Contoh (MongoDB Shell)Gabungkan kondisi dan subkueri berkorelasi (MongoDB Shell)Subkueri berkorelasi menggunakan sintaks ringkas (MongoDB Shell)Tahapan yang didukung dalam subquery yang berkorelasi Contoh kode Contoh kode subquery yang berkorelasi

$lookup

T $lookup ahap agregasi di Amazon DocumentDB memungkinkan Anda melakukan gabungan luar kiri antara dua koleksi. Operasi ini memungkinkan Anda menggabungkan data dari beberapa koleksi berdasarkan nilai bidang yang cocok. Ini sangat berguna ketika Anda perlu memasukkan data dari koleksi terkait ke dalam hasil kueri Anda.

Parameter

from: Nama koleksi untuk melakukan gabungan.
localField: Bidang dari dokumen input untuk dicocokkan denganforeignField.
foreignField: Bidang dari dokumen dalam from koleksi untuk dicocokkan denganlocalField.
as: Nama bidang baru untuk ditambahkan ke dokumen keluaran yang berisi dokumen yang cocok dari from koleksi.
pipeline: Opsional jika localField dan foreignField ditentukan. Pipa agregasi untuk dijalankan pada from koleksi. Pipa mengembalikan dokumen dari from koleksi. Untuk mengembalikan semua dokumen, tentukan pipa kosong[]. Pipa tidak dapat menyertakan ta $merge hapan $out atau. Lihat Gabungkan kondisi dan subkueri berkorelasi (MongoDB Shell).
let: Opsional. Dokumen yang mendefinisikan variabel untuk digunakan dalam ta pipeline hapan. Gunakan ekspresi variabel untuk mengakses bidang dari dokumen input yang digabungkan kepipeline. Untuk mereferensikan variabel dalam tahap pipeline, gunakan sin "$$<variable>" taks. Lihat Gabungkan kondisi dan subkueri berkorelasi (MongoDB Shell).

Contoh (MongoDB Shell)

Contoh berikut menunjukkan $lookup operasi sederhana yang menggabungkan data dari orders koleksi ke dalam customers koleksi.

Buat dokumen sampel


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

Contoh kueri


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

Keluaran


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

Gabungkan kondisi dan subkueri berkorelasi (MongoDB Shell)

Baru dari versi 8.0.2.

Selain pencocokan kesetaraan tunggal, $lookup di Amazon DocumentDB dapat menjalankan pipeline agregasi pada koleksi yang digabungkan. Ini mendukung subquery yang tidak berkorelasi, yang menjalankan subkueri yang sama untuk setiap dokumen input, dan subquery berkorelasi, yang menggunakan variabel yang ditentukan dari setiap bidang dokumen input untuk mengembalikan hasil yang berkorelasi dengan dokumen itu.

Sintaksis

Untuk menjalankan subkueri yang berkorelasi, tentukan variabel dari bidang dokumen input denganlet, dan rujuk mereka dalam ta pipeline hapan:


{
  $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: Dokumen yang mendefinisikan variabel dari bidang dokumen input. Untuk mereferensikan variabel dalam tahap pipeline, gunakan sin "$$<variable>" taks. Variabel dapat diakses oleh tahapan dipipeline, termasuk ta $lookup hapan tambahan yang bersarang dipipeline. Sebuah $match tahap membutuhkan penggunaan $expr operator untuk mengakses variabel. Hilangkan let untuk menjalankan subkueri yang tidak berkorelasi.
pipeline: Pipa agregasi untuk dijalankan pada from koleksi. Pipeline tidak dapat mengakses bidang dokumen input secara langsung; tentukan variabel dengan let dan referensi variabel sebagai gantinya. Untuk mengembalikan semua dokumen, tentukan pipa kosong[].

Operator $eq$gt,$gte,$lt,, dan $lte perbandingan yang ditempatkan dalam $expr operator di dalam pang $match gung dapat menggunakan indeks pada from koleksi ketika mereka membandingkan bidang koleksi yang digabungkan dengan let variabel atau konstanta.

Buat dokumen sampel


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

Contoh kueri

Contoh berikut menggabungkan setiap pelanggan dengan pesanan mereka, dan hanya menyimpan pesanan yang total lebih besar dari atau sama dengan min_total nilai pelanggan itu sendiri. Kondisi gabungan dan per-pelanggan memfilter kedua let variabel referensi di dalam: $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"
    }
  }
]);

Keluaran


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

Untuk setiap pelanggan, subquery dievaluasi dengan min_total nilai _id dan nilai pelanggan tersebut, sehingga setiap dokumen menerima hasil yang berkorelasi sendiri.

Subkueri berkorelasi menggunakan sintaks ringkas (MongoDB Shell)

Baru dari versi 8.0.2.

Amazon DocumentDB juga mendukung sintaks subkueri berkorelasi ringkas, yang menggabungkan kecocokan kesetaraan pada localField dan foreignField dengan a. pipeline Sintaks ringkas menghilangkan persyaratan untuk mengekspresikan kecocokan kesetaraan di dalam $expr operator dalam $match tahap.

Sintaksis


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

Contoh kueri

Contoh berikut mengembalikan hasil yang sama seperti contoh subquery berkorelasi sebelumnya. Kecocokan kesetaraan antara _id dan customer_id din localField yatakan dengan dan bu foreignField kannya $expr kondisi:


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

Keluaran


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

Tahapan yang didukung dalam subquery yang berkorelasi

Ketika $lookup pipa menggunakanlet, tahapan berikut dapat mereferensikan "$$<variable>" variabel:

$match(menggunakan $expr operator)
$project
$addFields
$set
$group
$bucket
$bucketAuto
$sortByCount
$lookup(bersarang)
$graphLookup

Tahapan yang tidak mengevaluasi ekspresi variabel, seperti$sort,,$skip,$limit,$count,$sample, dan $unwind$unset, juga dapat digunakan dalam pipeline tetapi tidak dapat mereferensikan variabel.

Tahapan berikut tidak didukung dalam $lookup pipeline yang menggunakanlet:$facet,,$redact,$replaceRoot, $replaceWith$geoNear,$setWindowFields,$fill, dan $match dengan$text.

Pembatasan

Tidak pipeline dapat mencakup ta $merge hap $out an atau.

Contoh kode

Untuk melihat contoh kode untuk menggunakan $lookup perintah, pilih tab untuk bahasa yang ingin Anda gunakan:

Contoh kode subquery yang berkorelasi

Untuk melihat contoh kode untuk menggunakan $lookup stage dengan subquery yang berkorelasi (menggunakan let danpipeline), pilih tab untuk bahasa yang ingin Anda gunakan:

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

Awas Javascript dinonaktifkan atau tidak tersedia di browser Anda.

Untuk menggunakan Dokumentasi AWS, Javascript harus diaktifkan. Lihat halaman Bantuan browser Anda untuk petunjuk.

Konvensi Dokumen

$lte

$ltrim