/ /

演算子

集計パイプラインステージ

Docs Home

データベースマニュアル

参照

演算子

集計パイプラインステージ

$lookup（集計）

このバージョンのドキュメントはアーカイブされており、サポートされなくなりました。6.0 配置をアップグレードするには、 MongoDB 7.0 のアップグレード手順を参照してください。

定義

$lookup

バージョン 5.1 での変更。

同じデータベース内のコレクションへの左外部結合を実行して、外部コレクションのドキュメントをフィルタリングして処理します。$lookup ステージでは、各入力ドキュメントに新しい配列フィールドが追加されます。新しい配列フィールドには、外部コレクションからの一致するドキュメントが含まれます。$lookup ステージは、これらを再作成したドキュメントを次のステージに渡します。

MongoDB 5.1以降では、シャーディングされたコレクションで$lookupを使用できます。

2 つの異なるコレクションの要素を結合するには、 $unionWithパイプラインステージを使用します。

互換性

次の環境でホストされる配置には $lookup を使用できます。

MongoDB Atlas はクラウドでの MongoDB 配置のためのフルマネージドサービスです

MongoDB Enterprise: サブスクリプションベースの自己管理型 MongoDB バージョン
MongoDB Community: ソースが利用可能で、無料で使用できる自己管理型の MongoDB のバージョン

構文

$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は、次のフィールドを含むドキュメントを受け入れます。

フィールド	必要性	説明
from	必須	ローカルコレクションに結合する同じデータベース内の外部コレクションを指定します。場合によっては、`$documents` を第 1 ステージとして、`from` を `pipeline` に置き換えることができます。例については、「`$lookup` ステージでの `$documents` ステージの使用」を参照してください。 MongoDB 5.1 以降では、 `from`コレクションをシャーディングできます。
localField	`pipeline`が指定されている場合は任意	`$lookup`ステージに入力されるドキュメントからフィールドを指定します。`$lookuplocalFieldforeignField`は`from` コレクションのドキュメントからとの等価一致を実行します。入力ドキュメントに`localField` が含まれていない場合、は一致させる目的でそのフィールドが`$lookup` `null`の値を持つものとして扱います。
foreignField	`pipeline`が指定されている場合は任意	外部ドキュメントの `foreignField` を指定して、ローカルドキュメントの `localField` と等価一致を実行します。外部ドキュメントに`foreignField` 値が含まれていない場合、`$lookup` は一致に`null` 値を使用します。
let	任意	パイプラインステージで使用する変数を指定します。変数式を使用して、`pipeline`に入力されたローカルコレクションのドキュメントのフィールドにアクセスします。パイプラインステージで変数を参照には、`"$$<variable>"` 構文を使用します。 let `$lookup`変数には、にネストされた追加の`pipeline` ステージを含むパイプラインのステージからアクセス可能です。 `$match`ステージでは、変数にアクセスするために`$expr`演算子を使用する必要があります。`$expr`演算子を使用すると、`$match`構文内で集計式を使用できます。 `$eq`演算子に配置されている`$lt` `$lte$gt$gte`、、`$expr` 、、比較演算子は、`from` `$lookup`ステージで参照されるコレクションのインデックスを使用できます。制限: インデックスはフィールドと定数の比較にのみ使用できるため、`let` オペランドは定数に変換する必要があります。たとえば、`$a` と定数値の比較にはインデックスを使用できますが、`$a` と `$b` の比較には使用できません。 `let` オペランドが空の値または欠損値に変換される場合の比較には、インデックスは使用されません。マルチキーインデックスは使用されません。パイプラインの他の（`$match` 以外の）ステージでは、変数にアクセスするために `$expr`演算子は必要ありません。
パイプライン	`localField`と `foreignField` が指定されている場合は任意です。	外部コレクションで実行する`pipeline`を指定します。`pipeline`は外部コレクションからドキュメントを返します。すべてのドキュメントを返すには、空の`pipeline: []`を指定します。には`pipeline` `$out$merge`ステージまたはステージを含めることはできません。v6.0 以降では、`pipeline` にはパイプライン内の最初のステージとして`$search` Atlas Search ステージを含めることができます。詳しくは、「 Atlas Search サポート」を参照してください。 `pipeline`は入力ドキュメントのフィールドにアクセスできません。代わりに、letオプションを使用してドキュメントフィールドの変数を定義し、その変数を`pipeline`ステージで参照します。パイプラインステージで変数を参照には、`"$$<variable>"` 構文を使用します。 let `$lookup`変数には、にネストされた追加の`pipeline` ステージを含むパイプラインのステージからアクセス可能です。 `$match`ステージでは、変数にアクセスするために`$expr`演算子を使用する必要があります。`$expr`演算子を使用すると、`$match`構文内で集計式を使用できます。 `$eq`演算子に配置されている`$lt` `$lte$gt$gte`、、`$expr` 、、比較演算子は、`from` `$lookup`ステージで参照されるコレクションのインデックスを使用できます。制限: インデックスはフィールドと定数の比較にのみ使用できるため、`let` オペランドは定数に変換する必要があります。たとえば、`$a` と定数値の比較にはインデックスを使用できますが、`$a` と `$b` の比較には使用できません。 `let` オペランドが空の値または欠損値に変換される場合の比較には、インデックスは使用されません。マルチキーインデックスは使用されません。パイプラインの他の（`$match` 以外の）ステージでは、変数にアクセスするために `$expr`演算子は必要ありません。
as	必須	入力ドキュメントに追加する新しい配列フィールドの名前を指定します。新しい配列フィールドには、`from`コレクションと一致するドキュメントが含まれます。指定した名前がすでに入力ドキュメントに存在する場合、既存のフィールドは上書きされます。

1 つの結合条件による等価一致

入力ドキュメントのフィールドと外部コレクションのドキュメントのフィールドとの間で等価一致を実行するには、$lookupステージで次の構文を使用します。

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

注意

この例では、pipeline は任意であり、ローカルと外部の等価ステージの後に実行されます。

この操作は、次の疑似 SQL ステートメントに対応します。

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

注意

このページの SQL ステートメントは、MongoDB 集計パイプライン構文の比較に含まれています。SQL ステートメントは実行できません。

MongoDB の例については、次のページを参照してください。

1 つの等価結合の実行 $lookup
配列で$lookupを使用する
$lookupを$mergeObjectsと一緒に使用する

外部コレクションの結合条件とサブクエリ

MongoDB は以下をサポートします。

外部コレクションでパイプラインを実行する。
複数の結合条件。
相関サブクエリと非相関サブクエリ。

MongoDBでは、非相関サブクエリとは、すべての入力ドキュメントが同じ結果を返すことを意味します。相関サブクエリは、ローカルコレクションまたは $lookupinputコレクションのフィールドを使用して、各受信ドキュメントに相関した結果を返すステージのパイプラインです。

注意

MongoDB5.0 以降では、$lookup $sampleステージ、$sampleRate 演算子、または$rand 演算子を含む、パイプラインステージ内の相関のないサブクエリの場合、繰り返される場合はサブクエリが常に再度実行されます。以前は、サブクエリの出力サイズに応じて、サブクエリの出力がキャッシュされるか、サブクエリが再度実行されていました。

MongoDB 相関サブクエリは、内部クエリが外部クエリ値を参照する SQL 相関サブクエリに相当します。SQL 非相関サブクエリは、外部クエリ値を参照しません。

MongoDB 5.0 は簡潔な相関サブクエリもサポートしています。

2 つのコレクションに対して相関サブクエリと非相関サブクエリを実行し、単一の等価一致以外の結合条件を実行するには、次の$lookup構文を使用します。

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

この操作は、次の疑似 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>
);

次の例を参照してください。

複数結合と相関サブクエリの実行 $lookup
非相関サブクエリの実行 $lookup

簡潔な構文を使用した相関サブクエリ

バージョン 5.0 で追加

MongoDB 5.0 以降、簡潔な相関サブクエリの構文を使用できるようになりました。相関サブクエリは、外部コレクションおよび、aggregate()メソッドが実行された「ローカル」コレクションのドキュメントフィールドを参照します。

次の新しい簡潔な構文により、$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>
      }
}

この操作は、次の疑似 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>
);

以下の例を参照してください。

簡潔な相関サブクエリの実行 $lookup

動作

ビューと照合

$lookup や $graphLookup のように複数のビューを含む集計を実行する場合、ビューの照合順序は同じである必要があります。

制限事項

$out または $merge ステージを $lookup ステージに含めることはできません。具体的には、外部コレクションのパイプラインを指定するときに、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>
   }
}

Atlas Search サポート

MongoDB 6.0 以降では、 $lookup パイプラインで Atlas Search $search または $searchMeta ステージを指定して、Atlas クラスター上のコレクションを検索できます。$search または $searchMeta ステージは、 $lookup パイプライン内の最初のステージである必要があります。

たとえば、外部コレクションで条件とサブクエリを結合する場合や、簡潔な構文を使用した相関サブクエリを実行する場合は、次に示すようにパイプライン内で$searchまたは$searchMetaを指定できます。

[{
  "$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>
        }
      },
      ...
    }]
  }
}]

$lookup とともに $search を使った例については、Atlas Search チュートリアルの「$lookup を使用した Atlas Search $search クエリの実行」を参照してください。

シャーディングされたコレクション

MongoDB5.1 以降では、from ステージのパラメーターで$lookup シャーディングされたコレクションを指定できます。

シャーディングされたコレクションをターゲットにしている間は、トランザクション内で $lookup ステージを使用できません。

スロットベースのクエリ実行エンジン

注意

バージョン 6.0.18 以降、スロットベースの実行クエリエンジンは、6.0 のパッチバージョンではデフォルトで有効ではなくなりました。スロットベースの実行クエリエンジンを使用するクエリを使用する場合は、バージョン 8.0 にアップグレードしてください。デフォルトで有効になっている。

バージョン6.0以降、 MongoDB は、パイプライン内の先行する$lookup すべてのステージもスロットベースのエンジンで実行でき、次の条件のいずれも当てはまらない場合、スロットベースの実行クエリエンジンを使用してステージを実行できます。

$lookup操作は、外部コレクションに対してパイプラインを実行します。この種の操作の例については、「外部コレクションの結合条件とサブクエリ」を参照してください。
$lookup の localField または foreignField は数値コンポーネントを指定します。例: { localField: "restaurant.0.review" }。
パイプラインに含まれる任意の $lookup の from フィールドには、ビューまたはシャーディングされたコレクションが明示されます。

詳細については、「$lookup 最適化」を参照してください。

パフォーマンスに関する考慮事項

$lookup パフォーマンスは、実行される操作の種類によって異なります。さまざまな$lookup操作のパフォーマンスに関する考慮事項については、次の表を参照してください。

`$lookup` 操作	パフォーマンスに関する考慮事項
単一結合による等価一致	`$lookup` では、外部コレクションに `foreignField` のインデックスが含まれている場合、単一結合で等価一致を実行する操作のパフォーマンスが向上します。重要: `foreignField` に対応するインデックスが存在しない場合、単一結合で等価一致を実行する `$lookup` 操作はパフォーマンスが低下する可能性があります。
非相関サブクエリ	`$lookup` では、内部パイプラインが外部コレクションのインデックスを参照できる場合、非相関サブクエリを含む操作のパフォーマンスが向上します。ソースコレクションと外部コレクションの間には関係がないため、MongoDB はクエリをキャッシュする前に `$lookup` サブクエリを一度だけ実行する必要があります。サブクエリはソースコレクション内のどの値にも基づいていません。この動作により、 `$lookup` 操作の後続の実行時のパフォーマンスが向上します。
相関サブクエリ	`$lookup` では、次の条件が当てはまる場合、相関サブクエリを含む操作は、より優れたパフォーマンスを実現します。外部コレクションは`foreignField`のインデックスを含みます。外部コレクションには、内部パイプラインを参照するインデックスが含まれています。パイプラインが多数のドキュメントを `$lookup` クエリに渡す場合、次の戦略によってパフォーマンスが向上する可能性があります。 MongoDB が`$lookup`クエリに渡すドキュメントの数を減らします。たとえば、`$match` ステージでより厳しいフィルターを設定します。 `$lookup` サブクエリの内部パイプラインを別のクエリとして実行し、`$out` を使用して一時コレクションを作成します。次に、 1 つの結合による等価一致を実行します。データのスキーマを再検討して、ユースケースに最適であることを確認します。

一般的なパフォーマンス戦略については、「インデックス戦略」と「クエリの最適化」を参照してください。

重要

クエリ内で$lookupを過度に使用すると、パフォーマンスが低下する可能性があります。複数の$lookup ステージを回避するには、埋め込みデータモデルを使用してクエリパフォーマンスを最適化することを検討してください。

例

1 つの等価結合の実行 `$lookup`

これらのドキュメントを使用してコレクションordersを作成します。

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

これらのドキュメントを使用して別のコレクションinventoryを作成します。

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

ordersコレクションに対する次の集計操作は、ordersコレクションのフィールドitemと　inventoryコレクションのskuフィールドを使用して、ordersのドキュメントと　inventoryコレクションのドキュメントを結合します。

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

この操作では、次のドキュメントが返されます。

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

この操作は、次の疑似 SQL ステートメントに対応します。

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

詳細については、「等価一致のパフォーマンスに関する考慮事項」を参照してください。

配列で `$lookup` を使用する

localFieldが配列の場合、$unwindステージを使用せずに、配列要素をスカラーforeignFieldと照合できます。

たとえば、次のドキュメントを使用してコレクション例「classes」を作成します。

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

これらのドキュメントを使用して別のコレクションmembersを作成します。

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

次の集計操作では、enrollmentlist フィールドと name フィールドを一致させて、classesコレクション内のドキュメントをmembersコレクションと結合します。

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

この操作では、以下を返します。

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

`$lookup` を `$mergeObjects` で使用する

$mergeObjects 演算子は、複数のドキュメントを 1 つのドキュメントに結合します。

これらのドキュメントを使用してコレクションordersを作成します。

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

これらのドキュメントを使用して別のコレクションitemsを作成します。

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

次の操作では、最初に$lookupステージを使用して、itemフィールドで2つのコレクションを結合し、$replaceRootの$mergeObjectsを使用してitemsおよび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 } }
] )

この操作では、次のドキュメントが返されます。

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

複数結合と相関サブクエリの実行 `$lookup`

パイプラインは外部コレクションに対して実行でき、複数の結合条件を含めることができます。

結合条件は、aggregate()メソッドが実行されたローカルコレクション内のフィールドを参照し、外部コレクション内のフィールドを参照できます。これにより、2つのコレクション間の相関サブクエリが可能になります。

MongoDB 5.0 は簡潔な相関サブクエリをサポートしています。

これらのドキュメントを使用してコレクションordersを作成します。

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

これらのドキュメントを使用して別のコレクションwarehousesを作成します。

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

次の例：

orders.itemフィールドとwarehouse.stock_itemフィールドを結合した相関サブクエリを使用します。
在庫品の数量が注文数量を満たせることを確認します。

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

この操作では、次のドキュメントが返されます。

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

この操作は、次の疑似 SQL ステートメントに対応します。

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

$expr 演算子に配置されている $eq、$lt、$lte、$gt、$gte 比較演算子では、$lookup ステージで参照される from コレクションにインデックスを使用できます。制限:

インデックスはフィールドと定数の比較にのみ使用できるため、let オペランドは定数に変換する必要があります。
たとえば、$a と定数値の比較にはインデックスを使用できますが、$a と $b の比較には使用できません。
let オペランドが空の値または欠損値に変換される場合の比較には、インデックスは使用されません。
マルチキーインデックスは使用されません。

たとえば、インデックス{ stock_item: 1, instock: 1 } warehousesコレクションに存在する場合：

warehouses.stock_itemフィールドの等価一致はインデックスを使用します。
warehouses.instock フィールドのクエリの範囲部分でも、複合インデックス内のインデックス付きフィールドが使用されます。

Tip

非相関サブクエリの実行 `$lookup`

集計パイプラインの $lookup ステージでは、外部コレクションに対してパイプラインを実行できるため、非相関サブクエリが可能になります。非相関サブクエリは、ローカルドキュメントフィールドを参照しません。

注意

これらのドキュメントを使用してコレクションabsencesを作成します。

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

これらのドキュメントを使用して別のコレクションholidaysを作成します。

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

次の操作では、absencesコレクションをholidaysコレクションの 2018 年の休日情報と結合します。

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

この操作では、以下を返します。

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

この操作は、次の疑似 SQL ステートメントに対応します。

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

詳細については、「非相関サブクエリのパフォーマンスに関する検討事項」を参照してください。

簡潔な相関サブクエリの実行 `$lookup`

バージョン 5.0 で追加

MongoDB 5.0以降、集計パイプラインの$lookupステージでは、コレクション間の結合を改善する簡潔な相関サブクエリ構文がサポートされています。新しい簡潔な構文により、ステージの$expr $match演算子内の外部フィールドとローカルフィールドを等価一致させる必要がなくなります。

コレクション 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" ]
   }
] )

食べ物と任意の飲み物の注文を含む別のコレクションordersを作成します。

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

次の例：

orders.restaurant_name の localField と restaurants.name の foreignField を一致させることにより、orders コレクションと restaurantsコレクションを結合します。一致は pipeline が実行される前に実行されます。
それぞれ$$orders_drinkと$beveragesを使用してアクセスされるorders.drinkフィールドとrestaurants.beveragesフィールド間で$in配列の一致を実行します。

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

orders.drinkフィールドとrestaurants.beveragesフィールドにsoda値の一致があります。この出力は matches 配列を表示し、一致する restaurants コレクションからのすべての外部フィールドを含みます。

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

この例では、MongoDB バージョン 5.0 以前の古い冗語構文を使用しており、以前の簡潔な例と同様の結果を返します。

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

前の例は、次の疑似 SQL ステートメントに対応します。

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

詳細については、「相関サブクエリのパフォーマンスに関する検討事項」を参照してください。

このページのC#の例では、Atlasサンプルデータセットの sample_mflixデータベースを使用します。MongoDB Atlasクラスターを無料で作成して、サンプルデータセットをロードする方法については、 MongoDB .NET/ C#ドライバーのドキュメントの「開始」を参照してください。

次の Movie クラスは、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; }
}

注意

パスカルケースの ConventionPack

このページのC# クラスはプロパティ名にパスカルケースを使用していますが、MongoDB コレクションのフィールド名はキャメルケースを使用しています。この違いを考慮するために、アプリケーションが起動する際に次のコードを使用してConventionPackを登録してください。

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

次の Comment クラスは、sample_mflix.comments コレクション内のドキュメントをモデル化します。

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

MongoDB .NET/ C#ドライバーを使用して$lookup ステージを集計パイプラインに追加するには、オブジェクトでLookup() PipelineDefinitionメソッドを呼び出します。

次の例では、movies コレクションと comments コレクション間で左外部結合を実行するパイプラインステージを作成します。このコードは、各 Movieドキュメントの IdフィールドをComment ドキュメントの MovieIdフィールドに結合します。各映画のコメントは、各 Movieドキュメントの Comments という名前のフィールドに保存されます。

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

このページのNode.js の例では、Atlasサンプルデータセットの sample_mflixデータベースを使用します。無料のMongoDB Atlas cluster を作成し、サンプルデータセットをロードする方法については、 MongoDB Node.jsドライバーのドキュメントの開始を参照してください。

MongoDB Node.jsドライバーを使用して $lookup ステージを集計パイプラインに追加するには、パイプラインオブジェクトで $lookup 演算子を使用します。

次の例では、movies コレクションと comments コレクションの間で左外部結合を実行するパイプラインステージを作成します。このコードは、各 movie ドキュメントの _id フィールドを comment ドキュメントの movie_id フィールドに結合します。comments フィールドは、各 movie ドキュメントの各映画に対するコメントを保存します。次に、この例は集計パイプラインを実行します。

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

戻る

$listSessions

$match

定義

互換性

構文

1 つの結合条件による等価一致

注意

注意

外部コレクションの結合条件とサブクエリ

注意

簡潔な構文を使用した相関サブクエリ

動作

ビューと照合

制限事項

Atlas Search サポート

シャーディングされたコレクション

スロットベースのクエリ実行エンジン

注意

パフォーマンスに関する考慮事項

重要

例

1 つの等価結合の実行 $lookup

配列で $lookup を使用する

$lookup を $mergeObjects で使用する

複数結合と相関サブクエリの実行 $lookup

Tip

非相関サブクエリの実行 $lookup

注意

簡潔な相関サブクエリの実行 $lookup

注意

パスカルケースの ConventionPack

ルール バッジを取得する

1 つの等価結合の実行 `$lookup`

配列で `$lookup` を使用する

`$lookup` を `$mergeObjects` で使用する

複数結合と相関サブクエリの実行 `$lookup`

非相関サブクエリの実行 `$lookup`

簡潔な相関サブクエリの実行 `$lookup`

ルールバッジを取得する