クエリドキュメント

項目一覧

コレクション内のすべてのドキュメントを選択

等価条件を指定
クエリ演算子を使用して条件を指定
AND条件の指定
OR 条件を指定
AND とOR 条件を指定
MongoDB Atlas でドキュメントをクエリする
その他のクエリに関するチュートリアル
動作
その他のメソッドとオプション

ドキュメントをクエリするには、返すドキュメントを示すクエリ述語を指定します。空のクエリ述語（ { } ）を指定すると、クエリはコレクション内のすべてのドキュメントを返します。

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

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

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

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

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

このページでは、MongoDB Compass. を使用したクエリ操作の例を取り上げます。

このページでは、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 ヘルパー　メソッドを使用すると、フィルタードキュメントの作成が簡単になります。このページでは、これらのメソッドを使用してフィルタードキュメントを作成する例を紹介します。

このページでは、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 ドライバーでのクエリ操作の例を取り上げます。

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

db.inventory.insertMany([
   { item: "journal", qty: 25, size: { h: 14, w: 21, uom: "cm" }, status: "A" },
   { item: "notebook", qty: 50, size: { h: 8.5, w: 11, uom: "in" }, status: "A" },
   { item: "paper", qty: 100, size: { h: 8.5, w: 11, uom: "in" }, status: "D" },
   { item: "planner", qty: 75, size: { h: 22.85, w: 30, uom: "cm" }, status: "D" },
   { item: "postcard", qty: 45, size: { h: 10, w: 15.25, uom: "cm" }, status: "A" }
]);

[
    { "item": "journal", "qty": 25, "size": { "h": 14, "w": 21, "uom": "cm" }, "status": "A" },
    { "item": "notebook", "qty": 50, "size": { "h": 8.5, "w": 11, "uom": "in" }, "status": "A" },
    { "item": "paper", "qty": 100, "size": { "h": 8.5, "w": 11, "uom": "in" }, "status": "D" },
    { "item": "planner", "qty": 75, "size": { "h": 22.85, "w": 30, "uom": "cm" }, "status": "D" },
    { "item": "postcard", "qty": 45, "size": { "h": 10, "w": 15.25, "uom": "cm" }, "status": "A" }
]

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

var documents = new BsonDocument[]
{
    new BsonDocument
    {
        { "item", "journal" },
        { "qty", 25 },
        { "size", new BsonDocument { { "h", 14 }, { "w", 21 }, {  "uom", "cm"} } },
        { "status", "A" }
    },
    new BsonDocument
    {
        { "item", "notebook" },
        { "qty", 50 },
        { "size", new BsonDocument { { "h",  8.5 }, { "w", 11 }, {  "uom", "in"} } },
        { "status", "A" }
    },
    new BsonDocument
    {
        { "item", "paper" },
        { "qty", 100 },
        { "size", new BsonDocument { { "h",  8.5 }, { "w", 11 }, {  "uom", "in"} } },
        { "status", "D" }
    },
    new BsonDocument
    {
        { "item", "planner" },
        { "qty", 75 },
        { "size", new BsonDocument { { "h", 22.85 }, { "w", 30  }, {  "uom", "cm"} } },
        { "status", "D" }
    },
    new BsonDocument
    {
        { "item", "postcard" },
        { "qty", 45 },
        { "size", new BsonDocument { { "h", 10 }, { "w", 15.25 }, {  "uom", "cm"} } },
        { "status", "A" }
    },
};
collection.InsertMany(documents);

docs := []interface{}{
	bson.D{
		{"item", "journal"},
		{"qty", 25},
		{"size", bson.D{
			{"h", 14},
			{"w", 21},
			{"uom", "cm"},
		}},
		{"status", "A"},
	},
	bson.D{
		{"item", "notebook"},
		{"qty", 50},
		{"size", bson.D{
			{"h", 8.5},
			{"w", 11},
			{"uom", "in"},
		}},
		{"status", "A"},
	},
	bson.D{
		{"item", "paper"},
		{"qty", 100},
		{"size", bson.D{
			{"h", 8.5},
			{"w", 11},
			{"uom", "in"},
		}},
		{"status", "D"},
	},
	bson.D{
		{"item", "planner"},
		{"qty", 75},
		{"size", bson.D{
			{"h", 22.85},
			{"w", 30},
			{"uom", "cm"},
		}},
		{"status", "D"},
	},
	bson.D{
		{"item", "postcard"},
		{"qty", 45},
		{"size", bson.D{
			{"h", 10},
			{"w", 15.25},
			{"uom", "cm"},
		}},
		{"status", "A"},
	},
}
result, err := coll.InsertMany(context.TODO(), docs)

Publisher<Success> insertManyPublisher = collection.insertMany(asList(
        Document.parse("{ item: 'journal', qty: 25, size: { h: 14, w: 21, uom: 'cm' }, status: 'A' }"),
        Document.parse("{ item: 'notebook', qty: 50, size: { h: 8.5, w: 11, uom: 'in' }, status: 'A' }"),
        Document.parse("{ item: 'paper', qty: 100, size: { h: 8.5, w: 11, uom: 'in' }, status: 'D' }"),
        Document.parse("{ item: 'planner', qty: 75, size: { h: 22.85, w: 30, uom: 'cm' }, status: 'D' }"),
        Document.parse("{ item: 'postcard', qty: 45, size: { h: 10, w: 15.25, uom: 'cm' }, status: 'A' }")
));

collection.insertMany(asList(
        Document.parse("{ item: 'journal', qty: 25, size: { h: 14, w: 21, uom: 'cm' }, status: 'A' }"),
        Document.parse("{ item: 'notebook', qty: 50, size: { h: 8.5, w: 11, uom: 'in' }, status: 'A' }"),
        Document.parse("{ item: 'paper', qty: 100, size: { h: 8.5, w: 11, uom: 'in' }, status: 'D' }"),
        Document.parse("{ item: 'planner', qty: 75, size: { h: 22.85, w: 30, uom: 'cm' }, status: 'D' }"),
        Document.parse("{ item: 'postcard', qty: 45, size: { h: 10, w: 15.25, uom: 'cm' }, status: 'A' }")
));

await db.inventory.insert_many(
    [
        {
            "item": "journal",
            "qty": 25,
            "size": {"h": 14, "w": 21, "uom": "cm"},
            "status": "A",
        },
        {
            "item": "notebook",
            "qty": 50,
            "size": {"h": 8.5, "w": 11, "uom": "in"},
            "status": "A",
        },
        {
            "item": "paper",
            "qty": 100,
            "size": {"h": 8.5, "w": 11, "uom": "in"},
            "status": "D",
        },
        {
            "item": "planner",
            "qty": 75,
            "size": {"h": 22.85, "w": 30, "uom": "cm"},
            "status": "D",
        },
        {
            "item": "postcard",
            "qty": 45,
            "size": {"h": 10, "w": 15.25, "uom": "cm"},
            "status": "A",
        },
    ]
)

await db.collection('inventory').insertMany([
  {
    item: 'journal',
    qty: 25,
    size: { h: 14, w: 21, uom: 'cm' },
    status: 'A'
  },
  {
    item: 'notebook',
    qty: 50,
    size: { h: 8.5, w: 11, uom: 'in' },
    status: 'A'
  },
  {
    item: 'paper',
    qty: 100,
    size: { h: 8.5, w: 11, uom: 'in' },
    status: 'D'
  },
  {
    item: 'planner',
    qty: 75,
    size: { h: 22.85, w: 30, uom: 'cm' },
    status: 'D'
  },
  {
    item: 'postcard',
    qty: 45,
    size: { h: 10, w: 15.25, uom: 'cm' },
    status: 'A'
  }
]);

$db->coll("inventory")->insert_many(
    [
        {
            item   => "journal",
            qty    => 25,
            size   => { h => 14, w => 21, uom => "cm" },
            status => "A"
        },
        {
            item   => "notebook",
            qty    => 50,
            size   => { h => 8.5, w => 11, uom => "in" },
            status => "A"
        },
        {
            item   => "paper",
            qty    => 100,
            size   => { h => 8.5, w => 11, uom => "in" },
            status => "D"
        },
        {
            item   => "planner",
            qty    => 75,
            size   => { h => 22.85, w => 30, uom => "cm" },
            status => "D"
        },
        {
            item   => "postcard",
            qty    => 45,
            size   => { h => 10, w => 15.25, uom => "cm" },
            status => "A"
        }
    ]
);

$insertManyResult = $db->inventory->insertMany([
    [
        'item' => 'journal',
        'qty' => 25,
        'size' => ['h' => 14, 'w' => 21, 'uom' => 'cm'],
        'status' => 'A',
    ],
    [
        'item' => 'notebook',
        'qty' => 50,
        'size' => ['h' => 8.5, 'w' => 11, 'uom' => 'in'],
        'status' => 'A',
    ],
    [
        'item' => 'paper',
        'qty' => 100,
        'size' => ['h' => 8.5, 'w' => 11, 'uom' => 'in'],
        'status' => 'D',
    ],
    [
        'item' => 'planner',
        'qty' => 75,
        'size' => ['h' => 22.85, 'w' => 30, 'uom' => 'cm'],
        'status' => 'D',
    ],
    [
        'item' => 'postcard',
        'qty' => 45,
        'size' => ['h' => 10, 'w' => 15.25, 'uom' => 'cm'],
        'status' => 'A',
    ],
]);

db.inventory.insert_many(
    [
        {
            "item": "journal",
            "qty": 25,
            "size": {"h": 14, "w": 21, "uom": "cm"},
            "status": "A",
        },
        {
            "item": "notebook",
            "qty": 50,
            "size": {"h": 8.5, "w": 11, "uom": "in"},
            "status": "A",
        },
        {
            "item": "paper",
            "qty": 100,
            "size": {"h": 8.5, "w": 11, "uom": "in"},
            "status": "D",
        },
        {
            "item": "planner",
            "qty": 75,
            "size": {"h": 22.85, "w": 30, "uom": "cm"},
            "status": "D",
        },
        {
            "item": "postcard",
            "qty": 45,
            "size": {"h": 10, "w": 15.25, "uom": "cm"},
            "status": "A",
        },
    ]
)

client[:inventory].insert_many([{ item: 'journal',
                                  qty: 25,
                                  size: { h: 14, w: 21, uom: 'cm' },
                                  status: 'A' },
                                { item: 'notebook',
                                  qty: 50,
                                  size: { h: 8.5, w: 11, uom: 'in' },
                                  status: 'A' },
                                { item: 'paper',
                                  qty: 100,
                                  size: { h: 8.5, w: 11, uom: 'in' },
                                  status: 'D' },
                                { item: 'planner',
                                  qty: 75,
                                  size: { h: 22.85, w: 30, uom: 'cm' },
                                  status: 'D' },
                                { item: 'postcard',
                                  qty: 45,
                                  size: { h: 10, w: 15.25, uom: 'cm' },
                                  status: 'A' }
                               ])

collection.insertMany(Seq(
  Document("""{ item: "journal", qty: 25, size: { h: 14, w: 21, uom: "cm" }, status: "A" }"""),
  Document("""{ item: "notebook", qty: 50, size: { h: 8.5, w: 11, uom: "in" }, status: "A" }"""),
  Document("""{ item: "paper", qty: 100, size: { h: 8.5, w: 11, uom: "in" }, status: "D" }"""),
  Document("""{ item: "planner", qty: 75, size: { h: 22.85, w: 30, uom: "cm" }, status: "D" }"""),
  Document("""{ item: "postcard", qty: 45, size: { h: 10, w: 15.25, uom: "cm" }, status: "A" }""")
)).execute()

コレクション内のすべてのドキュメントを選択

コレクション内のすべてのドキュメントを選択するには、空のドキュメントをクエリフィルターパラメーターとして find メソッドに渡します。クエリフィルターパラメータによって選択基準が決定されます。

コレクション内のすべてのドキュメントを選択するには、空のドキュメントをクエリフィルターパラメーターとしてクエリバーに渡します。クエリフィルターパラメーターによって選択基準が決定されます。

db.inventory.find( {} )

var filter = Builders<BsonDocument>.Filter.Empty;
var result = collection.Find(filter).ToList();

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

FindPublisher<Document> findPublisher = collection.find(new Document());

FindIterable<Document> findIterable = collection.find(new Document());

cursor = db.inventory.find({})

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

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

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

cursor = db.inventory.find({})

client[:inventory].find({})

var findObservable = collection.find(Document())

この操作では、次の SQL ステートメントに対応する{}のクエリ述語が使用されます。

SELECT * FROM inventory

メソッドの構文の詳細については、「find()」を参照してください。

MongoDB Compass クエリバーの詳細については、「クエリバー」を参照してください。

メソッドの構文の詳細については、Find(). を参照してください。

メソッドの構文の詳細については、com.mongodb.reactivestreams.client.MongoCollection.find を参照してください。

メソッドの構文の詳細については、 com.mongodb.client.MongoCollection.find を参照してください。

find() メソッドでサポートされているオプションを確認するには、find(). を参照してください。

メソッドの構文の詳細については、find() を参照してください。

メソッドの構文の詳細については、「find()」を参照してください。

メソッドの構文の詳細については、「find」を参照してください。

メソッドの構文の詳細については、find() を参照してください。

メソッドの構文の詳細については、collection.find() を参照してください。

等価条件を指定

等価条件を指定するには、クエリフィルタードキュメントで <field>:<value> 式を使用します。

{ <field1>: <value1>, ... }

等価条件を指定するには、クエリフィルタードキュメントで <field>:<value> 式を使用します。

{ <field1>: <value1>, ... }

等価条件を指定するには、Eq メソッドを使用してフィルターを構築します:

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

等価条件を指定するには、 com.mongodb.client.model.Filters.eq メソッドを使用して、クエリフィルタードキュメントを作成します。

and(eq( <field1>, <value1>), eq( <field2>, <value2>) ...)

等価条件を指定するには、com.mongodb.client.model.Filters.eq_ メソッドを使用してクエリフィルタードキュメントを作成します。

and(eq( <field1>, <value1>), eq( <field2>, <value2>) ...)

等価条件を指定するには、クエリフィルタードキュメントで <field>:<value> 式を使用します。

{ <field1>: <value1>, ... }

等価条件を指定するには、クエリフィルタードキュメントで <field>:<value> 式を使用します。

{ <field1>: <value1>, ... }

等価条件を指定するには、クエリフィルタードキュメントで <field> => <value> 式を使用します。

{ <field1> => <value1>, ... }

等価条件を指定するには、クエリフィルタードキュメントで <field> => <value> 式を使用します。

[ <field1> => <value1>, ... ]

等価条件を指定するには、クエリフィルタードキュメントで <field>:<value> 式を使用します。

{ <field1>: <value1>, ... }

等価条件を指定するには、クエリフィルタードキュメントで <field> => <value> 式を使用します。

{ <field1> => <value1>, ... }

等価条件を指定するには、com.mongodb.client.model.Filters.eq_ メソッドを使用してクエリフィルタードキュメントを作成します。

and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)

次の例では、inventory コレクションから、status が "D"と等しいすべてのドキュメントを選択します。

db.inventory.find( { status: "D" } )

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

{ status: "D" }

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

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

findPublisher = collection.find(eq("status", "D"));

findIterable = collection.find(eq("status", "D"));

cursor = db.inventory.find({"status": "D"})

const cursor = db.collection('inventory').find({ status: 'D' });

$cursor = $db->coll("inventory")->find( { status => "D" } );

$cursor = $db->inventory->find(['status' => 'D']);

cursor = db.inventory.find({"status": "D"})

client[:inventory].find(status: 'D')

findObservable = collection.find(equal("status", "D"))

この操作では、次の SQL ステートメントに対応する{ status: "D" }のクエリ述語が使用されます。

SELECT * FROM inventory WHERE status = "D"

注意

MongoDB Compass クエリバーは、埋め込まれたサブドキュメント内のキーを含め、コレクションのドキュメント内のキーに基づいて現在のクエリを自動補完します。

クエリ演算子を使用して条件を指定

クエリフィルタードキュメントでは、クエリ演算子を使用して次の形式で条件を指定できます。

{ <field1>: { <operator1>: <value1> }, ... }

クエリフィルタードキュメントでは、クエリ演算子を使用して次の形式で条件を指定できます。

{ <field1>: { <operator1>: <value1> }, ... }

等価フィルターに加えて、MongoDB はフィルター条件を指定するためのさまざまなクエリ演算子を提供します。フィルタードキュメントを作成するには、FilterDefinitionBuilder メソッドを使用します。以下がその例です。

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

等価条件に加えて、MongoDB は、フィルター条件を指定するためのさまざまなクエリ演算子を提供します。com.mongodb.client.model.Filters ヘルパーメソッドを使用すると、フィルタードキュメントの作成が簡単になります。以下がその例です。

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

クエリフィルタードキュメントでは、クエリ演算子を使用して次の形式で条件を指定できます。

{ <field1>: { <operator1>: <value1> }, ... }

クエリフィルタードキュメントでは、クエリ演算子を使用して次の形式で条件を指定できます。

{ <field1>: { <operator1>: <value1> }, ... }

クエリフィルタードキュメントでは、クエリ演算子を使用して次の形式で条件を指定できます。

{ <field1> => { <operator1> => <value1> }, ... }

クエリフィルタードキュメントでは、クエリ演算子を使用して次の形式で条件を指定できます。

[ <field1> => [ <operator1> => <value1> ], ... ]

クエリフィルタードキュメントでは、クエリ演算子を使用して次の形式で条件を指定できます。

{ <field1>: { <operator1>: <value1> }, ... }

クエリフィルタードキュメントでは、クエリ演算子を使用して次の形式で条件を指定できます。

{ <field1> => { <operator1> => <value1> }, ... }

MongoDB には等価条件に加え、フィルター条件を指定するためのさまざまなクエリ演算子が付属します。フィルタードキュメントの作成を容易にするには、com.mongodb.client.model.Filters_ ヘルパーメソッドを使用します。以下に例を挙げます。

and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))

次の例では、inventory コレクションから、status が "A" または "D" に等しいすべてのドキュメントを検索します。

db.inventory.find( { status: { $in: [ "A", "D" ] } } )

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

{ status: { $in: [ "A", "D" ] } }

var filter = Builders<BsonDocument>.Filter.In("status", new[] { "A", "D" });
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{{"status", bson.D{{"$in", bson.A{"A", "D"}}}}})

findPublisher = collection.find(in("status", "A", "D"));

findIterable = collection.find(in("status", "A", "D"));

cursor = db.inventory.find({"status": {"$in": ["A", "D"]}})

const cursor = db.collection('inventory').find({
  status: { $in: ['A', 'D'] }
});

$cursor = $db->coll("inventory")->find( { status => { '$in' => [ "A", "D" ] } } );

$cursor = $db->inventory->find(['status' => ['$in' => ['A', 'D']]]);

cursor = db.inventory.find({"status": {"$in": ["A", "D"]}})

client[:inventory].find(status: { '$in' => [ 'A', 'D' ]})

findObservable = collection.find(in("status", "A", "D"))

注意

$or 演算子を使用してこのクエリを表現できますが、同じフィールドで等価性チェックを実行する場合は、$or 演算子ではなく、$in 演算子を使用します。

この操作では、次の SQL ステートメントに対応する{ status: { $in: [ "A", "D" ] } }のクエリ述語が使用されます。

SELECT * FROM inventory WHERE status in ("A", "D")

MongoDB クエリ演算子の完全なリストについては、クエリ演算子とプロジェクション演算子のドキュメントを参照してください。

`AND`条件を指定

複合クエリは、コレクション内のドキュメントの複数のフィールドに条件を指定することができます。暗黙的に、論理的な AND 結合が複合クエリの各条件句を接続し、すべての条件に一致するドキュメントがコレクションから選択されます。

次の例では、inventory コレクション内で、status が "A" に等しく、かつ qty が（$lt）30 より小さいすべてのドキュメントを検索します。

db.inventory.find( { status: "A", qty: { $lt: 30 } } )

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

{ status: "A", qty: { $lt: 30 } }

var builder = Builders<BsonDocument>.Filter;
var filter = builder.And(builder.Eq("status", "A"), builder.Lt("qty", 30));
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"status", "A"},
		{"qty", bson.D{{"$lt", 30}}},
	})

findPublisher = collection.find(and(eq("status", "A"), lt("qty", 30)));

findIterable = collection.find(and(eq("status", "A"), lt("qty", 30)));

cursor = db.inventory.find({"status": "A", "qty": {"$lt": 30}})

const cursor = db.collection('inventory').find({
  status: 'A',
  qty: { $lt: 30 }
});

$cursor = $db->coll("inventory")->find( { status => "A", qty => { '$lt' => 30 } } );

$cursor = $db->inventory->find([
    'status' => 'A',
    'qty' => ['$lt' => 30],
]);

cursor = db.inventory.find({"status": "A", "qty": {"$lt": 30}})

client[:inventory].find(status: 'A', qty: { '$lt' => 30 })

findObservable = collection.find(and(equal("status", "A"), lt("qty", 30)))

この操作では、次の SQL ステートメントに対応する{ status: "A", qty: { $lt: 30 } }のクエリ述語が使用されます。

SELECT * FROM inventory WHERE status = "A" AND qty < 30

その他の MongoDB 比較演算子については、「比較演算子」を参照してください。

`OR`条件を指定

$or 演算子を使用すると、各条件句を論理的な OR 結合で結合する複合クエリを指定できます。これにより、クエリは、少なくとも 1 つの条件に一致するドキュメントをコレクションから選択します。

次の例では、コレクション内で status が "A" に等しい、または qty が（$lt） 30 より小さいすべてのドキュメントを検索します。

db.inventory.find( { $or: [ { status: "A" }, { qty: { $lt: 30 } } ] } )

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

{ $or: [ { status: "A" }, { qty: { $lt: 30 } } ] }

var builder = Builders<BsonDocument>.Filter;
var filter = builder.Or(builder.Eq("status", "A"), builder.Lt("qty", 30));
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"$or",
			bson.A{
				bson.D{{"status", "A"}},
				bson.D{{"qty", bson.D{{"$lt", 30}}}},
			}},
	})

findPublisher = collection.find(or(eq("status", "A"), lt("qty", 30)));

findIterable = collection.find(or(eq("status", "A"), lt("qty", 30)));

cursor = db.inventory.find({"$or": [{"status": "A"}, {"qty": {"$lt": 30}}]})

const cursor = db.collection('inventory').find({
  $or: [{ status: 'A' }, { qty: { $lt: 30 } }]
});

$cursor = $db->coll("inventory")->find(
    { '$or' => [ { status => "A" }, { qty => { '$lt' => 30 } } ] }
);

$cursor = $db->inventory->find([
    '$or' => [
        ['status' => 'A'],
        ['qty' => ['$lt' => 30]],
    ],
]);

cursor = db.inventory.find({"$or": [{"status": "A"}, {"qty": {"$lt": 30}}]})

client[:inventory].find('$or' => [{ status: 'A' },
                                  { qty: { '$lt' => 30 } }
                                 ])

findObservable = collection.find(or(equal("status", "A"), lt("qty", 30)))

この操作では、次の SQL ステートメントに対応する{ $or: [ { status: 'A' }, { qty: { $lt: 30 } } ] }のクエリ述語が使用されます。

SELECT * FROM inventory WHERE status = "A" OR qty < 30

注意

比較演算子を使用するクエリは、型のブラケット処理の対象となります。

`AND`と`OR`条件を指定

次の例では、複合クエリドキュメントは、status が"A" と等しく、かつqty が（$lt）30 より小さいか、または item が p の文字で始まる いずれかの条件が満たされるコレクション内のすべてのドキュメントを選択します。

db.inventory.find( {
     status: "A",
     $or: [ { qty: { $lt: 30 } }, { item: /^p/ } ]
} )

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

{ status: "A", $or: [ { qty: { $lt: 30 } }, { item: /^p/ } ] }

var builder = Builders<BsonDocument>.Filter;
var filter = builder.And(
    builder.Eq("status", "A"),
    builder.Or(builder.Lt("qty", 30), builder.Regex("item", new BsonRegularExpression("^p"))));
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"status", "A"},
		{"$or", bson.A{
			bson.D{{"qty", bson.D{{"$lt", 30}}}},
			bson.D{{"item", bson.Regex{Pattern: "^p", Options: ""}}},
		}},
	})

findPublisher = collection.find(
        and(eq("status", "A"),
                or(lt("qty", 30), regex("item", "^p")))
);

findIterable = collection.find(
        and(eq("status", "A"),
                or(lt("qty", 30), regex("item", "^p")))
);

cursor = db.inventory.find(
    {"status": "A", "$or": [{"qty": {"$lt": 30}}, {"item": {"$regex": "^p"}}]}
)

const cursor = db.collection('inventory').find({
  status: 'A',
  $or: [{ qty: { $lt: 30 } }, { item: { $regex: '^p' } }]
});

$cursor = $db->coll("inventory")->find(
    {
        status => "A",
        '$or'  => [ { qty => { '$lt' => 30 } }, { item => { '$regex' => "^p" } } ]
    }
);

$cursor = $db->inventory->find([
    'status' => 'A',
    '$or' => [
        ['qty' => ['$lt' => 30]],
        // Alternatively: ['item' => new \MongoDB\BSON\Regex('^p')]
        ['item' => ['$regex' => '^p']],
    ],
]);

cursor = db.inventory.find(
    {"status": "A", "$or": [{"qty": {"$lt": 30}}, {"item": {"$regex": "^p"}}]}
)

client[:inventory].find(status: 'A',
                        '$or' => [{ qty: { '$lt' => 30 } },
                                  { item: { '$regex' => BSON::Regexp::Raw.new('^p') } }
                        ])

findObservable = collection.find(and(
  equal("status", "A"),
  or(lt("qty", 30), regex("item", "^p")))
)

この操作では、次のクエリ述語を使用します。

{
   status: 'A',
   $or: [
     { qty: { $lt: 30 } }, { item: { $regex: '^p' } }
   ]
}

これは、次の SQL ステートメントに対応します。

SELECT * FROM inventory WHERE status = "A" AND ( qty < 30 OR item LIKE "p%")

注意

MongoDB は、文字列パターンの一致を実行するための正規表現 $regex のクエリをサポートしています。

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

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

MongoDB Atlas でクエリから返されるフィールドをプロジェクトするには、次の手順に従います。

MongoDB AtlasUIGo Clustersで、プロジェクトの [ ] ページにします。

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

コレクションへ移動する

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

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

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

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

{ year: 1924 }

クリック Apply

このクエリフィルターは、sample_mflix.movies コレクション内の year フィールドが 1924 と一致するすべてのドキュメントを返します。

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

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

動作

Cursor

db.collection.find() メソッドは、一致するドキュメントにカーソルを返します。

MongoDB Compass の Find 操作では、検索クエリに基づいてコレクションの一致するドキュメントへのカーソルを開くことができます。

MongoDB Compass でのサンプリングの詳細については、「Compass FAQ」を参照してください。

MongoCollection.Find() メソッドは、一致するドキュメントへのカーソルを返します。カーソルの反復処理については、MongoDB C# ドライバーのドキュメントを参照してください。

Collection.Find() 関数は、一致するドキュメントにカーソルを返します。詳細については、カーソルのドキュメントを参照してください。

com.mongodb.reactivestreams.client.MongoCollection.find は com.mongodb.reactivestreams.client.FindPublisherインターフェースのインスタンスを返します。

com.mongodb.client.MongoCollection.find メソッドが com.mongodb.client.FindIterable のインスタンスを返しますインターフェースを使用します。

Collection.find() メソッドは、カーソルを返します。

MongoDB::Collection::find() メソッドは、一致するドキュメントにカーソルを返します。カーソルの反復処理については、MongoDB Perl ドライバーのドキュメントを参照してください。

MongoDB\\Collection::find()メソッドは、一致するドキュメントにカーソルを返します。カーソルの反復処理については、MongoDB PHP ライブラリのドキュメントを参照してください。

pymongo.collection.Collection.find メソッドは、一致するドキュメントにカーソルを返します。カーソルの反復処理については、PyMongo のドキュメントを参照してください。

Mongo::Collection#find() メソッドからは Enumerable である CollectionView が返されます。カーソルは、View が列挙されると作成されます。例えば、#to_a() または #each() を呼び出した場合です。View で#to_enum() を呼び出すことで、Enumerator を取得することもできます。カーソルの反復処理については、Ruby ドライバー API ドキュメントを参照してください。

collection.find() メソッドからは find Observable が返されます。

読み取りの分離

レプリカセットおよびレプリカセットシャードへの読み取りの場合、読み取り保証 (read concern) により、クライアントは読み取りの分離レベルを選択できます。詳細については、「読み取り保証 (read concern)」を参照してください。