/ /

Operadores

Etapas de la pipeline de agregación

Docs Home

Manual de base de datos

Referencia

Operadores

Etapas de la pipeline de agregación

$lookup (agregación)

Esta versión de la documentación está archivada y ya no recibe soporte. Para actualizar su implementación 6.0, consulte Procedimientos de actualización de MongoDB.7.0

Definición

$lookup

Cambiado en la versión 5.1.

Realiza una unión externa izquierda con una colección en la misma base de datos para filtrar documentos de la colección extranjera para su procesamiento. La etapa $lookup añade un nuevo campo de arreglo a cada documento de entrada. El nuevo campo de arreglo contiene los documentos coincidentes de la colección externa. La etapa $lookup pasa estos documentos reformateados a la siguiente etapa.

A partir de MongoDB 5.1, puedes usar $lookup con colecciones sharded.

Para combinar elementos de dos colecciones diferentes, utilice el $unionWith Etapa de tubería.

Compatibilidad

Puedes usar $lookup para implementaciones alojadas en los siguientes entornos:

MongoDB Atlas: El servicio totalmente gestionado para implementaciones de MongoDB en la nube

MongoDB Enterprise: La versión basada en suscripción y autogestionada de MongoDB
MongoDB Community: La versión de MongoDB con código fuente disponible, de uso gratuito y autogestionada.

Sintaxis

La sintaxis de la etapa $lookup:

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

$lookup acepta un documento con estos campos:

Campo	Necesidad	Descripción
de	Requerido	Especifica la colección foránea en la misma base de datos para unirse a la colección local. Es posible en algunos casos límite que se sustituyan `from` por `pipeline` usando `$documents` como la primera etapa. Para un ejemplo, vea Usar una etapa `$documents` en una etapa `$lookup`. A partir de MongoDB 5.1, la colección `from` se puede fragmentar.
localField	Opcional si se especifica `pipeline`	Especifica el campo de la entrada de documentos para la etapa `$lookup`. `$lookup` realiza una coincidencia exacta en el `localField` con el `foreignField` de los documentos de la colección `from`. Si un documento de entrada no contiene el `localField`, el `$lookup` trata el campo como si tuviera un valor de `null` para fines de coincidencia.
foreignField	Opcional si se especifica `pipeline`	Especifica los `foreignField` de los documentos foráneos para realizar una coincidencia exacta con los `localField` de los documentos locales. Si un documento foráneo no contiene un valor `foreignField`, `$lookup` utiliza un valor `null` para la coincidencia.
permitir	Opcional	Especifica las variables que se deben usar en las etapas de la pipeline. Utiliza las expresiones de variables para acceder a los campos de los documentos de la colección local que se ingresan en `pipeline`. Para referenciar variables en las etapas de un pipeline, utiliza la sintaxis `"$$<variable>"`. Se puede acceder a las variables let por las etapas de la pipeline, incluidas las etapas adicionales`$lookup` anidadas en el `pipeline`. Una etapa `$match` requiere el uso de un operador `$expr` para acceder a las variables. El operador `$expr` permite el uso de expresiones de agregación dentro de la sintaxis de `$match`. Los operadores de comparación `$eq`, `$lt`, `$lte`, `$gt` y `$gte` colocados en un operador `$expr` pueden utilizar un índice en la colección `from` referenciada en una etapa `$lookup`. Limitaciones: Los índices solo pueden utilizarse para comparaciones entre campos y constantes, por lo que el operando `let` debe resolverse en una constante. Por ejemplo, una comparación entre `$a` y un valor constante puede utilizar un índice, pero una comparación entre `$a` y `$b` no puede. Los índices no se utilizan para comparaciones donde el operando `let` se resuelve en un valor vacío o faltante. Los índices multiclave no se utilizan. Otras etapas (no`$match`) de la pipeline no requieren un operador `$expr`para acceder a las variables.
pipeline	Opcional si se especifican `localField` y `foreignField`	Especifica el `pipeline` que se ejecutará en la colección foránea. El `pipeline` devuelve documentos de la colección externa. Para devolver todos los documentos, especifica un `pipeline: []` vacío. El `pipeline` no puede incluir las etapas ni. A partir de `$out` `$merge` la6.0 versión, el `pipeline` puede contener la etapa de Atlas Search `$search` como la primera etapa dentro del pipeline. Para obtener más información, consulte el soporte de Atlas Search. El `pipeline` no puede acceder a los campos de los documentos de entrada. En su lugar, defina variables para los campos del documento usando la opción let y luego haga referencia a las variables en las etapas `pipeline`. Para referenciar variables en las etapas de un pipeline, utiliza la sintaxis `"$$<variable>"`. Se puede acceder a las variables let por las etapas de la pipeline, incluidas las etapas adicionales`$lookup` anidadas en el `pipeline`. Una etapa `$match` requiere el uso de un operador `$expr` para acceder a las variables. El operador `$expr` permite el uso de expresiones de agregación dentro de la sintaxis de `$match`. Los operadores de comparación `$eq`, `$lt`, `$lte`, `$gt` y `$gte` colocados en un operador `$expr` pueden utilizar un índice en la colección `from` referenciada en una etapa `$lookup`. Limitaciones: Los índices solo pueden utilizarse para comparaciones entre campos y constantes, por lo que el operando `let` debe resolverse en una constante. Por ejemplo, una comparación entre `$a` y un valor constante puede utilizar un índice, pero una comparación entre `$a` y `$b` no puede. Los índices no se utilizan para comparaciones donde el operando `let` se resuelve en un valor vacío o faltante. Los índices multiclave no se utilizan. Otras etapas (no`$match`) de la pipeline no requieren un operador `$expr`para acceder a las variables.
como	Requerido	Especifica el nombre del nuevo campo de arreglo que se añadirá a los documentos de entrada. El nuevo campo de arreglo contiene los documentos coincidentes de la colección `from`. Si el nombre especificado ya existe en el documento de entrada, el campo existente se sobrescribe.

Coincidencia exacta con una única condición de unión

Para realizar una coincidencia exacta entre un campo de los documentos de entrada y un campo de los documentos de la colección externa, la etapa $lookup tiene esta sintaxis:

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

Nota

En este ejemplo, pipeline es opcional y se ejecuta después de la etapa de igualdad local y foránea.

La operación corresponde a esta instrucción pseudo-SQL:

SELECT *, (
   SELECT ARRAY_AGG(*)
   FROM <collection to join>
   WHERE <foreignField> = <collection.localField>
) AS <output array field>
FROM collection;

Nota

Las instrucciones SQL de esta página se incluyen para compararlas con la sintaxis de la pipeline de agregación de MongoDB. Las instrucciones SQL no son ejecutables.

Para ejemplos de MongoDB, consulte estas páginas:

Realice una única unión de igualdad con $lookup
Utiliza $lookup con un arreglo
Use $lookup con $mergeObjects

Condiciones de unión y sub-query en una colección foránea

MongoDB admite:

Ejecución de una pipeline en una colección externa.
Múltiples condiciones de combinación.
Subconsultas correlacionadas y no correlacionadas.

En MongoDB, un sub-query no correlacionado significa que cada documento de entrada arrojará el mismo resultado. Un sub-query correlacionado es un pipeline en una etapa$lookup que utiliza los campos de la colección local o input para arrojar resultados correlacionados con cada documento entrante.

Nota

A partir de MongoDB 5.0, para un subquery no correlacionado en una etapa de la pipeline de $lookup que contenga una etapa $sample, el operador $sampleRate o el operador $rand, el subquery siempre se ejecuta nuevamente si se repite. Anteriormente, según el tamaño del resultado del subquery, se almacenaba en caché o el subquery se ejecutaba nuevamente.

Las sub-query correlacionadas de MongoDB son comparables a las sub-query correlacionadas de SQL, donde la query interna hace referencia a los valores externos de la query. Una sub-query no correlacionada de SQL no hace referencia a valores de la query externa.

MongoDB 5.0 también soporta a los subquery correlacionados concisos.

Para realizar los subquery correlacionados y no correlacionados con dos colecciones, y realizar otras condiciones de unión además de una única coincidencia exacta, utiliza esta sintaxis de $lookup:

{
   $lookup:
      {
         from: <foreign collection>,
         let: { <var_1>: <expression>, …, <var_n>: <expression> },
         pipeline: [ <pipeline to run on foreign collection> ],
         as: <output array field>
      }
}

La operación corresponde a esta instrucción pseudo-SQL:

SELECT *, <output array field>
FROM collection
WHERE <output array field> IN (
   SELECT <documents as determined from the pipeline>
   FROM <collection to join>
   WHERE <pipeline>
);

Vea los siguientes ejemplos:

Realizar múltiples uniones y una subconsulta correlacionada con $lookup
Realice una sub-query no correlacionada con $lookup

Subconsultas correlacionadas utilizando una sintaxis concisa

Nuevo en la versión 5.0.

A partir de MongoDB 5.0, puedes usar una sintaxis concisa para una sub-query correlacionada. Las sub-query correlacionadas hacen referencia a campos de documentos de una colección foránea y de la colección "local" en la que se ejecutó el método aggregate().

La siguiente nueva sintaxis concisa elimina el requisito de una coincidencia exacta en los campos foráneo y local dentro de un operador $expr:

{
   $lookup:
      {
         from: <foreign collection>,
         localField: <field from local collection's documents>,
         foreignField: <field from foreign collection's documents>,
         let: { <var_1>: <expression>, …, <var_n>: <expression> },
         pipeline: [ <pipeline to run> ],
         as: <output array field>
      }
}

La operación corresponde a esta instrucción pseudo-SQL:

SELECT *, <output array field>
FROM localCollection
WHERE <output array field> IN (
   SELECT <documents as determined from the pipeline>
   FROM <foreignCollection>
   WHERE <foreignCollection.foreignField> = <localCollection.localField>
   AND <pipeline match condition>
);

Vea este ejemplo:

Realice una sub-query correlacionada concisa con $lookup

Comportamiento

Vistas e intercalación

Si realizas una agregación que implique varias vistas, como con $lookup o $graphLookup, las vistas deben tener la misma intercalación.

Restricciones

No puedes incluir la etapa $out o la etapa $merge en la etapa $lookup. Es decir, al especificar un pipeline para la colección foránea, no puedes incluir ninguna de las etapas en el campo pipeline.

{
   $lookup:
   {
      from: <collection to join>,
      let: { <var_1>: <expression>, …, <var_n>: <expression> },
      pipeline: [ <pipeline to execute on the foreign collection> ],  // Cannot include $out or $merge
      as: <output array field>
   }
}

Soporte de búsqueda en Atlas

A partir de MongoDB,6.0 puede especificar la etapa de búsqueda $search de Atlas o en $searchMeta la $lookup canalización para buscar colecciones en el clúster de Atlas. La $search etapa o debe ser la primera dentro de la $searchMeta $lookup canalización.

Por ejemplo, cuando unes condiciones y sub-query en una colección foránea o ejecutas sub-query correlacionados usando una sintaxis concisa, puedes especificar $search o $searchMeta dentro del pipeline, como se muestra a continuación:

[{
  "$lookup": {
    "from": <foreign collection>,
    localField: <field from the input documents>,
    foreignField: <field from the documents of the "from" collection>,
    "as": <output array field>,
    "pipeline": [{
      "$search": {
        "<operator>": {
          <operator-specification>
        }
      },
      ...
    }]
  }
}]

[{
  "$lookup": {
    "from": <foreign collection>,
    localField: <field from the input documents>,
    foreignField: <field from the documents of the "from" collection>,
    "as": <output array field>,
    "pipeline": [{
      "$searchMeta": {
        "<collector>": {
          <collector-specification>
        }
      },
      ...
    }]
  }
}]

Para ver un ejemplo de $lookup con, consulte el tutorial $search de búsqueda en Atlas Ejecutar una consulta de búsqueda en Atlas $search usando $lookup.

Colecciones fragmentadas

A partir de MongoDB 5.1, puedes especificar sharded collections en el parámetro from de las etapas de $lookup.

No se puede usar la etapa $lookup dentro de una transacción durante el direccionamiento a una colección fragmentada.

Motor de ejecución de query basado en ranuras

Nota

A partir de la versión 6.0.18, el motor de consultas de ejecución basado en ranuras ya no está habilitado de forma predeterminada en las versiones de parche de 6.0. Si desea que sus consultas utilicen el motor de consultas de ejecución basado en ranuras, actualice a la versión 8.0, donde está habilitado de forma predeterminada.

A partir de la 6.0 versión, MongoDB puede usar el motor de consultas de ejecución basado en ranuras para ejecutar $lookup etapas si todas las etapas anteriores en la canalización también pueden ser ejecutadas por el motor basado en ranuras y ninguna de las siguientes condiciones es verdadera:

La operación $lookup ejecuta una pipeline en una colección externa. Para ver un ejemplo de este tipo de operación, consulta Condiciones de unión y subconsultas en una colección externa.
Los localField o foreignField de $lookup especifican componentes numéricos. Por ejemplo: { localField: "restaurant.0.review" }.
El campo from de cualquier $lookup en el pipeline especifica una vista o una colección fragmentada.

Para obtener más información, consulta $lookupOptimización.

Consideraciones sobre el rendimiento

$lookup el rendimiento depende del tipo de operación que se realice. Consulta la siguiente tabla para las consideraciones de rendimiento de las diferentes operaciones de $lookup.

`$lookup` Operación	Consideraciones sobre el rendimiento
Coincidencia exacta con una sola unión	`$lookup` Las operaciones que realizan coincidencias exactas con una sola unión funcionan mejor cuando la colección externa contiene un índice en el `foreignField`. IMPORTANTE: si no existe un índice de apoyo en el `foreignField`, es probable que una operación `$lookup` que realice una coincidencia exacta con una sola unión tenga un rendimiento deficiente.
Subconsultas no correlacionadas	`$lookup` operaciones que contienen subqueries no correlacionadas funcionan mejor cuando el pipeline interno puede acceder a un índice de la colección externa. MongoDB solo necesita ejecutar una vez la subquery `$lookup` antes de almacenar en caché la query porque no hay relación entre las colecciones de origen y las externas. La subquery no se basa en ningún valor de la colección de origen. Este comportamiento mejora el rendimiento para las ejecuciones posteriores de la operación `$lookup`.
Subconsultas correlacionadas	`$lookup` operaciones que contienen subqueries correlacionadas tienen un mejor rendimiento cuando se aplican las siguientes condiciones: La colección foránea contiene un índice en el `foreignField`. La colección foránea contiene un índice que hace referencia a la pipeline interna. Si tu pipeline pasa una gran cantidad de documentos a la query`$lookup`, las siguientes estrategias pueden mejorar el rendimiento: Reduce el número de documentos que MongoDB pasa a la query `$lookup`. Por ejemplo, establece un filtro más estricto durante la etapa `$match`. Ejecute la pipeline interna de la sub-query `$lookup` como query independiente y use `$out` para crear una colección temporal. Luego, ejecute una coincidencia exacta con una sola unión. Reconsidere el esquema de los datos para asegurarse de que sea óptimo para el caso de uso.

Para estrategias generales de rendimiento, consulta las Estrategias de indexación y Optimización de query.

Importante

El uso excesivo de $lookup en una consulta puede ralentizar el rendimiento. Para evitar múltiples $lookup etapas de, considere un modelo de datos integrado para optimizar el rendimiento de la consulta.

Ejemplos

Realice una única unión de igualdad con `$lookup`

Cree una colección orders con estos documentos:

db.orders.insertMany( [
   { _id: 1, item: "almonds", price: 12, quantity: 2 },
   { _id: 2, item: "pecans", price: 20, quantity: 1 },
   { _id: 3  }
] )

Cree otra colección inventory con estos documentos:

db.inventory.insertMany( [
   { _id: 1, sku: "almonds", description: "product 1", instock: 120 },
   { _id: 2, sku: "bread", description: "product 2", instock: 80 },
   { _id: 3, sku: "cashews", description: "product 3", instock: 60 },
   { _id: 4, sku: "pecans", description: "product 4", instock: 70 },
   { _id: 5, sku: null, description: "Incomplete" },
   { _id: 6 }
] )

La siguiente operación de agregación en la colección orders une los documentos de orders con los documentos de la colección inventory utilizando los campos item de la colección orders y el campo sku de la colección inventory:

db.orders.aggregate( [
   {
     $lookup:
       {
         from: "inventory",
         localField: "item",
         foreignField: "sku",
         as: "inventory_docs"
       }
  }
] )

La operación devuelve estos documentos:

{
   _id: 1,
   item: "almonds",
   price: 12,
   quantity: 2,
   inventory_docs: [
      { _id: 1, sku: "almonds", description: "product 1", instock: 120 }
   ]
}
{
   _id: 2,
   item: "pecans",
   price: 20,
   quantity: 1,
   inventory_docs: [
      { _id: 4, sku: "pecans", description: "product 4", instock: 70 }
   ]
}
{
   _id: 3,
   inventory_docs: [
      { _id: 5, sku: null, description: "Incomplete" },
      { _id: 6 }
   ]
}

La operación corresponde a esta instrucción pseudo-SQL:

SELECT *, inventory_docs
FROM orders
WHERE inventory_docs IN (
   SELECT *
   FROM inventory
   WHERE sku = orders.item
);

Para obtener más información, consulta Consideraciones sobre el rendimiento de la coincidencia exacta.

Utilice `$lookup` con una matriz

Si el localField es un arreglo, puedes comparar los elementos del arreglo contra un escalar foreignField sin una etapa de $unwind.

Por ejemplo, cree una colección de ejemplo classes con estos documentos:

db.classes.insertMany( [
   { _id: 1, title: "Reading is ...", enrollmentlist: [ "giraffe2", "pandabear", "artie" ], days: ["M", "W", "F"] },
   { _id: 2, title: "But Writing ...", enrollmentlist: [ "giraffe1", "artie" ], days: ["T", "F"] }
] )

Cree otra colección members con estos documentos:

db.members.insertMany( [
   { _id: 1, name: "artie", foreign: new Date("2016-05-01"), status: "A" },
   { _id: 2, name: "giraffe", foreign: new Date("2017-05-01"), status: "D" },
   { _id: 3, name: "giraffe1", foreign: new Date("2017-10-01"), status: "A" },
   { _id: 4, name: "panda", foreign: new Date("2018-10-11"), status: "A" },
   { _id: 5, name: "pandabear", foreign: new Date("2018-12-01"), status: "A" },
   { _id: 6, name: "giraffe2", foreign: new Date("2018-12-01"), status: "D" }
] )

La siguiente operación de agregación une documentos de la colección classes con la colección members, emparejando el campo enrollmentlist con el campo name:

db.classes.aggregate( [
   {
      $lookup:
         {
            from: "members",
            localField: "enrollmentlist",
            foreignField: "name",
            as: "enrollee_info"
        }
   }
] )

La operación devuelve lo siguiente:

{
   _id: 1,
   title: "Reading is ...",
   enrollmentlist: [ "giraffe2", "pandabear", "artie" ],
   days: [ "M", "W", "F" ],
   enrollee_info: [
      { _id: 1, name: "artie", foreign: ISODate("2016-05-01T00:00:00Z"), status: "A" },
      { _id: 5, name: "pandabear", foreign: ISODate("2018-12-01T00:00:00Z"), status: "A" },
      { _id: 6, name: "giraffe2", foreign: ISODate("2018-12-01T00:00:00Z"), status: "D" }
   ]
}
{
   _id: 2,
   title: "But Writing ...",
   enrollmentlist: [ "giraffe1", "artie" ],
   days: [ "T", "F" ],
   enrollee_info: [
      { _id: 1, name: "artie", foreign: ISODate("2016-05-01T00:00:00Z"), status: "A" },
      { _id: 3, name: "giraffe1", foreign: ISODate("2017-10-01T00:00:00Z"), status: "A" }
   ]
}

Usa `$lookup` con `$mergeObjects`

El $mergeObjects operador combina múltiples documentos en un único documento.

Cree una colección orders con estos documentos:

db.orders.insertMany( [
   { _id: 1, item: "almonds", price: 12, quantity: 2 },
   { _id: 2, item: "pecans", price: 20, quantity: 1 }
] )

Cree otra colección items con estos documentos:

db.items.insertMany( [
  { _id: 1, item: "almonds", description: "almond clusters", instock: 120 },
  { _id: 2, item: "bread", description: "raisin and nut bread", instock: 80 },
  { _id: 3, item: "pecans", description: "candied pecans", instock: 60 }
] )

La siguiente operación primero utiliza la etapa $lookup para unir las dos colecciones por los campos item y luego utiliza $mergeObjects en $replaceRoot para fusionar los documentos externos de items y orders:

db.orders.aggregate( [
   {
      $lookup: {
         from: "items",
         localField: "item",    // field in the orders collection
         foreignField: "item",  // field in the items collection
         as: "fromItems"
      }
   },
   {
      $replaceRoot: { newRoot: { $mergeObjects: [ { $arrayElemAt: [ "$fromItems", 0 ] }, "$$ROOT" ] } }
   },
   { $project: { fromItems: 0 } }
] )

La operación devuelve estos documentos:

{
  _id: 1,
  item: 'almonds',
  description: 'almond clusters',
  instock: 120,
  price: 12,
  quantity: 2
},
{
  _id: 2,
  item: 'pecans',
  description: 'candied pecans',
  instock: 60,
  price: 20,
  quantity: 1
}

Realizar múltiples uniones y una subconsulta correlacionada con `$lookup`

Las canalizaciones se pueden ejecutar en una colección externa e incluir múltiples condiciones de unión.

Una condición de unión puede referirse a un campo en la colección local en la que se ejecutó el método aggregate() y referirse a un campo en la colección extranjera. Esto permite una sub-query correlacionada entre ambas colecciones.

MongoDB 5.0 soporta los subquery correlacionados concisos.

Cree una colección orders con estos documentos:

db.orders.insertMany( [
  { _id: 1, item: "almonds", price: 12, ordered: 2 },
  { _id: 2, item: "pecans", price: 20, ordered: 1 },
  { _id: 3, item: "cookies", price: 10, ordered: 60 }
] )

Cree otra colección warehouses con estos documentos:

db.warehouses.insertMany( [
  { _id: 1, stock_item: "almonds", warehouse: "A", instock: 120 },
  { _id: 2, stock_item: "pecans", warehouse: "A", instock: 80 },
  { _id: 3, stock_item: "almonds", warehouse: "B", instock: 60 },
  { _id: 4, stock_item: "cookies", warehouse: "B", instock: 40 },
  { _id: 5, stock_item: "cookies", warehouse: "A", instock: 80 }
] )

El siguiente ejemplo:

Utiliza una sub-query correlacionada con una unión en los campos orders.item y warehouse.stock_item.
Garantiza que la cantidad del artículo en inventario pueda abastecer la cantidad pedida.

db.orders.aggregate( [
   {
      $lookup:
         {
           from : "warehouses",
           localField : "item",
           foreignField : "stock_item",
           let : { order_qty: "$ordered" },
           pipeline : [
              { $match :
                 { $expr :
                      { $gte: [ "$instock", "$$order_qty" ] }
                 }
              },
              { $project : { stock_item: 0, _id: 0 } }
           ],
           as : "stockdata"
         }
    }
] )

La operación devuelve estos documentos:

{
  _id: 1,
  item: 'almonds',
  price: 12,
  ordered: 2,
  stockdata: [
    { warehouse: 'A', instock: 120 },
    { warehouse: 'B', instock: 60 }
  ]
},
{
  _id: 2,
  item: 'pecans',
  price: 20,
  ordered: 1,
  stockdata: [ { warehouse: 'A', instock: 80 } ]
},
{
  _id: 3,
  item: 'cookies',
  price: 10,
  ordered: 60,
  stockdata: [ { warehouse: 'A', instock: 80 } ]
}

La operación corresponde a esta instrucción pseudo-SQL:

SELECT *, stockdata
FROM orders
WHERE stockdata IN (
   SELECT warehouse, instock
   FROM warehouses
   WHERE stock_item = orders.item
   AND instock >= orders.ordered
);

Los operadores de comparación $eq, $lt, $lte, $gt y $gte colocados en un operador $expr pueden utilizar un índice en la colección from mencionada en una etapa $lookup. Limitaciones:

Los índices solo pueden utilizarse para comparaciones entre campos y constantes, por lo que el operando let debe resolverse en una constante.
Por ejemplo, una comparación entre $a y un valor constante puede utilizar un índice, pero una comparación entre $a y $b no puede.
Los índices no se utilizan para comparaciones donde el operando let se resuelve en un valor vacío o faltante.
Los índices multiclave no se utilizan.

Por ejemplo, si el índice { stock_item: 1, instock: 1 } existe en la colección warehouses:

La coincidencia exacta en el campo warehouses.stock_item utiliza el índice.
La parte de rango de la query sobre el campo warehouses.instock también utiliza el campo indexado en el índice compuesto.

Tip

Realice una sub-query no correlacionada con `$lookup`

Una etapa de $lookup de una pipeline de agregación puede ejecutar una pipeline en la colección foránea, lo que permite sub-query no correlacionadas. Una sub-query no correlacionada no hace referencia a los campos locales del documento.

Nota

Cree una colección absences con estos documentos:

db.absences.insertMany( [
   { _id: 1, student: "Ann Aardvark", sickdays: [ new Date ("2018-05-01"),new Date ("2018-08-23") ] },
   { _id: 2, student: "Zoe Zebra", sickdays: [ new Date ("2018-02-01"),new Date ("2018-05-23") ] },
] )

Cree otra colección holidays con estos documentos:

db.holidays.insertMany( [
   { _id: 1, year: 2018, name: "New Years", date: new Date("2018-01-01") },
   { _id: 2, year: 2018, name: "Pi Day", date: new Date("2018-03-14") },
   { _id: 3, year: 2018, name: "Ice Cream Day", date: new Date("2018-07-15") },
   { _id: 4, year: 2017, name: "New Years", date: new Date("2017-01-01") },
   { _id: 5, year: 2017, name: "Ice Cream Day", date: new Date("2017-07-16") }
] )

La siguiente operación une la colección absences con la información de las vacaciones de 2018 de la colección holidays:

db.absences.aggregate( [
   {
      $lookup:
         {
           from: "holidays",
           pipeline: [
              { $match: { year: 2018 } },
              { $project: { _id: 0, date: { name: "$name", date: "$date" } } },
              { $replaceRoot: { newRoot: "$date" } }
           ],
           as: "holidays"
         }
    }
] )

La operación devuelve lo siguiente:

{
  _id: 1,
  student: 'Ann Aardvark',
  sickdays: [
    ISODate("2018-05-01T00:00:00.000Z"),
    ISODate("2018-08-23T00:00:00.000Z")
  ],
  holidays: [
    { name: 'New Years', date: ISODate("2018-01-01T00:00:00.000Z") },
    { name: 'Pi Day', date: ISODate("2018-03-14T00:00:00.000Z") },
    { name: 'Ice Cream Day', date: ISODate("2018-07-15T00:00:00.000Z")
    }
  ]
},
{
  _id: 2,
  student: 'Zoe Zebra',
  sickdays: [
    ISODate("2018-02-01T00:00:00.000Z"),
    ISODate("2018-05-23T00:00:00.000Z")
  ],
  holidays: [
    { name: 'New Years', date: ISODate("2018-01-01T00:00:00.000Z") },
    { name: 'Pi Day', date: ISODate("2018-03-14T00:00:00.000Z") },
    { name: 'Ice Cream Day', date: ISODate("2018-07-15T00:00:00.000Z")
    }
  ]
}

La operación corresponde a esta instrucción pseudo-SQL:

SELECT *, holidays
FROM absences
WHERE holidays IN (
   SELECT name, date
   FROM holidays
   WHERE year = 2018
);

Para obtener más información, consulta Consideraciones sobre el rendimiento de subquery no correlacionado.

Realice una sub-query correlacionada concisa con `$lookup`

Nuevo en la versión 5.0.

A partir de MongoDB 5.0, una etapa de $lookup de la pipeline de agregación admite una sintaxis concisa de subquery correlacionado que mejora las uniones entre colecciones. La nueva sintaxis concisa remueve el requisito de una coincidencia exacta en los campos externos y locales dentro de un operador $expr en una etapa $match.

Cree una colección restaurants:

db.restaurants.insertMany( [
   {
      _id: 1,
      name: "American Steak House",
      food: [ "filet", "sirloin" ],
      beverages: [ "beer", "wine" ]
   },
   {
      _id: 2,
      name: "Honest John Pizza",
      food: [ "cheese pizza", "pepperoni pizza" ],
      beverages: [ "soda" ]
   }
] )

Crea otra colección orders con pedidos de comida y bebidas opcionales:

db.orders.insertMany( [
   {
      _id: 1,
      item: "filet",
      restaurant_name: "American Steak House"
   },
   {
      _id: 2,
      item: "cheese pizza",
      restaurant_name: "Honest John Pizza",
      drink: "lemonade"
   },
   {
      _id: 3,
      item: "cheese pizza",
      restaurant_name: "Honest John Pizza",
      drink: "soda"
   }
] )

El siguiente ejemplo:

Une las colecciones orders y restaurants al emparejar el localFieldorders.restaurant_name con el foreignField restaurants.name. La coincidencia se realiza antes de que se ejecute pipeline.
Realiza una coincidencia de arreglo $in entre los campos orders.drink y restaurants.beverages a los que se accede utilizando $$orders_drink y $beverages respectivamente.

db.orders.aggregate( [
   {
      $lookup: {
         from: "restaurants",
         localField: "restaurant_name",
         foreignField: "name",
         let: { orders_drink: "$drink" },
         pipeline: [ {
            $match: {
               $expr: { $in: [ "$$orders_drink", "$beverages" ] }
            }
         } ],
         as: "matches"
      }
   }
] )

Hay una coincidencia para el valor soda en los campos orders.drink y restaurants.beverages. Esta salida muestra el arreglo matches y contiene todos los campos foráneos de la colección restaurants para la coincidencia:

{
   _id: 1, item: "filet",
   restaurant_name: "American Steak House",
   matches: [ ]
}
{
   _id: 2, item: "cheese pizza",
   restaurant_name: "Honest John Pizza",
   drink: "lemonade",
   matches: [ ]
}
{
   _id: 3, item: "cheese pizza",
   restaurant_name: "Honest John Pizza",
   drink: "soda",
   matches: [ {
      _id: 2, name": "Honest John Pizza",
      food: [ "cheese pizza", "pepperoni pizza" ],
      beverages: [ "soda" ]
   } ]
}

Este ejemplo utiliza la sintaxis detallada de las versiones de MongoDB anteriores a la 5.0 y arroja los mismos resultados que el ejemplo conciso anterior:

db.orders.aggregate( [
   {
      $lookup: {
         from: "restaurants",
         let: { orders_restaurant_name: "$restaurant_name",
                orders_drink: "$drink" },
         pipeline: [ {
            $match: {
               $expr: {
                  $and: [
                     { $eq: [ "$$orders_restaurant_name", "$name" ] },
                     { $in: [ "$$orders_drink", "$beverages" ] }
                  ]
               }
            }
         } ],
         as: "matches"
      }
   }
] )

Los ejemplos anteriores corresponden a esta instrucción pseudo-SQL:

SELECT *, matches
FROM orders
WHERE matches IN (
   SELECT *
   FROM restaurants
   WHERE restaurants.name = orders.restaurant_name
   AND restaurants.beverages = orders.drink
);

Para obtener más información, consulta Consideraciones sobre el rendimiento de los subquery correlacionados.

Los ejemplos de C# en esta página utilizan la base de datos sample_mflix de los conjuntos de datos de muestra de Atlas. Para aprender a crear un clúster gratuito de MongoDB Atlas y cargar los conjuntos de datos de muestra, consulta Primeros pasos en la documentación del controlador de MongoDB .NET/C#.

La siguiente clase Movie modela los documentos en la colección sample_mflix.movies:

public class Movie
{
    public ObjectId Id { get; set; }
    public int Runtime { get; set; }
    
    public string Title { get; set; }
    public string Rated { get; set; }
    public List<string> Genres { get; set; }
    public string Plot { get; set; }
    
    public ImdbData Imdb { get; set; }
    public int Year { get; set; }
    public int Index { get; set; }
    
    public string[] Comments { get; set; }
   
    [BsonElement("lastupdated")]
    public DateTime LastUpdated { get; set; }
}

Nota

ConventionPack para Pascal Case

Las clases de C# en esta página utilizan Pascal case para los nombres de sus propiedades, pero los nombres de los campos en la colección de MongoDB utilizan camel case. Para tener en cuenta esta diferencia, se puede usar el siguiente código para registrar un ConventionPack cuando la aplicación se inicie:

var camelCaseConvention = new ConventionPack { new CamelCaseElementNameConvention() };
ConventionRegistry.Register("CamelCase", camelCaseConvention, type => true);

La siguiente clase Comment modela los documentos en la colección sample_mflix.comments:

public class Comment
{
    public Guid Id { get; set; }
   
    [BsonElement("movie_id")]
    public Guid MovieId { get; set; }
    
    public string Text { get; set; }
}

Para usar el controlador MongoDB.NET/C# para agregar una $lookup etapa a una canalización de agregación, llame a Lookup()método en un PipelineDefinition objeto.

El siguiente ejemplo crea una etapa de pipeline que realiza una unión externa izquierda entre las colecciones movies y comments. El código une el campo Id de cada documento Movie al campo MovieId en los documentos Comment. Los comentarios de cada película se almacenan en un campo llamado Comments en cada documento Movie.

var commentCollection = client
    .GetDatabase("aggregation_examples")
    .GetCollection<Comment>("comments");
var pipeline = new EmptyPipelineDefinition<Movie>()
    .Lookup<Movie, Movie, Comment, Movie>(
        foreignCollection: commentCollection,
        localField: m => m.Id,
        foreignField: c => c.MovieId,
        @as: m => m.Comments);

Los ejemplos de Node.js en esta página utilizan la base de datos sample_mflix de los conjuntos de datos de muestra de Atlas. Para aprender a crear un clúster gratuito de MongoDB Atlas y cargar los conjuntos de datos de muestra, consulte Primeros pasos en la documentación del controlador de MongoDB Node.js.

Para utilizar el controlador de MongoDB Node.js para agregar una etapa de $lookup a una canalización de agregación, utilice el Operador $lookup en un objeto de canalización.

El siguiente ejemplo crea una etapa de pipeline que realiza una unión externa izquierda entre las colecciones movies y comments. El código une el campo _id de cada documento movie al campo movie_id en los documentos comment. El campo comments almacena los comentarios de cada película en cada documento movie. A continuación, el ejemplo ejecuta la pipeline de agregación:

const pipeline = [
  {
    $lookup: {
      from: "comments",
      localField: "_id",
      foreignField: "movie_id",
      as: "comments"
    }
  }
];
const cursor = collection.aggregate(pipeline);
return cursor;

Volver

$listSessions

Coincidencia

Definición

Compatibilidad

Sintaxis

Coincidencia exacta con una única condición de unión

Nota

Nota

Condiciones de unión y sub-query en una colección foránea

Nota

Subconsultas correlacionadas utilizando una sintaxis concisa

Comportamiento

Vistas e intercalación

Restricciones

Soporte de búsqueda en Atlas

Colecciones fragmentadas

Motor de ejecución de query basado en ranuras

Nota

Consideraciones sobre el rendimiento

Importante

Ejemplos

Realice una única unión de igualdad con $lookup

Utilice $lookup con una matriz

Usa $lookup con $mergeObjects

Realizar múltiples uniones y una subconsulta correlacionada con $lookup

Tip

Realice una sub-query no correlacionada con $lookup

Nota

Realice una sub-query correlacionada concisa con $lookup

Nota

ConventionPack para Pascal Case

Obtén una insignia de habilidad

Realice una única unión de igualdad con `$lookup`

Utilice `$lookup` con una matriz

Usa `$lookup` con `$mergeObjects`

Realizar múltiples uniones y una subconsulta correlacionada con `$lookup`

Realice una sub-query no correlacionada con `$lookup`

Realice una sub-query correlacionada concisa con `$lookup`