配列のクエリ

項目一覧

配列の一致

配列内の要素のクエリ
配列要素に複数の条件を指定
MongoDB Atlas を使用した配列のクエリ
その他のクエリに関するチュートリアル

MongoDB では、以下の方法で配列をクエリできます。

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

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

このページでは、db.collection.find() メソッドを使用して配列フィールドにおける mongosh でのクエリ操作の例を取り上げます。

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

このページでは、MongoDB Compass を使用した配列フィールドにおけるクエリ操作の例を取り上げます。

このページでは、 mongoc_collection_find_with_opts を使用した、配列フィールドにおけるクエリ操作の例を取り上げます。

このページでは、MongoCollection.Find() メソッドを使用した、配列フィールドにおける MongoDB C# ドライバーでのクエリ操作の例を取り上げます。

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

このページでは、com.mongodb.reactivestreams.client.MongoCollection.find メソッドを使用した、配列フィールドにおける MongoDB Java Reactive Streams ドライバーでのクエリ操作の例を取り上げます。

このページでは、 com.mongodb.client.MongoCollection.find を使用した、配列フィールドにおけるクエリ操作の例を取り上げますメソッドを使用した、 MongoDB Java 同期ドライバーでのクエリ操作の例を取り上げます。

Tip

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

このページでは、 MongoCollection.find()MongoDB Kotlin コルーチンドライバーで実行されるクエリ操作の例を取りあげます。

Tip

このページでは、motor.motor_asyncio.AsyncIOMotorCollection.find メソッドを使用した、配列フィールドにおける Motor ドライバーでのクエリ操作の例を取り上げます。

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

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

このページでは、MongoDB\\Collection::find() メソッドを使用した、配列フィールドにおける MongoDB PHP ライブラリでのクエリ操作の例を取り上げます。

このページでは、pymongo.collection.Collection.find メソッドを使用した、配列フィールドにおける PyMongo Python ドライバーでのクエリ操作の例を取り上げます。

このページでは、Mongo::Collection#find() メソッドを使用した、配列フィールドにおける MongoDB Ruby ドライバーでのクエリ操作の例を取り上げます。

このページでは、コレクション.find() メソッドを使用した、配列フィールドにおける MongoDB Scala ドライバーでのクエリ操作の例を取り上げます。

db.inventory.insertMany([
   { item: "journal", qty: 25, tags: ["blank", "red"], dim_cm: [ 14, 21 ] },
   { item: "notebook", qty: 50, tags: ["red", "blank"], dim_cm: [ 14, 21 ] },
   { item: "paper", qty: 100, tags: ["red", "blank", "plain"], dim_cm: [ 14, 21 ] },
   { item: "planner", qty: 75, tags: ["blank", "red"], dim_cm: [ 22.85, 30 ] },
   { item: "postcard", qty: 45, tags: ["blue"], dim_cm: [ 10, 15.25 ] }
]);

[
    { "item": "journal", "qty": 25, "tags": ["blank", "red"], "dim_cm": [ 14, 21 ] },
    { "item": "notebook", "qty": 50, "tags": ["red", "blank"], "dim_cm": [ 14, 21 ] },
    { "item": "paper", "qty": 100, "tags": ["red", "blank", "plain"], "dim_cm": [ 14, 21 ] },
    { "item": "planner", "qty": 75, "tags": ["blank", "red"], "dim_cm": [ 22.85, 30 ] },
    { "item": "postcard", "qty": 45, "tags": ["blue"], "dim_cm": [ 10, 15.25 ] }
]

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

mongoc_collection_t *collection;
mongoc_bulk_operation_t *bulk;
bson_t *doc;
bool r;
bson_error_t error;
bson_t reply;
collection = mongoc_database_get_collection (db, "inventory");
bulk = mongoc_collection_create_bulk_operation_with_opts (collection, NULL);
doc = BCON_NEW (
   "item", BCON_UTF8 ("journal"),
   "qty", BCON_INT64 (25),
   "tags", "[",
   BCON_UTF8 ("blank"), BCON_UTF8 ("red"),
   "]",
   "dim_cm", "[",
   BCON_INT64 (14), BCON_INT64 (21),
   "]");
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("notebook"),
   "qty", BCON_INT64 (50),
   "tags", "[",
   BCON_UTF8 ("red"), BCON_UTF8 ("blank"),
   "]",
   "dim_cm", "[",
   BCON_INT64 (14), BCON_INT64 (21),
   "]");
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("paper"),
   "qty", BCON_INT64 (100),
   "tags", "[",
   BCON_UTF8 ("red"), BCON_UTF8 ("blank"), BCON_UTF8 ("plain"),
   "]",
   "dim_cm", "[",
   BCON_INT64 (14), BCON_INT64 (21),
   "]");
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("planner"),
   "qty", BCON_INT64 (75),
   "tags", "[",
   BCON_UTF8 ("blank"), BCON_UTF8 ("red"),
   "]",
   "dim_cm", "[",
   BCON_DOUBLE (22.85), BCON_INT64 (30),
   "]");
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("postcard"),
   "qty", BCON_INT64 (45),
   "tags", "[",
   BCON_UTF8 ("blue"),
   "]",
   "dim_cm", "[",
   BCON_INT64 (10), BCON_DOUBLE (15.25),
   "]");
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
/* "reply" is initialized on success or error */
r = (bool) mongoc_bulk_operation_execute (bulk, &reply, &error);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
}

var documents = new[]
{
    new BsonDocument
    {
        { "item", "journal" },
        { "qty", 25 },
        { "tags", new BsonArray { "blank", "red" } },
        { "dim_cm", new BsonArray { 14, 21 } }
    },
    new BsonDocument
    {
        { "item", "notebook" },
        { "qty", 50 },
        { "tags", new BsonArray { "red", "blank" } },
        { "dim_cm", new BsonArray { 14, 21 } }
    },
    new BsonDocument
    {
        { "item", "paper" },
        { "qty", 100 },
        { "tags", new BsonArray { "red", "blank", "plain" } },
        { "dim_cm", new BsonArray { 14, 21 } }
    },
    new BsonDocument
    {
        { "item", "planner" },
        { "qty", 75 },
        { "tags", new BsonArray { "blank", "red" } },
        { "dim_cm", new BsonArray { 22.85, 30 } }
    },
    new BsonDocument
    {
        { "item", "postcard" },
        { "qty", 45 },
        { "tags", new BsonArray { "blue" } },
        { "dim_cm", new BsonArray { 10, 15.25 } }
    }
};
collection.InsertMany(documents);

docs := []interface{}{
	bson.D{
		{"item", "journal"},
		{"qty", 25},
		{"tags", bson.A{"blank", "red"}},
		{"dim_cm", bson.A{14, 21}},
	},
	bson.D{
		{"item", "notebook"},
		{"qty", 50},
		{"tags", bson.A{"red", "blank"}},
		{"dim_cm", bson.A{14, 21}},
	},
	bson.D{
		{"item", "paper"},
		{"qty", 100},
		{"tags", bson.A{"red", "blank", "plain"}},
		{"dim_cm", bson.A{14, 21}},
	},
	bson.D{
		{"item", "planner"},
		{"qty", 75},
		{"tags", bson.A{"blank", "red"}},
		{"dim_cm", bson.A{22.85, 30}},
	},
	bson.D{
		{"item", "postcard"},
		{"qty", 45},
		{"tags", bson.A{"blue"}},
		{"dim_cm", bson.A{10, 15.25}},
	},
}
result, err := coll.InsertMany(context.TODO(), docs)

Publisher<Success> insertManyPublisher = collection.insertMany(asList(
        Document.parse("{ item: 'journal', qty: 25, tags: ['blank', 'red'], dim_cm: [ 14, 21 ] }"),
        Document.parse("{ item: 'notebook', qty: 50, tags: ['red', 'blank'], dim_cm: [ 14, 21 ] }"),
        Document.parse("{ item: 'paper', qty: 100, tags: ['red', 'blank', 'plain'], dim_cm: [ 14, 21 ] }"),
        Document.parse("{ item: 'planner', qty: 75, tags: ['blank', 'red'], dim_cm: [ 22.85, 30 ] }"),
        Document.parse("{ item: 'postcard', qty: 45, tags: ['blue'], dim_cm: [ 10, 15.25 ] }")
));

collection.insertMany(asList(
        Document.parse("{ item: 'journal', qty: 25, tags: ['blank', 'red'], dim_cm: [ 14, 21 ] }"),
        Document.parse("{ item: 'notebook', qty: 50, tags: ['red', 'blank'], dim_cm: [ 14, 21 ] }"),
        Document.parse("{ item: 'paper', qty: 100, tags: ['red', 'blank', 'plain'], dim_cm: [ 14, 21 ] }"),
        Document.parse("{ item: 'planner', qty: 75, tags: ['blank', 'red'], dim_cm: [ 22.85, 30 ] }"),
        Document.parse("{ item: 'postcard', qty: 45, tags: ['blue'], dim_cm: [ 10, 15.25 ] }")
));

collection.insertMany(
    listOf(
        Document("item", "journal")
            .append("qty", 25)
            .append("tags", listOf("blank", "red"))
            .append("dim_cm", listOf(14, 21)),
        Document("item", "notebook")
            .append("qty", 50)
            .append("tags", listOf("red", "blank"))
            .append("dim_cm", listOf(14, 21)),
        Document("item", "paper")
            .append("qty", 100)
            .append("tags", listOf("red", "blank", "plain"))
            .append("dim_cm", listOf(14, 21)),
        Document("item", "planner")
            .append("qty", 75)
            .append("tags", listOf("blank", "red"))
            .append("dim_cm", listOf(22.85, 30)),
        Document("item", "postcard")
            .append("qty", 45)
            .append("tags", listOf("blue"))
            .append("dim_cm", listOf(10, 15.25)),
    )
)

await db.inventory.insert_many(
    [
        {"item": "journal", "qty": 25, "tags": ["blank", "red"], "dim_cm": [14, 21]},
        {"item": "notebook", "qty": 50, "tags": ["red", "blank"], "dim_cm": [14, 21]},
        {
            "item": "paper",
            "qty": 100,
            "tags": ["red", "blank", "plain"],
            "dim_cm": [14, 21],
        },
        {"item": "planner", "qty": 75, "tags": ["blank", "red"], "dim_cm": [22.85, 30]},
        {"item": "postcard", "qty": 45, "tags": ["blue"], "dim_cm": [10, 15.25]},
    ]
)

await db.collection('inventory').insertMany([
  {
    item: 'journal',
    qty: 25,
    tags: ['blank', 'red'],
    dim_cm: [14, 21]
  },
  {
    item: 'notebook',
    qty: 50,
    tags: ['red', 'blank'],
    dim_cm: [14, 21]
  },
  {
    item: 'paper',
    qty: 100,
    tags: ['red', 'blank', 'plain'],
    dim_cm: [14, 21]
  },
  {
    item: 'planner',
    qty: 75,
    tags: ['blank', 'red'],
    dim_cm: [22.85, 30]
  },
  {
    item: 'postcard',
    qty: 45,
    tags: ['blue'],
    dim_cm: [10, 15.25]
  }
]);

$db->coll("inventory")->insert_many(
    [
        {
            item   => "journal",
            qty    => 25,
            tags   => [ "blank", "red" ],
            dim_cm => [ 14, 21 ]
        },
        {
            item   => "notebook",
            qty    => 50,
            tags   => [ "red", "blank" ],
            dim_cm => [ 14, 21 ]
        },
        {
            item   => "paper",
            qty    => 100,
            tags   => [ "red", "blank", "plain" ],
            dim_cm => [ 14, 21 ]
        },
        {
            item   => "planner",
            qty    => 75,
            tags   => [ "blank", "red" ],
            dim_cm => [ 22.85, 30 ]
        },
        {
            item   => "postcard",
            qty    => 45,
            tags   => ["blue"],
            dim_cm => [ 10, 15.25 ]
        }
    ]
);

$insertManyResult = $db->inventory->insertMany([
    [
        'item' => 'journal',
        'qty' => 25,
        'tags' => ['blank', 'red'],
        'dim_cm' => [14, 21],
    ],
    [
        'item' => 'notebook',
        'qty' => 50,
        'tags' => ['red', 'blank'],
        'dim_cm' => [14, 21],
    ],
    [
        'item' => 'paper',
        'qty' => 100,
        'tags' => ['red', 'blank', 'plain'],
        'dim_cm' => [14, 21],
    ],
    [
        'item' => 'planner',
        'qty' => 75,
        'tags' => ['blank', 'red'],
        'dim_cm' => [22.85, 30],
    ],
    [
        'item' => 'postcard',
        'qty' => 45,
        'tags' => ['blue'],
        'dim_cm' => [10, 15.25],
    ],
]);

db.inventory.insert_many(
    [
        {"item": "journal", "qty": 25, "tags": ["blank", "red"], "dim_cm": [14, 21]},
        {"item": "notebook", "qty": 50, "tags": ["red", "blank"], "dim_cm": [14, 21]},
        {
            "item": "paper",
            "qty": 100,
            "tags": ["red", "blank", "plain"],
            "dim_cm": [14, 21],
        },
        {"item": "planner", "qty": 75, "tags": ["blank", "red"], "dim_cm": [22.85, 30]},
        {"item": "postcard", "qty": 45, "tags": ["blue"], "dim_cm": [10, 15.25]},
    ]
)

client[:inventory].insert_many([{ item: 'journal',
                                  qty: 25,
                                  tags: ['blank', 'red'],
                                  dim_cm: [ 14, 21 ] },
                                { item: 'notebook',
                                  qty: 50,
                                  tags: ['red', 'blank'],
                                  dim_cm: [ 14, 21 ] },
                                { item: 'paper',
                                  qty: 100,
                                  tags: ['red', 'blank', 'plain'],
                                  dim_cm: [ 14, 21 ] },
                                { item: 'planner',
                                  qty: 75,
                                  tags: ['blank', 'red'],
                                  dim_cm: [ 22.85, 30 ] },
                                { item: 'postcard',
                                  qty: 45,
                                  tags: ['blue'],
                                  dim_cm: [ 10, 15.25 ] }
                               ])

collection.insertMany(Seq(
  Document("""{ item: "journal", qty: 25, tags: ["blank", "red"], dim_cm: [ 14, 21 ] }"""),
  Document("""{ item: "notebook", qty: 50, tags: ["red", "blank"], dim_cm: [ 14, 21 ] }"""),
  Document("""{ item: "paper", qty: 100, tags: ["red", "blank", "plain"], dim_cm: [ 14, 21 ] }"""),
  Document("""{ item: "planner", qty: 75, tags: ["blank", "red"], dim_cm: [ 22.85, 30 ] }"""),
  Document("""{ item: "postcard", qty: 45, tags: ["blue"], dim_cm: [ 10, 15.25 ] }""")
)).execute()

配列の一致

配列に等価条件を指定するには、クエリドキュメント { <field>: <value> } を使用します。ここでは、<value> は、要素の順序を含め、完全一致する配列です。

配列に等価条件を指定するには、 Eq を使用してフィルターを構築しますメソッドとして、は一致させる正確な配列を含め、要素の順序も指定します。<value>

Builders<BsonDocument>.Filter.Eq(<field>, <value>)

配列に等価条件を指定するには、クエリドキュメント eq( <field>, <value>) を使用します。ここでは、<value> は、要素の順序を含め、完全一致する配列です。

配列に等価条件を指定するには、クエリドキュメント { <field> => <value> } を使用します。ここでは、<value> は、要素の順序を含め、完全一致する配列です。

配列に等価条件を指定するには、クエリドキュメント [ <field> => <value> ] を使用します。ここでは、<value> は、要素の順序を含め、完全一致する配列です。

配列に等価条件を指定するには、クエリドキュメント equal( <field>, <value> ) を使用します。ここでは、<value> は、要素の順序を含め、完全一致する配列です。

次の例では、フィールド tags の値が "red" と "blank" の 2 つの要素だけを含む配列で、指定された順序ですべてのドキュメントをクエリします。

db.inventory.find( { tags: ["red", "blank"] } )

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

{ tags: ["red", "blank"] }

mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "tags", "[",
   BCON_UTF8 ("red"), BCON_UTF8 ("blank"),
   "]");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);

var filter = Builders<BsonDocument>.Filter.Eq("tags", new[] { "red", "blank" });
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{{"tags", bson.A{"red", "blank"}}},
)

FindPublisher<Document> findPublisher = collection.find(eq("tags", asList("red", "blank")));

FindIterable<Document> findIterable = collection.find(eq("tags", asList("red", "blank")));

val findFlow = collection
    .find(eq("tags", listOf("red", "blank")))

cursor = db.inventory.find({"tags": ["red", "blank"]})

const cursor = db.collection('inventory').find({
  tags: ['red', 'blank']
});

$cursor = $db->coll("inventory")->find( { tags => [ "red", "blank" ] } );

$cursor = $db->inventory->find(['tags' => ['red', 'blank']]);

cursor = db.inventory.find({"tags": ["red", "blank"]})

client[:inventory].find(tags: ['red', 'blank'])

var findObservable = collection.find(equal("tags", Seq("red", "blank")))

代わりに、配列内の順序や他の要素に関係なく、"red" 要素と "blank" 要素の両方を含む配列を検索する場合は、$all 演算子を使用します。

db.inventory.find( { tags: { $all: ["red", "blank"] } } )

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

{ tags: { $all: ["red", "blank"] } }

mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "tags", "{",
   "$all", "[",
   BCON_UTF8 ("red"), BCON_UTF8 ("blank"),
   "]",
   "}");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);

var filter = Builders<BsonDocument>.Filter.All("tags", new[] { "red", "blank" });
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"tags", bson.D{{"$all", bson.A{"red", "blank"}}}},
	})

findPublisher = collection.find(all("tags", asList("red", "blank")));

findIterable = collection.find(all("tags", asList("red", "blank")));

val findFlow = collection
    .find(all("tags", listOf("red", "blank")))

cursor = db.inventory.find({"tags": {"$all": ["red", "blank"]}})

const cursor = db.collection('inventory').find({
  tags: { $all: ['red', 'blank'] }
});

$cursor = $db->coll("inventory")->find( { tags => { '$all' => [ "red", "blank" ] } } );

$cursor = $db->inventory->find(['tags' => ['$all' => ['red', 'blank']]]);

cursor = db.inventory.find({"tags": {"$all": ["red", "blank"]}})

client[:inventory].find(tags: { '$all' => ['red', 'blank'] })

findObservable = collection.find(all("tags", "red", "blank"))

配列内の要素のクエリ

配列フィールドに、指定された値を持つ要素が少なくとも 1 つ含まれているかどうかをクエリするには、{ <field>: <value> } フィルターを使用します。ここでは、<value>　は要素値です。

配列フィールドに、指定された値を持つ要素が少なくとも 1 つ 含まれているかどうかをクエリするには、 Eq を使用してフィルターを構築しますメソッドとして、<value> は一致させる要素の値です。

Builders<BsonDocument>.Filter.Eq(<field>, <value>)

配列フィールドに指定された値を持つ要素が少なくとも 1つ含まれているかどうかをクエリするには、値が要素の値であるフィルター eq( <field>, <value>) を使用します。

配列フィールドに、指定された値を持つ要素が少なくとも 1 つ含まれているかどうかをクエリするには、eq( <field>, <value>) フィルターを使用します。ここでは、<value>　は要素値です。

配列フィールドに、指定された値を持つ要素が少なくとも1 つ含まれているかどうかをクエリするには、フィルターを使用します

{ <field> => <value> } 上記で、値は要素の値です。

配列フィールドに、指定された値を持つ要素が少なくとも 1 つ含まれているかどうかをクエリするには、[ <field> => <value> ] フィルターを使用します。ここでは、<value>　は要素値です。

配列フィールドに、指定された値を持つ要素が少なくとも 1 つ含まれているかどうかをクエリするには、{ <field> => <value> } フィルターを使用します。ここでは、<value>　は要素値です。

配列フィールドに、指定された値を持つ要素が少なくとも 1 つ含まれているかどうかをクエリするには、equal( <field>, <value> ) フィルターを使用します。ここでは、<value>　は要素値です。

次の例では、tags が要素の 1 つとして文字列 "red" を含む配列であるすべてのドキュメントをクエリします。

db.inventory.find( { tags: "red" } )

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

{ tags: "red" }

mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("tags", BCON_UTF8 ("red"));
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);

var filter = Builders<BsonDocument>.Filter.Eq("tags", "red");
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"tags", "red"},
	})

findPublisher = collection.find(eq("tags", "red"));

findIterable = collection.find(eq("tags", "red"));

val findFlow = collection
    .find(eq("tags", "red"))

cursor = db.inventory.find({"tags": "red"})

const cursor = db.collection('inventory').find({
  tags: 'red'
});

$cursor = $db->coll("inventory")->find( { tags => "red" } );

$cursor = $db->inventory->find(['tags' => 'red']);

cursor = db.inventory.find({"tags": "red"})

client[:inventory].find(tags: 'red')

findObservable = collection.find(equal("tags", "red"))

配列フィールド内の要素に条件を指定するには、クエリフィルタードキュメントでクエリ演算子を使用します。

{ <array field>: { <operator1>: <value1>, ... } }

配列フィールド内の要素に条件を指定するには、クエリフィルタードキュメントでクエリ演算子を使用します。

{ <array field>: { <operator1>: <value1>, ... } }

配列フィールド内の要素に条件を指定するには、クエリフィルタードキュメントでクエリ演算子を使用します。

{ <array field>: { <operator1>: <value1>, ... } }

配列フィールド内の要素に条件を指定するには、クエリフィルタードキュメントでクエリ演算子を使用します。以下に例を挙げます。

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<array field>, <value1>), builder.Lt(<array field>, <value2>));

配列フィールド内の要素に条件を指定するには、クエリフィルタードキュメントでクエリ演算子を使用します。以下に例を挙げます。

and(gte(<array field>, <value1>), lt(<array field>, <value2>) ...)

配列フィールド内の要素に条件を指定するには、クエリフィルタードキュメントでクエリ演算子を使用します。以下に例を挙げます。

and(gte(<array field>, <value1>), lt(<array field>, <value2>) ...)

配列フィールド内の要素に条件を指定するには、クエリフィルタードキュメントでクエリ演算子を使用します。以下に例を挙げます。

and(gte(<array field>, <value1>), lt(<array field>, <value2>) ...)

配列フィールド内の要素に条件を指定するには、クエリフィルタードキュメントでクエリ演算子を使用します。

{ <array field>: { <operator1>: <value1>, ... } }

配列フィールド内の要素に条件を指定するには、クエリフィルタードキュメントでクエリ演算子を使用します。

{ <array field> => { <operator1> => <value1>, ... } }

配列フィールド内の要素に条件を指定するには、クエリフィルタードキュメントでクエリ演算子を使用します。

[ <array field> => [ <operator1> => <value1>, ... ] ]

配列フィールド内の要素に条件を指定するには、クエリフィルタードキュメントでクエリ演算子を使用します。

{ <array field>: { <operator1>: <value1>, ... } }

配列フィールド内の要素に条件を指定するには、クエリフィルタードキュメントでクエリ演算子を使用します。

{ <array field> => { <operator1> => <value1>, ... } }

配列フィールド内の要素に条件を指定するには、クエリフィルタードキュメントでクエリ演算子を使用します。

and(gte(<array field>, <value1>), lt(<array field>, <value2>) ...)

たとえば、次の操作は、dim_cm の配列に 25 より大きい値を持つ要素が少なくとも 1 つ含まれているすべてのドキュメントに対してクエリを実行します。

db.inventory.find( { dim_cm: { $gt: 25 } } )

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

{ dim_cm: { $gt: 25 } }

mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "dim_cm", "{",
   "$gt", BCON_INT64 (25),
   "}");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);

var filter = Builders<BsonDocument>.Filter.Gt("dim_cm", 25);
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"dim_cm", bson.D{
			{"$gt", 25},
		}},
	})

findPublisher = collection.find(gt("dim_cm", 25));

findIterable = collection.find(gt("dim_cm", 25));

val findFlow = collection
    .find(gt("dim_cm", 25))

cursor = db.inventory.find({"dim_cm": {"$gt": 25}})

const cursor = db.collection('inventory').find({
  dim_cm: { $gt: 25 }
});

$cursor = $db->coll("inventory")->find( { "dim_cm" => { '$gt' => 25 } } );

$cursor = $db->inventory->find(['dim_cm' => ['$gt' => 25]]);

cursor = db.inventory.find({"dim_cm": {"$gt": 25}})

client[:inventory].find(dim_cm: { '$gt' => 25 })

findObservable = collection.find(gt("dim_cm", 25))

配列要素に複数の条件を指定

配列要素に複合条件を指定する場合、1 つの配列要素がこれらの条件を満たすか、配列要素の任意の組み合わせが条件を満たすようにクエリを指定できます。

配列要素に複合フィルター条件を指定して配列をクエリ

次の例では、dim_cm 配列に何らかの組み合わせでクエリ条件を満たす要素が含まれているドキュメントを検索します。たとえば、1つの要素が 15 より大きい条件を満たし、別の要素が 20 より小さい条件を満たす場合や、1 つの要素が両方の条件を満たす場合などです。

db.inventory.find( { dim_cm: { $gt: 15, $lt: 20 } } )

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

{ dim_cm: { $gt: 15, $lt: 20 } }

mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "dim_cm", "{",
   "$gt", BCON_INT64 (15),
   "$lt", BCON_INT64 (20),
   "}");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);

var builder = Builders<BsonDocument>.Filter;
var filter = builder.And(builder.Gt("dim_cm", 15), builder.Lt("dim_cm", 20));
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"dim_cm", bson.D{
			{"$gt", 15},
			{"$lt", 20},
		}},
	})

findPublisher = collection.find(and(gt("dim_cm", 15), lt("dim_cm", 20)));

findIterable = collection.find(and(gt("dim_cm", 15), lt("dim_cm", 20)));

val findFlow = collection
    .find(and(gt("dim_cm", 15), lt("dim_cm", 20)))

cursor = db.inventory.find({"dim_cm": {"$gt": 15, "$lt": 20}})

const cursor = db.collection('inventory').find({
  dim_cm: { $gt: 15, $lt: 20 }
});

$cursor = $db->coll("inventory")->find(
    { "dim_cm" => { '$gt' => 15, '$lt' => 20 } }
);

$cursor = $db->inventory->find([
    'dim_cm' => [
        '$gt' => 15,
        '$lt' => 20,
    ],
]);

cursor = db.inventory.find({"dim_cm": {"$gt": 15, "$lt": 20}})

client[:inventory].find(dim_cm: { '$gt' => 15,
                                  '$lt' => 20 })

findObservable = collection.find(and(gt("dim_cm", 15), lt("dim_cm", 20)))

複数の条件を満たす配列要素のクエリ

配列の要素に対して複数の条件を指定し、少なくとも 1 つの配列要素が指定された条件をすべて満たすようにするには、$elemMatch 演算子を使用します。

次の例では、dim_cm 配列に（$gt）22より大きく（$lt）30より小さい要素が少なくとも 1 つ含まれているドキュメントをクエリします。

db.inventory.find( { dim_cm: { $elemMatch: { $gt: 22, $lt: 30 } } } )

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

{ dim_cm: { $elemMatch: { $gt: 22, $lt: 30 } } }

mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "dim_cm", "{",
   "$elemMatch", "{",
   "$gt", BCON_INT64 (22),
   "$lt", BCON_INT64 (30),
   "}",
   "}");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);

var filter = Builders<BsonDocument>.Filter.ElemMatch<BsonValue>("dim_cm", new BsonDocument { { "$gt", 22 }, { "$lt", 30 } });
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"dim_cm", bson.D{
			{"$elemMatch", bson.D{
				{"$gt", 22},
				{"$lt", 30},
			}},
		}},
	})

findPublisher = collection.find(elemMatch("dim_cm", Document.parse("{ $gt: 22, $lt: 30 }")));

findIterable = collection.find(elemMatch("dim_cm", Document.parse("{ $gt: 22, $lt: 30 }")));

val findFlow = collection
    .find(elemMatch("dim_cm", Document.parse("{ \$gt: 22, \$lt: 30 }")))

cursor = db.inventory.find({"dim_cm": {"$elemMatch": {"$gt": 22, "$lt": 30}}})

const cursor = db.collection('inventory').find({
  dim_cm: { $elemMatch: { $gt: 22, $lt: 30 } }
});

$cursor = $db->coll("inventory")->find(
    { dim_cm => { '$elemMatch' => { '$gt' => 22, '$lt' => 30 } } }
);

$cursor = $db->inventory->find([
    'dim_cm' => [
        '$elemMatch' => [
            '$gt' => 22,
            '$lt' => 30,
        ],
    ],
]);

cursor = db.inventory.find({"dim_cm": {"$elemMatch": {"$gt": 22, "$lt": 30}}})

client[:inventory].find(dim_cm: { '$elemMatch' => { '$gt' => 22,
                                                    '$lt' => 30 } })

findObservable = collection.find(elemMatch("dim_cm", Document("$gt" -> 22, "$lt" -> 30)))

配列のインデックス位置による要素のクエリ

ドット表記を使用すると、配列の特定のインデックスまたは位置にある要素のクエリ条件を指定できます。配列は 0 から始まるインデックスを使用します。

注意

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

次の例では、配列 dim_cm の 2 番目の要素が 25 より大きいすべてのドキュメントをクエリします。

db.inventory.find( { "dim_cm.1": { $gt: 25 } } )

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

{ "dim_cm.1": { $gt: 25 } }

mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "dim_cm.1", "{",
   "$gt", BCON_INT64 (25),
   "}");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);

var filter = Builders<BsonDocument>.Filter.Gt("dim_cm.1", 25);
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"dim_cm.1", bson.D{
			{"$gt", 25},
		}},
	})

findPublisher = collection.find(elemMatch("dim_cm", Document.parse("{ $gt: 22, $lt: 30 }")));

findIterable = collection.find(gt("dim_cm.1", 25));

val findFlow = collection
    .find(gt("dim_cm.1", 25))

cursor = db.inventory.find({"dim_cm.1": {"$gt": 25}})

const cursor = db.collection('inventory').find({
  'dim_cm.1': { $gt: 25 }
});

$cursor = $db->coll("inventory")->find( { "dim_cm.1" => { '$gt' => 25 } } );

$cursor = $db->inventory->find(['dim_cm.1' => ['$gt' => 25]]);

cursor = db.inventory.find({"dim_cm.1": {"$gt": 25}})

client[:inventory].find('dim_cm.1' => { '$gt' => 25 })

findObservable = collection.find(gt("dim_cm.1", 25))

配列の長さによる配列のクエリ

$size 演算子を使用して、要素数で配列をクエリします。たとえば、次の例では、tags の配列に 3 つの要素があるドキュメントが選択されます。

db.inventory.find( { "tags": { $size: 3 } } )

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

{ "tags": { $size: 3 } }

mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "tags", "{",
   "$size", BCON_INT64 (3),
   "}");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);

必要に応じて、次のメソッドを呼び出して、開いているリソースもクリーンアップするようにします。

var filter = Builders<BsonDocument>.Filter.Size("tags", 3);
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"tags", bson.D{
			{"$size", 3},
		}},
	})

findPublisher = collection.find(size("tags", 3));

findIterable = collection.find(size("tags", 3));

val findFlow = collection
    .find(size("tags", 3))

cursor = db.inventory.find({"tags": {"$size": 3}})

const cursor = db.collection('inventory').find({
  tags: { $size: 3 }
});

$cursor = $db->coll("inventory")->find( { tags => { '$size' => 3 } } );

$cursor = $db->inventory->find(['tags' => ['$size' => 3]]);

cursor = db.inventory.find({"tags": {"$size": 3}})

client[:inventory].find(tags: { '$size' => 3 })

findObservable = collection.find(size("tags", 3))

MongoDB Atlas を使用した配列のクエリ

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

MongoDB Atlas で配列をクエリするには、次の手順に従います。

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

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

コレクションに移動します。

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

クエリフィルタードキュメントを指定します。

配列を含むドキュメントをクエリするには、クエリフィルタードキュメントを指定します。クエリフィルタードキュメントは、クエリ演算子を使用して検索条件を指定します。次のサンプルドキュメントを使用して、sample_mflix.movies コレクション内の配列フィールドをクエリします。

クエリフィルターを適用するには、サンプルドキュメントを Filter 検索バーにコピーして、[Apply] をクリックします。

配列に等価条件を指定するには、クエリドキュメント { <field>: <value> } を使用します。ここでは、<value> は一致させる正確な配列を含め、要素の順序も指定します。以下の例では、 genres フィールドが指定された順序で ["Action", "Comedy"] 配列を含むを持つドキュメントを検索します。

{ genres: ["Action", "Comedy"] }

配列内の順序や他の要素に関係なく、Action 要素と Comedy 要素の両方を含む配列を検索する場合は、$all 演算子を使用します。

{ genres: { $all: ["Action", "Comedy"] } }

配列フィールドに、指定された値を持つ要素が少なくとも 1 つ含まれているかどうかをクエリするには、{ <field>: <value> } フィルターを使用します。ここでは、<value>　は要素の値です。

次の例では、genres フィールドに要素の 1 つとして、Short 文字列が含まれているすべてのドキュメントをクエリします。

{ genres: "Short" }

配列フィールド内の要素に条件を指定するには、クエリフィルタードキュメントでクエリ演算子を使用します。

{ <array field>: { <operator1>: <value1>, ... } }

例えば、次の操作では $nin 演算子を使用して、genres フィールドに Drama が含まれていないすべてのドキュメントをクエリします。

{ genres: { $nin: ["Drama"] } }

配列要素に複合フィルター条件を指定して配列をクエリ

次の例では、cast 配列に何らかの組み合わせでクエリ条件を満たす要素が含まれているドキュメントをクエリします。例えば、次のフィルターでは、$regex 演算子および $eq 演算子を使用して、1 つの配列要素が Olsen で終わり、別の要素が Mary-Kate Olsen と等しい、または両方の条件を満たす単一の要素が含まれるドキュメントを返します。

{ cast: { $regex: "Olsen$", $eq: "Mary-Kate Olsen" } }

このクエリフィルターは、キャストにMary-Kate Olsenが含まれる映画と、キャストにMary-Kate OlsenとAshley Olsenの両方が含まれる映画を返します。

複数の条件を満たす配列要素のクエリ

次の例では、 $elemMatch演算子と$ne演算子を使用して、 languages配列にnullではなく、かつEnglishと等しくない要素が少なくとも 1 つ含まれているドキュメントをクエリします。

{ languages: { $elemMatch: { $ne: null, $ne: "English" } } }

配列のインデックス位置による要素のクエリ

注意

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

次の例では、 $ne演算子を使用して、countries 配列の最初の要素が USA と等しくないすべてのドキュメントをクエリします。

{ "countries.0": { $ne: "USA" }

配列の長さによる配列のクエリ

$size 演算子を使用して、要素数で配列をクエリします。たとえば、次の例では、genres の配列に 3 つの要素があるドキュメントが選択されます。

{ genres: { $size: 3 } }

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

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

戻る

埋め込みドキュメント

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

Tip

Tip

配列の一致

配列内の要素のクエリ

配列要素に複数の条件を指定

配列要素に複合フィルター条件を指定して配列をクエリ

複数の条件を満たす配列要素のクエリ

配列のインデックス位置による要素のクエリ

注意

配列の長さによる配列のクエリ

MongoDB Atlas を使用した配列のクエリ

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

コレクションに移動します。

クエリフィルター ドキュメントを指定します。

配列要素に複合フィルター条件を指定して配列をクエリ

複数の条件を満たす配列要素のクエリ

配列のインデックス位置による要素のクエリ

注意

配列の長さによる配列のクエリ

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

クエリフィルタードキュメントを指定します。