埋め込みドキュメントの配列のクエリ

項目一覧

配列にネストされたドキュメントのクエリ

ドキュメントの配列内のフィールドにクエリ条件を指定
ドキュメントの配列に複数の条件を指定
MongoDB Atlas でドキュメントの配列をクエリする
その他のクエリに関するチュートリアル

次の方法を使用して、MongoDB 内のドキュメントをクエリできます。

プログラミング言語のドライバー。
MongoDB Atlas UI 。詳細については、「 MongoDB Atlas を使用したドキュメントの配列のクエリ」を参照してください。
MongoDB Compass

➤ 右上の [言語選択] ドロップダウンメニューを使用して、以下の例の言語を設定するか、MongoDB Compass を選択します。

このページでは、mongosh で db.collection.find() メソッドを使用して行う、ネストされたドキュメントの配列に対するクエリ操作の例を示します。

このページの例では、inventory コレクションを使用しています。MongoDB インスタンスのテストデータベースに接続し、inventory コレクションを作成します。

このページでは、MongoDB Compass を使用してネストされたドキュメントの配列に対するクエリ操作の例えを示します。

このページでは、 MongoDB C# Driverで MongoCollection.Find() メソッドを使用して行う、ネストされたドキュメントの配列に対するクエリ操作の例を示します。

このページでは、 Collection.Find メソッドを MongoDB Go ドライバーでの関数。

このページでは MongoDB Java Reactive Streams ドライバーで com.mongodb.reactivestreams.client.MongoCollection.find メソッドを使用した、ネストされたドキュメントの配列に対するクエリ操作の例えを示します。

このページでは MongoDB Java 同期ドライバーで com.mongodb.client.MongoCollection.find メソッドを使用してネストされたドキュメントの配列に対するクエリ操作の例えを示します。

Tip

ドライバーが提供する com.mongodb.client.model.Filters ヘルパー　メソッドを使用すると、フィルタードキュメントの作成が簡単になります。このページでは、これらのメソッドを使用してフィルタードキュメントを作成する例を紹介します。

このページでは、Motor ドライバーで motor.motor_asyncio.AsyncIOMotorCollection.find メソッドを使用して行う、ネストされたドキュメントの配列に対するクエリ操作の例を示します。

このページでは、collection.find() メソッドをメソッドを使用した、MongoDB Node.js ドライバーでのクエリ操作の例を取り上げます。

このページでは、MongoDB Perl Driverで MongoDB::Collection::find() メソッドを使用して行う、ネストされたドキュメントの配列に対するクエリ操作の例を示します。

このページでは MongoDB PHP ライブラリで MongoDB\\Collection::find() メソッドを使用してネストされたドキュメントの配列に対するクエリ操作の例えを示します。

このページでは、PyMongo Python ドライバーの pymongo.collection.Collection.find メソッドを使用してネストされたドキュメントの配列に対するクエリ操作の例を示します。

このページでは MongoDB Ruby ドライバーで Mongo::Collection#find() メソッドを使用してネストされたドキュメントの配列に対するクエリ操作の例えを示します。

このページでは、collection.find() メソッドをMongoDB Scala ドライバーで使用して行う、ネストされたドキュメントの配列に対するクエリ操作の例を示します。

db.inventory.insertMany( [
   { item: "journal", instock: [ { warehouse: "A", qty: 5 }, { warehouse: "C", qty: 15 } ] },
   { item: "notebook", instock: [ { warehouse: "C", qty: 5 } ] },
   { item: "paper", instock: [ { warehouse: "A", qty: 60 }, { warehouse: "B", qty: 15 } ] },
   { item: "planner", instock: [ { warehouse: "A", qty: 40 }, { warehouse: "B", qty: 5 } ] },
   { item: "postcard", instock: [ { warehouse: "B", qty: 15 }, { warehouse: "C", qty: 35 } ] }
]);

[
    { "item": "journal", "instock": [ { "warehouse": "A", "qty": 5 }, { "warehouse": "C", "qty": 15 } ] },
    { "item": "notebook", "instock": [ { "warehouse": "C", "qty": 5 } ] },
    { "item": "paper", "instock": [ { "warehouse": "A", "qty": 60 }, { "warehouse": "B", "qty": 15 } ] },
    { "item": "planner", "instock": [ { "warehouse": "A", "qty": 40 }, { "warehouse": "B", "qty": 5 } ] },
    { "item": "postcard", "instock": [ { "warehouse": "B","qty": 15 }, { "warehouse": "C", "qty": 35 } ] }
]

MongoDB Compass でドキュメントを挿入する手順については、「ドキュメントの挿入」を参照してください。

var documents = new[]
{
    new BsonDocument
    {
        { "item", "journal" },
        { "instock", new BsonArray
            {
                new BsonDocument { { "warehouse", "A" }, { "qty", 5 } },
                new BsonDocument { { "warehouse", "C" }, { "qty", 15 } } }
            }
    },
    new BsonDocument
    {
        { "item", "notebook" },
        { "instock", new BsonArray
            {
                new BsonDocument { { "warehouse", "C" }, { "qty", 5 } } }
            }
    },
    new BsonDocument
    {
        { "item", "paper" },
        { "instock", new BsonArray
            {
                new BsonDocument { { "warehouse", "A" }, { "qty", 60 } },
                new BsonDocument { { "warehouse", "B" }, { "qty", 15 } } }
            }
    },
    new BsonDocument
    {
        { "item", "planner" },
        { "instock", new BsonArray
            {
                new BsonDocument { { "warehouse", "A" }, { "qty", 40 } },
                new BsonDocument { { "warehouse", "B" }, { "qty", 5 } } }
            }
    },
    new BsonDocument
    {
        { "item", "postcard" },
        { "instock", new BsonArray
            {
                new BsonDocument { { "warehouse", "B" }, { "qty", 15 } },
                new BsonDocument { { "warehouse", "C" }, { "qty", 35 } } }
            }
    }
};
collection.InsertMany(documents);

docs := []interface{}{
	bson.D{
		{"item", "journal"},
		{"instock", bson.A{
			bson.D{
				{"warehouse", "A"},
				{"qty", 5},
			},
			bson.D{
				{"warehouse", "C"},
				{"qty", 15},
			},
		}},
	},
	bson.D{
		{"item", "notebook"},
		{"instock", bson.A{
			bson.D{
				{"warehouse", "C"},
				{"qty", 5},
			},
		}},
	},
	bson.D{
		{"item", "paper"},
		{"instock", bson.A{
			bson.D{
				{"warehouse", "A"},
				{"qty", 60},
			},
			bson.D{
				{"warehouse", "B"},
				{"qty", 15},
			},
		}},
	},
	bson.D{
		{"item", "planner"},
		{"instock", bson.A{
			bson.D{
				{"warehouse", "A"},
				{"qty", 40},
			},
			bson.D{
				{"warehouse", "B"},
				{"qty", 5},
			},
		}},
	},
	bson.D{
		{"item", "postcard"},
		{"instock", bson.A{
			bson.D{
				{"warehouse", "B"},
				{"qty", 15},
			},
			bson.D{
				{"warehouse", "C"},
				{"qty", 35},
			},
		}},
	},
}
result, err := coll.InsertMany(context.TODO(), docs)

Publisher<Success> insertManyPublisher = collection.insertMany(asList(
        Document.parse("{ item: 'journal', instock: [ { warehouse: 'A', qty: 5 }, { warehouse: 'C', qty: 15 } ] }"),
        Document.parse("{ item: 'notebook', instock: [ { warehouse: 'C', qty: 5 } ] }"),
        Document.parse("{ item: 'paper', instock: [ { warehouse: 'A', qty: 60 }, { warehouse: 'B', qty: 15 } ] }"),
        Document.parse("{ item: 'planner', instock: [ { warehouse: 'A', qty: 40 }, { warehouse: 'B', qty: 5 } ] }"),
        Document.parse("{ item: 'postcard', instock: [ { warehouse: 'B', qty: 15 }, { warehouse: 'C', qty: 35 } ] }")
));

collection.insertMany(asList(
        Document.parse("{ item: 'journal', instock: [ { warehouse: 'A', qty: 5 }, { warehouse: 'C', qty: 15 } ] }"),
        Document.parse("{ item: 'notebook', instock: [ { warehouse: 'C', qty: 5 } ] }"),
        Document.parse("{ item: 'paper', instock: [ { warehouse: 'A', qty: 60 }, { warehouse: 'B', qty: 15 } ] }"),
        Document.parse("{ item: 'planner', instock: [ { warehouse: 'A', qty: 40 }, { warehouse: 'B', qty: 5 } ] }"),
        Document.parse("{ item: 'postcard', instock: [ { warehouse: 'B', qty: 15 }, { warehouse: 'C', qty: 35 } ] }")
));

# Subdocument key order matters in a few of these examples so we have
# to use bson.son.SON instead of a Python dict.
from bson.son import SON
await db.inventory.insert_many(
    [
        {
            "item": "journal",
            "instock": [
                SON([("warehouse", "A"), ("qty", 5)]),
                SON([("warehouse", "C"), ("qty", 15)]),
            ],
        },
        {"item": "notebook", "instock": [SON([("warehouse", "C"), ("qty", 5)])]},
        {
            "item": "paper",
            "instock": [
                SON([("warehouse", "A"), ("qty", 60)]),
                SON([("warehouse", "B"), ("qty", 15)]),
            ],
        },
        {
            "item": "planner",
            "instock": [
                SON([("warehouse", "A"), ("qty", 40)]),
                SON([("warehouse", "B"), ("qty", 5)]),
            ],
        },
        {
            "item": "postcard",
            "instock": [
                SON([("warehouse", "B"), ("qty", 15)]),
                SON([("warehouse", "C"), ("qty", 35)]),
            ],
        },
    ]
)

await db.collection('inventory').insertMany([
  {
    item: 'journal',
    instock: [
      { warehouse: 'A', qty: 5 },
      { warehouse: 'C', qty: 15 }
    ]
  },
  {
    item: 'notebook',
    instock: [{ warehouse: 'C', qty: 5 }]
  },
  {
    item: 'paper',
    instock: [
      { warehouse: 'A', qty: 60 },
      { warehouse: 'B', qty: 15 }
    ]
  },
  {
    item: 'planner',
    instock: [
      { warehouse: 'A', qty: 40 },
      { warehouse: 'B', qty: 5 }
    ]
  },
  {
    item: 'postcard',
    instock: [
      { warehouse: 'B', qty: 15 },
      { warehouse: 'C', qty: 35 }
    ]
  }
]);

# Subdocument key order matters in this example so we have
# to use Tie::IxHash instead of a regular, unordered Perl hash.
$db->coll("inventory")->insert_many(
    [
        {
            item    => "journal",
            instock => [
                Tie::IxHash->new( warehouse => "A", qty => 5 ),
                Tie::IxHash->new( warehouse => "C", qty => 15 )
            ]
        },
        {
            item    => "notebook",
            instock => [ Tie::IxHash->new( warehouse => "C", qty => 5 ) ]
        },
        {
            item    => "paper",
            instock => [
                Tie::IxHash->new( warehouse => "A", qty => 60 ),
                Tie::IxHash->new( warehouse => "B", qty => 15 )
            ]
        },
        {
            item    => "planner",
            instock => [
                Tie::IxHash->new( warehouse => "A", qty => 40 ),
                Tie::IxHash->new( warehouse => "B", qty => 5 )
            ]
        },
        {
            item    => "postcard",
            instock => [
                Tie::IxHash->new( warehouse => "B", qty => 15 ),
                Tie::IxHash->new( warehouse => "C", qty => 35 )
            ]
        }
    ]
);

$insertManyResult = $db->inventory->insertMany([
    [
        'item' => 'journal',
        'instock' => [
            ['warehouse' => 'A',  'qty' => 5],
            ['warehouse' => 'C',  'qty' => 15],
        ],
    ],
    [
        'item' => 'notebook',
        'instock' => [
            ['warehouse' => 'C',  'qty' => 5],
        ],
    ],
    [
        'item' => 'paper',
        'instock' => [
            ['warehouse' => 'A',  'qty' => 60],
            ['warehouse' => 'B',  'qty' => 15],
        ],
    ],
    [
        'item' => 'planner',
        'instock' => [
            ['warehouse' => 'A',  'qty' => 40],
            ['warehouse' => 'B',  'qty' => 5],
        ],
    ],
    [
        'item' => 'postcard',
        'instock' => [
            ['warehouse' => 'B',  'qty' => 15],
            ['warehouse' => 'C',  'qty' => 35],
        ],
    ],
]);

# Subdocument key order matters in a few of these examples so we have
# to use bson.son.SON instead of a Python dict.
from bson.son import SON
db.inventory.insert_many(
    [
        {
            "item": "journal",
            "instock": [
                SON([("warehouse", "A"), ("qty", 5)]),
                SON([("warehouse", "C"), ("qty", 15)]),
            ],
        },
        {"item": "notebook", "instock": [SON([("warehouse", "C"), ("qty", 5)])]},
        {
            "item": "paper",
            "instock": [
                SON([("warehouse", "A"), ("qty", 60)]),
                SON([("warehouse", "B"), ("qty", 15)]),
            ],
        },
        {
            "item": "planner",
            "instock": [
                SON([("warehouse", "A"), ("qty", 40)]),
                SON([("warehouse", "B"), ("qty", 5)]),
            ],
        },
        {
            "item": "postcard",
            "instock": [
                SON([("warehouse", "B"), ("qty", 15)]),
                SON([("warehouse", "C"), ("qty", 35)]),
            ],
        },
    ]
)

client[:inventory].insert_many([{ item: 'journal',
                                  instock: [ { warehouse: 'A', qty: 5 },
                                             { warehouse: 'C', qty: 15 }] },
                                { item: 'notebook',
                                  instock: [ { warehouse: 'C', qty: 5 }] },
                                { item: 'paper',
                                  instock: [ { warehouse: 'A', qty: 60 },
                                             { warehouse: 'B', qty: 15 }] },
                                { item: 'planner',
                                  instock: [ { warehouse: 'A', qty: 40 },
                                             { warehouse: 'B', qty: 5 }] },
                                { item: 'postcard',
                                  instock: [ { warehouse: 'B', qty: 15 },
                                             { warehouse: 'C', qty: 35 }] }
                               ])

collection.insertMany(Seq(
  Document("""{ item: "journal", instock: [ { warehouse: "A", qty: 5 }, { warehouse: "C", qty: 15 } ] }"""),
  Document("""{ item: "notebook", instock: [ { warehouse: "C", qty: 5 } ] }"""),
  Document("""{ item: "paper", instock: [ { warehouse: "A", qty: 60 }, { warehouse: "B", qty: 15 } ] }"""),
  Document("""{ item: "planner", instock: [ { warehouse: "A", qty: 40 }, { warehouse: "B", qty: 5 } ] }"""),
  Document("""{ item: "postcard", instock: [ { warehouse: "B", qty: 15 }, { warehouse: "C", qty: 35 } ] }""")
)).execute()

配列にネストされたドキュメントのクエリ

次の例えでは instock 配列の要素が、指定されたドキュメントと一致するすべてのドキュメントを選択します。

db.inventory.find( { "instock": { warehouse: "A", qty: 5 } } )

次のフィルターを Compass のクエリバーにコピーし、[Find] ボタンをクリックします。

{ "instock": { warehouse: "A", qty: 5 } }

var filter = Builders<BsonDocument>.Filter.AnyEq("instock", new BsonDocument { { "warehouse", "A" }, { "qty", 5 } });
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"instock", bson.D{
			{"warehouse", "A"},
			{"qty", 5},
		}},
	})

FindPublisher<Document> findPublisher = collection.find(eq("instock", Document.parse("{ warehouse: 'A', qty: 5 }")));

FindIterable<Document> findIterable = collection.find(eq("instock", Document.parse("{ warehouse: 'A', qty: 5 }")));

cursor = db.inventory.find({"instock": SON([("warehouse", "A"), ("qty", 5)])})

const cursor = db.collection('inventory').find({
  instock: { warehouse: 'A', qty: 5 }
});

# Subdocument key order matters in this example so we have
# to use Tie::IxHash instead of a regular, unordered Perl hash.
$cursor = $db->coll("inventory")->find(
    { instock => Tie::IxHash->new( warehouse => "A", qty => 5 ) }
);

$cursor = $db->inventory->find(['instock' => ['warehouse' => 'A', 'qty' => 5]]);

cursor = db.inventory.find({"instock": SON([("warehouse", "A"), ("qty", 5)])})

client[:inventory].find(instock: { warehouse: 'A', qty: 5 })

var findObservable = collection.find(equal("instock", Document("warehouse" -> "A", "qty" -> 5)))

埋め込みやネストされたドキュメント全体での等価一致には、フィールドの順序も含めて、指定されたドキュメントと完全に一致する必要があります。たとえば、次のクエリは inventory コレクション内のどのドキュメントにも一致しません。

db.inventory.find( { "instock": { qty: 5, warehouse: "A" } } )

var filter = Builders<BsonDocument>.Filter.AnyEq("instock", new BsonDocument { { "qty", 5 }, { "warehouse", "A" } });
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"instock", bson.D{
			{"qty", 5},
			{"warehouse", "A"},
		}},
	})

findPublisher = collection.find(eq("instock", Document.parse("{ qty: 5, warehouse: 'A' }")));

findIterable = collection.find(eq("instock", Document.parse("{ qty: 5, warehouse: 'A' }")));

cursor = db.inventory.find({"instock": SON([("qty", 5), ("warehouse", "A")])})

const cursor = db.collection('inventory').find({
  instock: { qty: 5, warehouse: 'A' }
});

# Subdocument key order matters in this example so we have
# to use Tie::IxHash instead of a regular, unordered Perl hash.
$cursor = $db->coll("inventory")->find(
    { instock => Tie::IxHash->new( qty => 5, warehouse => "A" ) }
);

$cursor = $db->inventory->find(['instock' => ['qty' => 5, 'warehouse' => 'A']]);

cursor = db.inventory.find({"instock": SON([("qty", 5), ("warehouse", "A")])})

client[:inventory].find(instock: { qty: 5, warehouse: 'A' } )

findObservable = collection.find(equal("instock", Document("qty" -> 5, "warehouse" -> "A")))

ドキュメントの配列内のフィールドにクエリ条件を指定

ドキュメントの配列に埋め込まれたフィールドにクエリ条件を指定

配列にネストされているドキュメントのインデックス位置がわからない場合は、配列フィールドの名前とドット（.）とネストされたドキュメント内のフィールド名を連結します。

次の例では、値が 20 以下のフィールド qty を含む埋め込みドキュメントが、instock 配列に少なくとも 1 つあるドキュメントをすべて選択します。

db.inventory.find( { 'instock.qty': { $lte: 20 } } )

次のフィルターを Compass のクエリバーにコピーし、[Find] をクリックします。

{ 'instock.qty': { $lte: 20 } }

var filter = Builders<BsonDocument>.Filter.Lte("instock.qty", 20);
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"instock.qty", bson.D{
			{"$lte", 20},
		}},
	})

findPublisher = collection.find(lte("instock.qty", 20));

findIterable = collection.find(lte("instock.qty", 20));

cursor = db.inventory.find({"instock.qty": {"$lte": 20}})

const cursor = db.collection('inventory').find({
  'instock.qty': { $lte: 20 }
});

$cursor = $db->coll("inventory")->find( { 'instock.qty' => { '$lte' => 20 } } );

$cursor = $db->inventory->find(['instock.qty' => ['$lte' => 20]]);

cursor = db.inventory.find({"instock.qty": {"$lte": 20}})

client[:inventory].find('instock.qty' => { '$lte' => 20 })

findObservable = collection.find(lte("instock.qty", 20))

配列インデックスを使用して埋め込みドキュメント内のフィールドをクエリ

ドット表記を使用すると、配列の特定のインデックスや位置にあるドキュメント内のフィールドのクエリ条件を指定できます。配列は 0 から始まるインデックスを使用します。

注意

ドット表記を使用してクエリを実行する場合、フィールドとインデックスは引用符で囲む必要があります。

次の例では、フィールド qty の値が 20 以下のドキュメントが、instock 配列の最初の要素として含まれているドキュメントをすべて選択します。

db.inventory.find( { 'instock.0.qty': { $lte: 20 } } )

次のフィルターを Compass のクエリバーにコピーし、[Find] をクリックします。

{ 'instock.0.qty': { $lte: 20 } }

var filter = Builders<BsonDocument>.Filter.Lte("instock.0.qty", 20);
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"instock.0.qty", bson.D{
			{"$lte", 20},
		}},
	})

findPublisher = collection.find(lte("instock.0.qty", 20));

findIterable = collection.find(lte("instock.0.qty", 20));

cursor = db.inventory.find({"instock.0.qty": {"$lte": 20}})

const cursor = db.collection('inventory').find({
  'instock.0.qty': { $lte: 20 }
});

$cursor = $db->coll("inventory")->find( { 'instock.0.qty' => { '$lte' => 20 } } );

$cursor = $db->inventory->find(['instock.0.qty' => ['$lte' => 20]]);

cursor = db.inventory.find({"instock.0.qty": {"$lte": 20}})

client[:inventory].find('instock.0.qty' => { '$lte' => 20 })

findObservable = collection.find(lte("instock.0.qty", 20))

ドキュメントの配列に複数の条件を指定

ドキュメントの配列にネストされた複数のフィールドに対して条件を指定する場合、単一のドキュメントがこれらの条件を満たすか、配列内の任意のドキュメントの組み合わせ（単一のドキュメントを含む）が条件を満たすようにクエリを指定できます。

ネストされた単一のドキュメントが、ネストされたフィールドの複数のクエリ条件を満たす

$elemMatch 演算子を使用して、少なくとも 1 つの埋め込みドキュメントが指定の条件をすべて満たすように、埋め込みドキュメントの配列に複数の条件を指定します。

次の例では、フィールド qty が 5 に等しく、かつフィールド warehouse が A に等しい埋め込みドキュメントが、instock 配列に少なくとも 1 つあるドキュメントをクエリします。

db.inventory.find( { "instock": { $elemMatch: { qty: 5, warehouse: "A" } } } )

次のフィルターを Compass のクエリバーにコピーし、[Find] をクリックします。

{ "instock": { $elemMatch: { qty: 5, warehouse: "A" } } }

var filter = Builders<BsonDocument>.Filter.ElemMatch<BsonValue>("instock", new BsonDocument { { "qty", 5 }, { "warehouse", "A" } });
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"instock", bson.D{
			{"$elemMatch", bson.D{
				{"qty", 5},
				{"warehouse", "A"},
			}},
		}},
	})

findPublisher = collection.find(elemMatch("instock", Document.parse("{ qty: 5, warehouse: 'A' }")));

findIterable = collection.find(elemMatch("instock", Document.parse("{ qty: 5, warehouse: 'A' }")));

cursor = db.inventory.find({"instock": {"$elemMatch": {"qty": 5, "warehouse": "A"}}})

const cursor = db.collection('inventory').find({
  instock: { $elemMatch: { qty: 5, warehouse: 'A' } }
});

$cursor = $db->coll("inventory")->find(
    { instock => { '$elemMatch' => { qty => 5, warehouse => "A" } } }
);

$cursor = $db->inventory->find(['instock' => ['$elemMatch' => ['qty' => 5, 'warehouse' => 'A']]]);

cursor = db.inventory.find({"instock": {"$elemMatch": {"qty": 5, "warehouse": "A"}}})

client[:inventory].find(instock: { '$elemMatch' => { qty: 5,
                                                     warehouse: 'A' } })

findObservable = collection.find(elemMatch("instock", Document("qty" -> 5, "warehouse" -> "A")))

次の例では、フィールド qty が 10 より大きく 20 より小さい埋め込みドキュメントが、instock 配列に少なくとも 1 つあるドキュメントを検索します。

db.inventory.find( { "instock": { $elemMatch: { qty: { $gt: 10, $lte: 20 } } } } )

次のフィルターを Compass のクエリバーにコピーし、[Find] をクリックします。

{ "instock": { $elemMatch: { qty: { $gt: 10, $lte: 20 } } } }

var filter = Builders<BsonDocument>.Filter.ElemMatch<BsonValue>("instock", new BsonDocument { { "qty", new BsonDocument { { "$gt", 10 }, { "$lte", 20 } } } });
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"instock", bson.D{
			{"$elemMatch", bson.D{
				{"qty", bson.D{
					{"$gt", 10},
					{"$lte", 20},
				}},
			}},
		}},
	})

findPublisher = collection.find(elemMatch("instock", Document.parse("{ qty: { $gt: 10, $lte: 20 } }")));

findIterable = collection.find(elemMatch("instock", Document.parse("{ qty: { $gt: 10, $lte: 20 } }")));

cursor = db.inventory.find({"instock": {"$elemMatch": {"qty": {"$gt": 10, "$lte": 20}}}})

const cursor = db.collection('inventory').find({
  instock: { $elemMatch: { qty: { $gt: 10, $lte: 20 } } }
});

$cursor = $db->coll("inventory") ->find(
    { instock => { '$elemMatch' => { qty => { '$gt' => 10, '$lte' => 20 } } } }
);

$cursor = $db->inventory->find(['instock' => ['$elemMatch' => ['qty' => ['$gt' => 10, '$lte' => 20]]]]);

cursor = db.inventory.find({"instock": {"$elemMatch": {"qty": {"$gt": 10, "$lte": 20}}}})

client[:inventory].find(instock: { '$elemMatch' => { qty: { '$gt'  => 10,
                                                            '$lte' => 20 } } })

findObservable = collection.find(elemMatch("instock", Document("""{ qty: { $gt: 10, $lte: 20 } }""")))

要素の組み合わせが基準を満たす

配列フィールドの複合クエリ条件で $elemMatch 演算子が使用されていない場合、クエリは条件を満たす要素の任意の組み合わせが配列に含まれているドキュメントを選択します。

たとえば、次のクエリは、instock 配列にネストされたドキュメントのうち、qty フィールドが 10 より大きいドキュメントと、qty フィールドが 20 より小さいドキュメント（ただし、必ずしも同じ埋め込みドキュメントである必要はない）に一致します。

db.inventory.find( { "instock.qty": { $gt: 10,  $lte: 20 } } )

次のフィルターを Compass のクエリバーにコピーし、[Find] をクリックします。

{ "instock.qty": { $gt: 10,  $lte: 20 } }

var builder = Builders<BsonDocument>.Filter;
var filter = builder.And(builder.Gt("instock.qty", 10), builder.Lte("instock.qty", 20));
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"instock.qty", bson.D{
			{"$gt", 10},
			{"$lte", 20},
		}},
	})

findPublisher = collection.find(and(gt("instock.qty", 10), lte("instock.qty", 20)));

findIterable = collection.find(and(gt("instock.qty", 10), lte("instock.qty", 20)));

cursor = db.inventory.find({"instock.qty": {"$gt": 10, "$lte": 20}})

const cursor = db.collection('inventory').find({
  'instock.qty': { $gt: 10, $lte: 20 }
});

$cursor = $db->coll("inventory")->find(
    { "instock.qty" => { '$gt' => 10, '$lte' => 20 } }
);

$cursor = $db->inventory->find(['instock.qty' => ['$gt' => 10, '$lte' => 20]]);

cursor = db.inventory.find({"instock.qty": {"$gt": 10, "$lte": 20}})

client[:inventory].find('instock.qty' => { '$gt' => 10, '$lte' => 20 })

findObservable = collection.find(and(gt("instock.qty", 10), lte("instock.qty", 20)))

次の例では、instock 配列に、フィールド qty が5 に等しい埋め込みドキュメントが少なくとも 1 つと、フィールド warehouse が A に等しい埋め込みドキュメント（ただし、必ずしも同じ埋め込みドキュメントである必要はない）が少なくとも 1 つあるドキュメントをクエリします。

db.inventory.find( { "instock.qty": 5, "instock.warehouse": "A" } )

次のフィルターを Compass のクエリバーにコピーし、[Find] をクリックします。

{ "instock.qty": 5, "instock.warehouse": "A" }

var builder = Builders<BsonDocument>.Filter;
var filter = builder.And(builder.Eq("instock.qty", 5), builder.Eq("instock.warehouse", "A"));
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"instock.qty", 5},
		{"instock.warehouse", "A"},
	})

findPublisher = collection.find(and(eq("instock.qty", 5), eq("instock.warehouse", "A")));

findIterable = collection.find(and(eq("instock.qty", 5), eq("instock.warehouse", "A")));

cursor = db.inventory.find({"instock.qty": 5, "instock.warehouse": "A"})

const cursor = db.collection('inventory').find({
  'instock.qty': 5,
  'instock.warehouse': 'A'
});

$cursor = $db->coll("inventory")->find(
    { "instock.qty" => 5, "instock.warehouse" => "A" }
);

$cursor = $db->inventory->find(['instock.qty' => 5, 'instock.warehouse' => 'A']);

cursor = db.inventory.find({"instock.qty": 5, "instock.warehouse": "A"})

client[:inventory].find('instock.qty' => 5,
                        'instock.warehouse' => 'A')

findObservable = collection.find(and(equal("instock.qty", 5), equal("instock.warehouse", "A")))

MongoDB Atlas でドキュメントの配列をクエリする

このセクションの例では、訓練用サンプルデータセットを使用します。サンプルデータセットを MongoDB Atlas 配置にロードする方法について詳しくは、「サンプルデータのロード」を参照してください。

MongoDB Atlas 内のドキュメントの配列をクエリするには、次の手順に従います。

MongoDB Atlas UI で、プロジェクトのClusters ページに移動します。

まだ表示されていない場合は、希望するプロジェクトを含む組織を選択しますナビゲーションバーのOrganizationsメニュー
まだ表示されていない場合は、ナビゲーションバーの Projects メニューからプロジェクトを選択します。
まだ表示されていない場合は、サイドバーの Clusters をクリックしてください。
[ Clusters （クラスター） ] ページが表示されます。

コレクションへ移動する

サンプルデータを含むクラスターで、[ Browse Collections ] をクリックします。
左側のナビゲーションペインで、sample_training データベースを選択します。
grades コレクションを選択します。

[Filter] フィールドを指定します

Filter フィールドにクエリフィルタードキュメントを指定します。クエリフィルタードキュメントは、クエリ演算子を使用して検索条件を指定します。

次のクエリフィルタードキュメントを Filter 検索バーにコピーします。

{"scores.type": "exam"}

クリック Apply

このクエリフィルターは、 typeがexamに設定されているscores配列にサブドキュメントを含む、 sample_training.gradesコレクション内のすべてのドキュメントを返します。 scores配列全体を含む完全なドキュメントが返されます。返される配列の変更の詳細については、「返される配列内のプロジェクト固有の配列要素」を参照してください。

その他のクエリに関するチュートリアル

その他のクエリの例については、以下を参照してください。

戻る

配列

プロジェクトの結果