Exemplo (MongoDB Shell)Condições de junção e subconsultas correlacionadas (MongoDB Shell)Subconsultas correlacionadas usando sintaxe concisa (MongoDB Shell)Estágios suportados em subconsultas correlacionadas Exemplos de código Exemplos de códigos de subconsulta correlacionados

$lookup

O estágio $lookup de agregação no Amazon DocumentDB permite que você realize uma junção externa esquerda entre duas coleções. Essa operação permite combinar dados de várias coleções com base nos valores de campo correspondentes. É particularmente útil quando você precisa incorporar dados de coleções relacionadas aos resultados da consulta.

Parâmetros

from: O nome da coleção com a qual realizar a junção.
localField: O campo dos documentos de entrada a serem comparados com foreignField o.
foreignField: O campo dos documentos na from coleção a ser comparado com localField o.
as: o nome do novo campo a ser adicionado aos documentos de saída contendo os documentos correspondentes da from coleção.
pipeline: Opcional se localField e foreignField forem especificados. Um pipeline de agregação para ser executado na from coleção. O pipeline retorna documentos da from coleção. Para retornar todos os documentos, especifique um pipeline vazio[]. O pipeline não pode incluir os $merge estágios $out ou. Consulte Condições de junção e subconsultas correlacionadas (MongoDB Shell).
let: opcional. Um documento que define variáveis a serem usadas nas pipeline etapas. Use as expressões variáveis para acessar os campos dos documentos de entrada que estão unidos aopipeline. Para referenciar uma variável nos estágios do pipeline, use a "$$<variable>" sintaxe. Consulte Condições de junção e subconsultas correlacionadas (MongoDB Shell).

Exemplo (MongoDB Shell)

O exemplo a seguir demonstra uma $lookup operação simples que une dados da orders coleta à customers coleção.

Crie documentos de amostra


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

Exemplo de consulta


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

Saída


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

Condições de junção e subconsultas correlacionadas (MongoDB Shell)

Novo na versão 8.0.2.

Além de uma única igualdade de igualdade, $lookup no Amazon DocumentDB é possível executar um pipeline de agregação na coleção unida. Isso suporta subconsultas não correlacionadas, que executam a mesma subconsulta para cada documento de entrada, e subconsultas correlacionadas, que usam variáveis definidas nos campos de cada documento de entrada para retornar resultados correlacionados a esse documento.

Sintaxe

Para executar uma subconsulta correlacionada, defina variáveis dos campos do documento de entrada com let e faça referência a elas nas pipeline etapas:


{
  $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: um documento que define variáveis dos campos dos documentos de entrada. Para referenciar uma variável nos estágios do pipeline, use a "$$<variable>" sintaxe. As variáveis podem ser acessadas pelos estágios dopipeline, incluindo $lookup estágios adicionais aninhados nopipeline. Um $match estágio requer o uso do $expr operador para acessar as variáveis. Omita let para executar uma subconsulta não correlacionada.
pipeline: O pipeline de agregação a ser executado na from coleção. O pipeline não pode acessar diretamente os campos dos documentos de entrada; em vez disso, defina variáveis let e faça referência às variáveis. Para retornar todos os documentos, especifique um pipeline vazio[].

Os operadores $eq$gt,$gte,$lt, e de $lte comparação colocados em um $expr operador dentro de um $match estágio podem usar um índice na from coleção quando comparam um campo da coleção unida com uma let variável ou constante.

Crie documentos de amostra


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

Exemplo de consulta

O exemplo a seguir une cada cliente com seus pedidos e mantém somente os pedidos que total são maiores ou iguais ao min_total valor do próprio cliente. A condição de junção e o filtro por cliente são as duas let variáveis de referência em: $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"
    }
  }
]);

Saída


[
  { _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, a subconsulta é avaliada com min_total os valores _id e valores desse cliente, de modo que cada documento receba seu próprio resultado correlacionado.

Subconsultas correlacionadas usando sintaxe concisa (MongoDB Shell)

Novo na versão 8.0.2.

O Amazon DocumentDB também oferece suporte à sintaxe concisa de subconsultas correlacionadas, que combina a correspondência de igualdade em e com a. localField foreignField pipeline A sintaxe concisa elimina a exigência de expressar a correspondência de igualdade dentro de um $expr operador em um $match estágio.

Sintaxe


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

Exemplo de consulta

O exemplo a seguir retorna os mesmos resultados do exemplo anterior de subconsulta correlacionada. A igualdade entre _id e customer_id é expressa com localField e foreignField em vez de uma $expr condição:


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

Saída


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

Estágios suportados em subconsultas correlacionadas

Quando um $lookup pipeline usalet, os seguintes estágios podem fazer referência às "$$<variable>" variáveis:

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

Estágios que não avaliam expressões variáveis, como$sort,$skip,$limit,$count,$sample, e $unwind$unset, também podem ser usados no pipeline, mas não podem referenciar as variáveis.

Os seguintes estágios não são suportados em um $lookup pipeline que usalet: $facet$redact,$replaceRoot, $replaceWith$geoNear,$setWindowFields,$fill, e $match com$text.

Restrições

pipelineNão podem incluir os $merge estágios $out ou.

Exemplos de código

Para ver um exemplo de código para usar o $lookup comando, escolha a guia do idioma que você deseja usar:

Exemplos de códigos de subconsulta correlacionados

Para ver um exemplo de código para usar o $lookup estágio com uma subconsulta correlacionada (usando let epipeline), escolha a guia do idioma que você deseja 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()

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

$lte

$ltrim