Ejemplo (MongoDB Shell)Condiciones de unión y subconsultas correlacionadas (MongoDB Shell)Subconsultas correlacionadas mediante una sintaxis concisa (MongoDB Shell)Etapas compatibles en las subconsultas correlacionadas Ejemplos de código Ejemplos de códigos de subconsultas correlacionados

$lookup

La fase de $lookup agregación de Amazon DocumentDB le permite realizar una unión externa izquierda entre dos colecciones. Esta operación le permite combinar datos de varias colecciones en función de los valores de campo coincidentes. Resulta especialmente útil cuando necesita incorporar datos de colecciones relacionadas en los resultados de la consulta.

Parámetros

from: el nombre de la colección con la que se realizará la unión.
localField: El campo de los documentos de entrada con el que se compararáforeignField.
foreignField: El campo de los documentos de la from colección con el que se compararálocalField.
as: el nombre del nuevo campo que se va a añadir a los documentos de salida que contienen los documentos coincidentes de la from colección.
pipeline: Opcional si se foreignField especifican localField y se especifican. Una canalización de agregación para ejecutarse en la from colección. La canalización devuelve los documentos de la from colección. Para devolver todos los documentos, especifique una canalización vacía[]. La canalización no puede incluir las $merge etapas $out o. Consulte Condiciones de unión y subconsultas correlacionadas (MongoDB Shell).
let: opcional. Un documento que define las variables que se van a utilizar en las pipeline etapas. Utilice las expresiones variables para acceder a los campos desde los documentos de entrada que están unidos alpipeline. Para hacer referencia a una variable en las etapas del proceso, utilice la "$$<variable>" sintaxis. Consulte Condiciones de unión y subconsultas correlacionadas (MongoDB Shell).

Ejemplo (MongoDB Shell)

El siguiente ejemplo muestra una $lookup operación sencilla que une los datos de la orders colección con la customers colección.

Cree documentos de muestra


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

Ejemplo de consulta


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

Salida


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

Condiciones de unión y subconsultas correlacionadas (MongoDB Shell)

Nuevo a partir de la versión 8.0.2.

Además de una única igualación, $lookup en Amazon DocumentDB se puede ejecutar una canalización de agregación en la colección unida. Esto admite subconsultas no correlacionadas, que ejecutan la misma subconsulta para cada documento de entrada, y subconsultas correlacionadas, que utilizan variables definidas en los campos de cada documento de entrada para obtener resultados correlacionados con ese documento.

Sintaxis

Para ejecutar una subconsulta correlacionada, defina las variables de los campos del documento de entrada con y haga referencia a ellas en las etapas siguientes: 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>
  }
}

Parámetros

let: un documento que define las variables a partir de los campos de los documentos de entrada. Para hacer referencia a una variable en las etapas del proceso, utilice la "$$<variable>" sintaxis. Se puede acceder a las variables desde las etapas depipeline, incluidas $lookup las etapas adicionales anidadas en. pipeline Una $match etapa requiere el uso del $expr operador para acceder a las variables. Omita let ejecutar una subconsulta no correlacionada.
pipeline: la canalización de agregación que se ejecutará en la colección. from La canalización no puede acceder directamente a los campos de los documentos de entrada; en su lugar, defina las variables con ellas let y haga referencia a ellas. Para devolver todos los documentos, especifique una canalización vacía[].

Los operadores $eq$gt,$gte,$lt, y de $lte comparación colocados en un $expr operador dentro de una $match etapa pueden usar un índice en la from colección cuando comparan un campo de la colección combinada con una let variable o una constante.

Cree documentos de muestra


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

Ejemplo de consulta

El siguiente ejemplo une a cada cliente con sus pedidos y conserva solo los pedidos cuyo valor total es superior o igual al min_total valor propio de ese cliente. Tanto la condición de unión como el filtro por cliente hacen referencia a let las siguientes variables: $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"
    }
  }
]);

Salida


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

Para cada cliente, la subconsulta se evalúa con los min_total valores _id y de ese cliente, por lo que cada documento recibe su propio resultado correlacionado.

Subconsultas correlacionadas mediante una sintaxis concisa (MongoDB Shell)

Nuevo a partir de la versión 8.0.2.

Amazon DocumentDB también admite la sintaxis concisa de subconsultas correlacionadas, que combina la coincidencia de igualdad en y con un. localField foreignField pipeline La sintaxis concisa elimina el requisito de expresar la coincidencia de igualdad dentro de un operador en una $expr etapa. $match

Sintaxis


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

Ejemplo de consulta

El siguiente ejemplo devuelve los mismos resultados que el ejemplo anterior de subconsulta correlacionada. La coincidencia de igualdad entre _id y customer_id se expresa con localField y foreignField en lugar de una $expr condición:


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

Salida


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

Etapas compatibles en las subconsultas correlacionadas

Cuando se utiliza una $lookup canalizaciónlet, las siguientes etapas pueden hacer referencia a las "$$<variable>" variables:

$match(usando el $expr operador)
$project
$addFields
$set
$group
$bucket
$bucketAuto
$sortByCount
$lookup (anidado)
$graphLookup

Las etapas que no evalúan expresiones variables, como,$sort,,, y $skip$limit,$count,,$sample,$unwind,,$unset, también se pueden utilizar en el proceso, pero no pueden hacer referencia a las variables.

Las siguientes etapas no se admiten en una $lookup canalización que utilicelet: $facet $redact$replaceRoot,$replaceWith,$geoNear,$setWindowFields,$fill, y $match con$text.

Restricciones

pipelineNo pueden incluir las $merge etapas $out o.

Ejemplos de código

Para ver un ejemplo de código sobre el uso del $lookup comando, elija la pestaña correspondiente al idioma que desea usar:

Ejemplos de códigos de subconsultas correlacionados

Para ver un ejemplo de código sobre cómo usar el $lookup escenario con una subconsulta correlacionada (usando let ypipeline), elige la pestaña del idioma que quieres usar:

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

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

$lte

$ltrim