Beispiel (MongoDB Shell)Join-Bedingungen und korrelierte Unterabfragen (MongoDB Shell)Korrelierte Unterabfragen mit übersichtlicher Syntax (MongoDB Shell)Unterstützte Stufen in korrelierten Unterabfragen Codebeispiele Codebeispiele für korrelierte Unterabfragen

$lookup

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 sollforeignField.
foreignField: Das Feld aus den Dokumenten in der from Sammlung, das mit dem abgeglichen werden solllocalField.
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).
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 zuzugreifenpipeline. Verwenden Sie die "$$<variable>" Syntax, um in den Pipeline-Phasen auf eine Variable zu verweisen. Siehe Join-Bedingungen und korrelierte Unterabfragen (MongoDB Shell).

Beispiel (MongoDB Shell)

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)

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 werdenpipeline, 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 auslet, 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)

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

Wenn eine $lookup Pipeline verwendetlet, 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ütztlet: $replaceRoot$replaceWith,$geoNear,$setWindowFields,$fill, und $match with$text.

Einschränkungen

Die $merge Stufen $out oder pipeline können nicht enthalten.

Codebeispiele

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:

Codebeispiele für korrelierte Unterabfragen

Um ein Codebeispiel für die Verwendung der $lookup Stufe mit einer korrelierten Unterabfrage (mithilfe von let undpipeline) 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()

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

$lte

$ ltrim