Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# $ setzen WindowFields
<a name="setWindowFields"></a>

Neu ab Version 8.0.2.

Die `$setWindowFields` Phase in Amazon DocumentDB führt Operationen für einen bestimmten Bereich von Dokumenten (ein * Fenster*) in einer Partition durch und gibt die Ergebnisse auf der Grundlage des ausgewählten Fensteroperators zurück. Die Phase gruppiert die Eingabedokumente in Partitionen, sortiert sie optional und berechnet für jedes Dokument ein oder mehrere Ausgabefelder über ein Fenster mit umgebenden Dokumenten.

**Syntax**

```
{
  $setWindowFields: {
    partitionBy: <expression>,
    sortBy: { <sortField1>: <sortOrder>, ... },
    output: {
      <outputField1>: {
        <windowOperator>: <expression>,
        window: {
          documents: [ <lowerBound>, <upperBound> ],
          range: [ <lowerBound>, <upperBound> ],
          unit: <time unit>
        }
      },
      ...
    }
  }
}
```

**Parameter**
+ `partitionBy`: Optional. Ein einzelner Ausdruck, der verwendet wird, um die Dokumente in Partitionen zu gruppieren. Dies kann ein Feldpfad (z. B.`"$state"`) oder ein anderer Ausdruck sein. Wenn es weggelassen wird, gehören alle Eingabedokumente zu einer einzigen Partition.
+ `sortBy`: Optional. Ein Dokument, das das Feld oder die Felder angibt, nach denen die Dokumente in jeder Partition sortiert werden sollen, und zwar in der Form `{ <field>: 1 }` für aufsteigende oder `{ <field>: -1 }` für absteigende Reihenfolge. A `sortBy` ist erforderlich, wenn Sie dokument- oder bereichsbasierte Fenstergrenzen verwenden und wenn Sie einen der Operatoren für die Rangfolge verwenden.
+ `output`: Erforderlich. Ein Dokument, das die Felder angibt, die an jedes Dokument angehängt werden sollen. Sie können mehrere Ausgabefelder angeben, aber jedes Ausgabefeld benötigt genau einen Fensteroperator, sein Argument und ein optionales `window` Dokument, das die Fenstergrenzen definiert:`{ <field>: { <windowOperator>: <expression>, window: { ... } } }`.

## Fenstergrenzen
<a name="setWindowFields-bounds"></a>

In jedem `output` Feld können Sie optional die Fenstergrenzen mit einem `window` Dokument definieren. Ein Fenster kann anhand der Dokumentposition oder anhand eines Wertebereichs definiert werden.
+ `documents`: Gibt das Fenster als eine Anzahl von Dokumenten vor und nach dem aktuellen Dokument im Formular an`[ <lowerBound>, <upperBound> ]`. Jede Grenze ist ein Ganzzahl-Offset (z. B. `-1` oder`2`) oder eines der Schlüsselwörter `"unbounded"` und`"current"`. `"unbounded"`erweitert das Fenster bis zum Anfang der Partition, wenn es als Untergrenze verwendet wird, oder bis zum Ende der Partition, wenn es als Obergrenze verwendet wird. `"current"`bedeutet das aktuelle Dokument. Ein `documents` Fenster benötigt einen, `sortBy` es sei denn, beide Grenzen sind `"unbounded"` gleich.
+ `range`: Gibt das Fenster als einen Bereich von `sortBy` Feldwerten im Verhältnis zum aktuellen Dokument im Formular `[ <lowerBound>, <upperBound> ]` an. Jede Grenze ist eine Zahl, die dem `sortBy` Wert des aktuellen Dokuments oder dem `"unbounded"` Schlüsselwort hinzugefügt wird. Ein `range` Fenster benötigt genau ein aufsteigendes `sortBy` Feld und akzeptiert das `"current"` Schlüsselwort nicht.
+ `unit`: Optional. Wird verwendet`range`, um die numerischen Fenstergrenzen als Zeitspanne zu interpretieren, in der das `sortBy` Feld Datumswerte enthält. Amazon DocumentDB unterstützt die folgenden Einheiten: `"year"``"quarter"`,`"month"`,`"week"`,,`"day"`, `"hour"` `"minute"``"second"`, und. `"millisecond"` Wenn `unit` angegeben, müssen die `range` Grenzen ganze Zahlen sein.

Wenn das `window` Dokument weggelassen wird, wird das Standardfenster verwendet`documents: ["unbounded", "unbounded"]`, das sich über die gesamte Partition erstreckt.

**Anmerkung**  
Wenn Sie ein `range` Fenster verwenden, das Datumswerten vorzieht, empfehlen wir eine feste Dauer `unit` wie `"day"` (oder kleiner) und nicht, oder `"month"` `"quarter"``"year"`, deren kalenderabhängige Länge zu mehrdeutigen Fenstergrenzen führen kann.

## Unterstützte Fensteroperatoren
<a name="setWindowFields-operators"></a>

Amazon DocumentDB unterstützt die folgenden 26 Fensteroperatoren im `output` Bereich der `$setWindowFields` Bühne:
+ `$sum`
+ `$avg`
+ `$count`
+ `$push`
+ `$addToSet`
+ `$stdDevPop`
+ `$stdDevSamp`
+ `$covariancePop`
+ `$covarianceSamp`
+ `$first`
+ `$last`
+ `$firstN`
+ `$lastN`
+ `$top`
+ `$bottom`
+ `$topN`
+ `$bottomN`
+ `$min`
+ `$minN`
+ `$max`
+ `$maxN`
+ `$median`
+ `$percentile`
+ `$rank`
+ `$denseRank`
+ `$documentNumber`

**Anmerkung**  
Der `$rand` Operator wird innerhalb eines Fensteroperators in der `$setWindowFields` Bühne nicht unterstützt.

**Leere Fenster **

Wenn ein Fenster keine Dokumente enthält (z. B. ein `range` Fenster ohne Werte im Bereich), hängt das Ergebnis vom Operator ab: `$count` und gibt `$sum` zurück`0`;`$push`,,,,,,, `$addToSet` `$firstN` `$lastN` `$minN` `$maxN``$topN`, und gibt ein leeres Array `$percentile` zurück; gibt ein Array von `null` Werten zurück (einen pro angefordertem Perzentil); alle anderen Operatoren `$bottomN` kehren zurück. `null`

## Beispiel (MongoDB Shell)
<a name="setWindowFields-examples"></a>

Das folgende Beispiel partitioniert die Dokumente nach`region`, sortiert jede Partition nach `day` und berechnet eine laufende Summe `revenue` vom Anfang der Partition bis zum aktuellen Dokument.

**Erstellen Sie Beispieldokumente **

```
db.sales.insertMany([
  { _id: 1, region: "east", day: 1, revenue: 100 },
  { _id: 2, region: "east", day: 2, revenue: 150 },
  { _id: 3, region: "east", day: 3, revenue: 120 },
  { _id: 4, region: "west", day: 1, revenue: 200 },
  { _id: 5, region: "west", day: 2, revenue: 180 }
]);
```

**Beispiel für eine Abfrage **

```
db.sales.aggregate([
  {
    $setWindowFields: {
      partitionBy: "$region",
      sortBy: { day: 1 },
      output: {
        runningRevenue: {
          $sum: "$revenue",
          window: { documents: ["unbounded", "current"] }
        }
      }
    }
  }
]);
```

**Ausgabe**

```
[
  { "_id": 1, "region": "east", "day": 1, "revenue": 100, "runningRevenue": 100 },
  { "_id": 2, "region": "east", "day": 2, "revenue": 150, "runningRevenue": 250 },
  { "_id": 3, "region": "east", "day": 3, "revenue": 120, "runningRevenue": 370 },
  { "_id": 4, "region": "west", "day": 1, "revenue": 200, "runningRevenue": 200 },
  { "_id": 5, "region": "west", "day": 2, "revenue": 180, "runningRevenue": 380 }
]
```

Jedes Dokument wird um die kumulative Summe `revenue` innerhalb seiner Partition bis einschließlich des aktuellen Dokuments erweitert. `runningRevenue`

## Codebeispiele
<a name="setWindowFields-code"></a>

Um ein Codebeispiel für die Verwendung der `$setWindowFields` Bühne anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:

------
#### [ Node.js ]

```
const { MongoClient } = require('mongodb');

async function example() {
  const client = new MongoClient('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');

  try {
    await client.connect();
    const db = client.db('test');
    const sales = db.collection('sales');

    await sales.insertMany([
      { _id: 1, region: "east", day: 1, revenue: 100 },
      { _id: 2, region: "east", day: 2, revenue: 150 },
      { _id: 3, region: "east", day: 3, revenue: 120 },
      { _id: 4, region: "west", day: 1, revenue: 200 },
      { _id: 5, region: "west", day: 2, revenue: 180 }
    ]);

    const result = await sales.aggregate([
      {
        $setWindowFields: {
          partitionBy: "$region",
          sortBy: { day: 1 },
          output: {
            runningRevenue: {
              $sum: "$revenue",
              window: { documents: ["unbounded", "current"] }
            }
          }
        }
      }
    ]).toArray();

    console.log(result);
  } finally {
    await client.close();
  }
}

example();
```

------
#### [ Python ]

```
from pymongo import MongoClient

def example():
    client = MongoClient('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')

    try:
        db = client['test']
        sales = db['sales']

        sales.insert_many([
            { '_id': 1, 'region': 'east', 'day': 1, 'revenue': 100 },
            { '_id': 2, 'region': 'east', 'day': 2, 'revenue': 150 },
            { '_id': 3, 'region': 'east', 'day': 3, 'revenue': 120 },
            { '_id': 4, 'region': 'west', 'day': 1, 'revenue': 200 },
            { '_id': 5, 'region': 'west', 'day': 2, 'revenue': 180 }
        ])

        result = list(sales.aggregate([
            {
                '$setWindowFields': {
                    'partitionBy': '$region',
                    'sortBy': { 'day': 1 },
                    'output': {
                        'runningRevenue': {
                            '$sum': '$revenue',
                            'window': { 'documents': ['unbounded', 'current'] }
                        }
                    }
                }
            }
        ]))

        print(result)
    finally:
        client.close()

example()
```

------