Esempio (MongoDB Shell)Unisci condizioni e sottoquery correlate (MongoDB Shell)Sottoquery correlate utilizzando una sintassi concisa (MongoDB Shell)Fasi supportate nelle sottoquery correlate Esempi di codice Esempi di codice di sottoquery correlati

$lookup

La fase $lookup di aggregazione in Amazon DocumentDB consente di eseguire un join esterno sinistro tra due raccolte. Questa operazione consente di combinare i dati di più raccolte in base ai valori dei campi corrispondenti. È particolarmente utile quando è necessario incorporare dati provenienti da raccolte correlate nei risultati delle query.

Parametri

from: il nome della raccolta con cui eseguire il join.
localField: Il campo dei documenti di input da confrontare conforeignField.
foreignField: Il campo dei documenti della from raccolta da confrontare con illocalField.
as: il nome del nuovo campo da aggiungere ai documenti di output contenenti i documenti corrispondenti della from raccolta.
pipeline: Facoltativo se localField e foreignField sono specificati. Una pipeline di aggregazione da eseguire sulla from raccolta. La pipeline restituisce i documenti della raccolta. from Per restituire tutti i documenti, specificate una pipeline [] vuota. La pipeline non può includere le fasi $out o$merge. Consulta Unisci condizioni e sottoquery correlate (MongoDB Shell).
let: facoltativo. Un documento che definisce le variabili da utilizzare nelle pipeline fasi. Usa le espressioni variabili per accedere ai campi dei documenti di input che sono uniti apipeline. Per fare riferimento a una variabile nelle fasi della pipeline, utilizzate la "$$<variable>" sintassi. Consulta Unisci condizioni e sottoquery correlate (MongoDB Shell).

Esempio (MongoDB Shell)

L'esempio seguente dimostra una semplice $lookup operazione che unisce i dati della orders raccolta alla raccolta. customers

Crea documenti di esempio


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 }
]);

Esempio di interrogazione


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

Output


[
  {
    _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 } ]
  }
]

Unisci condizioni e sottoquery correlate (MongoDB Shell)

Nuovo dalla versione 8.0.2.

Oltre a una singola corrispondenza di uguaglianza, $lookup in Amazon DocumentDB è possibile eseguire una pipeline di aggregazione sulla raccolta unita. Ciò supporta le sottoquery non correlate, che eseguono la stessa sottoquery per ogni documento di input, e le sottoquery correlate, che utilizzano variabili definite dai campi di ciascun documento di input per restituire risultati correlati a quel documento.

Sintassi

Per eseguire una sottoquery correlata, definisci le variabili dai campi del documento di input con e fai riferimento ad esse nelle fasi: 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>
  }
}

Parametri

let: un documento che definisce le variabili dai campi dei documenti di input. Per fare riferimento a una variabile nelle fasi della pipeline, utilizzate la "$$<variable>" sintassi. È possibile accedere alle variabili dagli stadi inpipeline, inclusi gli $lookup stadi aggiuntivi annidati nel. pipeline Una $match fase richiede l'uso dell'$exproperatore per accedere alle variabili. Ometti let di eseguire una sottoquery non correlata.
pipeline: la pipeline di aggregazione da eseguire sulla raccolta. from La pipeline non può accedere direttamente ai campi dei documenti di input; definisce invece le variabili con le variabili let e fa riferimento alle variabili. Per restituire tutti i documenti, specificate una pipeline [] vuota.

Gli operatori $eq$gt, $gte$lt, e di $lte confronto inseriti in un $expr operatore all'interno di uno $match stadio possono utilizzare un indice sulla from raccolta quando confrontano un campo della raccolta unita con una let variabile o una costante.

Crea documenti di esempio


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 }
]);

Esempio di interrogazione

L'esempio seguente unisce ogni cliente ai propri ordini e mantiene solo gli ordini il cui valore total è maggiore o uguale al min_total valore proprio di quel cliente. La condizione di join e quella per cliente filtrano entrambe le variabili di riferimento all'interno: let $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"
    }
  }
]);

Output


[
  { _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: [] }
]

Per ogni cliente, la sottoquery viene valutata con i min_total valori del cliente _id e, pertanto, ogni documento riceve il proprio risultato correlato.

Sottoquery correlate utilizzando una sintassi concisa (MongoDB Shell)

Novità dalla versione 8.0.2.

Amazon DocumentDB supporta anche la sintassi concisa delle sottoquery correlate, che combina la corrispondenza di uguaglianza su e con un. localField foreignField pipeline La sintassi concisa elimina la necessità di esprimere la corrispondenza di uguaglianza all'interno di un operatore in una fase. $expr $match

Sintassi


{
  $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>
  }
}

Esempio di interrogazione

L'esempio seguente restituisce gli stessi risultati del precedente esempio di sottoquery correlata. La corrispondenza di uguaglianza tra _id e customer_id è espressa con localField e foreignField anziché con una $expr condizione:


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"
    }
  }
]);

Output


[
  { _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: [] }
]

Fasi supportate nelle sottoquery correlate

Quando viene utilizzata una $lookup pipelinelet, le seguenti fasi possono fare riferimento alle variabili: "$$<variable>"

$match(utilizzando l'$exproperatore)
$project
$addFields
$set
$group
$bucket
$bucketAuto
$sortByCount
$lookup(annidato)
$graphLookup

Anche gli stadi che non valutano espressioni variabili$sort, come$skip,$limit,$count,$sample, e $unwind$unset, possono essere utilizzati nella pipeline ma non possono fare riferimento alle variabili.

Le fasi seguenti non sono supportate in una $lookup pipeline che utilizzalet:$facet,$redact,$replaceRoot,,$replaceWith, $geoNear $setWindowFields$fill, e $match with. $text

Restrizioni

pipelineNon possono includere le $merge fasi $out o.

Esempi di codice

Per visualizzare un esempio di codice per l'utilizzo del $lookup comando, scegli la scheda relativa alla lingua che desideri utilizzare:

Esempi di codice di sottoquery correlati

Per visualizzare un esempio di codice per l'utilizzo $lookup dello stage con una sottoquery correlata (utilizzando let andpipeline), scegli la scheda relativa alla lingua che desideri utilizzare:

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()

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

$lte

$ltrim