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.

# $lookup
<a name="lookup"></a>

Die `$lookup` Aggregationsphase in Amazon DocumentDB ermöglicht es Ihnen, eine linke äußere Verknüpfung zwischen zwei Sammlungen durchzuführen. Mit diesem Vorgang können Sie Daten aus mehreren Sammlungen auf der Grundlage übereinstimmender Feldwerte kombinieren. Dies ist besonders nützlich, wenn Sie Daten aus verwandten Sammlungen in Ihre Abfrageergebnisse einbeziehen müssen.

**Parameter**
+ `from`: Der Name der Sammlung, mit der die Verknüpfung durchgeführt werden soll.
+ `localField`: Das Feld aus den Eingabedokumenten, das mit dem abgeglichen werden soll`foreignField`.
+ `foreignField`: Das Feld aus den Dokumenten in der `from` Sammlung, das mit dem abgeglichen werden soll`localField`.
+ `as`: Der Name des neuen Felds, das zu den Ausgabedokumenten hinzugefügt werden soll, die die passenden Dokumente aus der `from` Sammlung enthalten.
+ `pipeline`: Optional, wenn `localField` und angegeben `foreignField` sind. Eine Aggregationspipeline, die auf der `from` Sammlung ausgeführt werden soll. Die Pipeline gibt Dokumente aus der `from` Sammlung zurück. Um alle Dokumente zurückzugeben, geben Sie eine leere Pipeline an`[]`. Die Pipeline darf die `$merge` Stufen `$out` oder nicht enthalten. Siehe [Join-Bedingungen und korrelierte Unterabfragen (MongoDB Shell)](#lookup-correlated).
+ `let`: Optional. Ein Dokument, das Variablen definiert, die in den `pipeline` Phasen verwendet werden sollen. Verwenden Sie die Variablenausdrücke, um in den Eingabedokumenten, die mit dem verknüpft sind, auf die Felder zuzugreifen`pipeline`. Verwenden Sie die `"$$<variable>"` Syntax, um in den Pipeline-Phasen auf eine Variable zu verweisen. Siehe [Join-Bedingungen und korrelierte Unterabfragen (MongoDB Shell)](#lookup-correlated).

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

Das folgende Beispiel zeigt einen einfachen `$lookup` Vorgang, der Daten aus der `orders` Sammlung mit der `customers` Sammlung verknüpft.

**Erstellen Sie Beispieldokumente **

```
db.customers.insertMany([
  { _id: 1, name: "Alice" },
  { _id: 2, name: "Bob" },
  { _id: 3, name: "Charlie" }
]);

db.orders.insertMany([
  { _id: 1, customer_id: 1, total: 50 },
  { _id: 2, customer_id: 1, total: 100 },
  { _id: 3, customer_id: 2, total: 75 }
]);
```

**Beispiel für eine Abfrage **

```
db.customers.aggregate([
  {
    $lookup: {
      from: "orders",           
      localField: "_id",        
      foreignField: "customer_id", 
      as: "orders" 
    }
  }
]);
```

**Ausgabe**

```
[
  {
    _id: 1,
    name: 'Alice',
    orders: [
      { _id: 2, customer_id: 1, total: 100 },
      { _id: 1, customer_id: 1, total: 50 }
    ]
  },
  { _id: 3, name: 'Charlie', orders: [] },
  {
    _id: 2,
    name: 'Bob',
    orders: [ { _id: 3, customer_id: 2, total: 75 } ]
  }
]
```

## Join-Bedingungen und korrelierte Unterabfragen (MongoDB Shell)
<a name="lookup-correlated"></a>

Neu ab Version 8.0.2.

Zusätzlich zu einer einzelnen Gleichheitsübereinstimmung kann `$lookup` in Amazon DocumentDB eine Aggregationspipeline für die verknüpfte Sammlung ausgeführt werden. Dies unterstützt unkorrelierte Unterabfragen, die dieselbe Unterabfrage für jedes Eingabedokument ausführen, und korrelierte Unterabfragen, bei denen Variablen verwendet werden, die aus den Feldern der einzelnen Eingabedokumente definiert wurden, um Ergebnisse zurückzugeben, die mit diesem Dokument korreliert sind.

**Syntax**

Um eine korrelierte Unterabfrage auszuführen, definieren Sie Variablen aus den Feldern des Eingabedokuments mit und referenzieren Sie sie in den folgenden Schritten: `let` `pipeline`

```
{
  $lookup: {
    from: <collection to join>,
    let: { <var_1>: <expression>, ..., <var_n>: <expression> },
    pipeline: [ <pipeline to run on the joined collection> ],
    as: <output array field>
  }
}
```

**Parameter**
+ `let`: Ein Dokument, das Variablen aus den Feldern der Eingabedokumente definiert. Verwenden Sie die `"$$<variable>"` Syntax, um in den Pipeline-Phasen auf eine Variable zu verweisen. Auf die Variablen kann von den Stufen in der zugegriffen werden`pipeline`, einschließlich zusätzlicher `$lookup` Stufen, die in der `pipeline` verschachtelt sind. Eine `$match` Stufe erfordert die Verwendung des `$expr` Operators für den Zugriff auf die Variablen. Lassen Sie es aus`let`, um eine unkorrelierte Unterabfrage auszuführen.
+ `pipeline`: Die Aggregationspipeline, die für die Sammlung ausgeführt werden soll. `from` Die Pipeline kann nicht direkt auf Felder der Eingabedokumente zugreifen. Definieren Sie stattdessen Variablen mit den Variablen `let` und verweisen Sie auf die Variablen. Um alle Dokumente zurückzugeben, geben Sie eine leere Pipeline an`[]`.

Die Operatoren `$eq``$gt`, `$gte``$lt`, und die `$lte` Vergleichsoperatoren, die in einem `$expr` Operator innerhalb einer `$match` Stufe platziert sind, können einen Index für die `from` Sammlung verwenden, wenn sie ein Feld der verknüpften Sammlung mit einer `let` Variablen oder einer Konstanten vergleichen.

**Erstellen Sie Beispieldokumente **

```
db.customers.insertMany([
  { _id: 1, name: "Alice", min_total: 60 },
  { _id: 2, name: "Bob", min_total: 50 },
  { _id: 3, name: "Charlie", min_total: 20 }
]);

db.orders.insertMany([
  { _id: 1, customer_id: 1, total: 50 },
  { _id: 2, customer_id: 1, total: 100 },
  { _id: 3, customer_id: 2, total: 75 }
]);
```

**Beispiel für eine Abfrage **

Das folgende Beispiel verknüpft alle Kunden mit ihren Bestellungen und behält nur die Bestellungen bei, deren `total` Wert größer oder gleich dem eigenen `min_total` Wert des Kunden ist. Die Join-Bedingung und der Filter pro Kunde enthalten beide `let` Referenzvariablen: `$expr`

```
db.customers.aggregate([
  {
    $lookup: {
      from: "orders",
      let: { customer_id: "$_id", min_total: "$min_total" },
      pipeline: [
        {
          $match: {
            $expr: {
              $and: [
                { $eq: [ "$customer_id", "$$customer_id" ] },
                { $gte: [ "$total", "$$min_total" ] }
              ]
            }
          }
        },
        { $project: { _id: 0, total: 1 } }
      ],
      as: "qualifying_orders"
    }
  }
]);
```

**Ausgabe**

```
[
  { _id: 1, name: 'Alice', min_total: 60, qualifying_orders: [ { total: 100 } ] },
  { _id: 2, name: 'Bob', min_total: 50, qualifying_orders: [ { total: 75 } ] },
  { _id: 3, name: 'Charlie', min_total: 20, qualifying_orders: [] }
]
```

Für jeden Kunden wird die Unterabfrage anhand der `min_total` and-Werte dieses Kunden ausgewertet, sodass jedes Dokument sein eigenes korreliertes Ergebnis erhält. `_id`

## Korrelierte Unterabfragen mit übersichtlicher Syntax (MongoDB Shell)
<a name="lookup-concise-correlated"></a>

Neu ab Version 8.0.2.

Amazon DocumentDB unterstützt auch die präzise korrelierte Unterabfragesyntax, die den Gleichheitsvergleich auf und mit einem kombiniert. `localField` `foreignField` `pipeline` Durch die präzise Syntax entfällt die Anforderung, die Gleichheitsübereinstimmung innerhalb eines Operators in einer `$expr` Stufe auszudrücken. `$match`

**Syntax**

```
{
  $lookup: {
    from: <collection to join>,
    localField: <field from the input documents>,
    foreignField: <field from the documents of the "from" collection>,
    let: { <var_1>: <expression>, ..., <var_n>: <expression> },
    pipeline: [ <pipeline to run> ],
    as: <output array field>
  }
}
```

**Beispiel für eine Abfrage **

Das folgende Beispiel gibt dieselben Ergebnisse wie das vorherige Beispiel für eine korrelierte Unterabfrage zurück. Die Gleichheitsübereinstimmung zwischen `_id` und `customer_id` wird mit `localField` und `foreignField` anstelle einer `$expr` Bedingung ausgedrückt:

```
db.customers.aggregate([
  {
    $lookup: {
      from: "orders",
      localField: "_id",
      foreignField: "customer_id",
      let: { min_total: "$min_total" },
      pipeline: [
        { $match: { $expr: { $gte: [ "$total", "$$min_total" ] } } },
        { $project: { _id: 0, total: 1 } }
      ],
      as: "qualifying_orders"
    }
  }
]);
```

**Ausgabe**

```
[
  { _id: 1, name: 'Alice', min_total: 60, qualifying_orders: [ { total: 100 } ] },
  { _id: 2, name: 'Bob', min_total: 50, qualifying_orders: [ { total: 75 } ] },
  { _id: 3, name: 'Charlie', min_total: 20, qualifying_orders: [] }
]
```

## Unterstützte Stufen in korrelierten Unterabfragen
<a name="lookup-correlated-stages"></a>

Wenn eine `$lookup` Pipeline verwendet`let`, können die folgenden Stufen auf die `"$$<variable>"` Variablen verweisen:
+ `$match`(unter Verwendung des `$expr` Operators)
+ `$project`
+ `$addFields`
+ `$set`
+ `$group`
+ `$bucket`
+ `$bucketAuto`
+ `$sortByCount`
+ `$lookup`(verschachtelt)
+ `$graphLookup`

Stufen, die Variablenausdrücke nicht auswerten, wie`$sort`,`$skip`,`$limit`, und `$count``$sample`, und `$unwind``$unset`, können ebenfalls in der Pipeline verwendet werden, können aber nicht auf die Variablen verweisen.

Die folgenden Stufen werden in einer `$lookup` Pipeline, die Folgendes verwendet `$facet``$redact`, nicht unterstützt`let`: `$replaceRoot``$replaceWith`,`$geoNear`,`$setWindowFields`,`$fill`, und `$match` with`$text`.

**Einschränkungen**
+ Die `$merge` Stufen `$out` oder `pipeline` können nicht enthalten.

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

Um ein Codebeispiel für die Verwendung des `$lookup` Befehls 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 = await MongoClient.connect('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');

  await client.connect();

  const db = client.db('test');

  const result = await db.collection('customers').aggregate([
    {
      $lookup: {
        from: 'orders',
        localField: '_id',
        foreignField: 'customer_id',
        as: 'orders'
      }
    }
  ]).toArray();

  console.log(JSON.stringify(result, null, 2));
  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')

    db = client.test
    
    collection = db.customers

    pipeline = [
        {
            "$lookup": {
                "from": "orders",
                "localField": "_id",
                "foreignField": "customer_id",
                "as": "orders"
            }
        }
    ]

    result = collection.aggregate(pipeline)

    for doc in result:
        print(doc)

    client.close()

example()
```

------

## Codebeispiele für korrelierte Unterabfragen
<a name="lookup-correlated-code"></a>

Um ein Codebeispiel für die Verwendung der `$lookup` Stufe mit einer korrelierten Unterabfrage (mithilfe von `let` und`pipeline`) 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 = await MongoClient.connect('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');

  const db = client.db('test');

  const customers = db.collection('customers');
  await customers.insertMany([
    { _id: 1, name: "Alice", min_total: 60 },
    { _id: 2, name: "Bob", min_total: 50 },
    { _id: 3, name: "Charlie", min_total: 20 }
  ]);
  const orders = db.collection('orders');
  await orders.insertMany([
    { _id: 1, customer_id: 1, total: 50 },
    { _id: 2, customer_id: 1, total: 100 },
    { _id: 3, customer_id: 2, total: 75 }
  ]);

  // Correlated subquery: filter each customer's orders with a per-customer threshold
  const result = await customers.aggregate([
    {
      $lookup: {
        from: 'orders',
        localField: '_id',
        foreignField: 'customer_id',
        let: { min_total: '$min_total' },
        pipeline: [
          { $match: { $expr: { $gte: [ '$total', '$$min_total' ] } } },
          { $project: { _id: 0, total: 1 } }
        ],
        as: 'qualifying_orders'
      }
    }
  ]).toArray();

  console.log(JSON.stringify(result, null, 2));
  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')

    db = client.test

    customers = db.customers
    customers.insert_many([
        { "_id": 1, "name": "Alice", "min_total": 60 },
        { "_id": 2, "name": "Bob", "min_total": 50 },
        { "_id": 3, "name": "Charlie", "min_total": 20 }
    ])
    orders = db.orders
    orders.insert_many([
        { "_id": 1, "customer_id": 1, "total": 50 },
        { "_id": 2, "customer_id": 1, "total": 100 },
        { "_id": 3, "customer_id": 2, "total": 75 }
    ])

    # Correlated subquery: filter each customer's orders with a per-customer threshold
    pipeline = [
        {
            "$lookup": {
                "from": "orders",
                "localField": "_id",
                "foreignField": "customer_id",
                "let": { "min_total": "$min_total" },
                "pipeline": [
                    { "$match": { "$expr": { "$gte": [ "$total", "$$min_total" ] } } },
                    { "$project": { "_id": 0, "total": 1 } }
                ],
                "as": "qualifying_orders"
            }
        }
    ]

    result = customers.aggregate(pipeline)

    for doc in result:
        print(doc)

    client.close()

example()
```

------