读取文档

db.movies.find( {} )

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

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

val flowInsertMany = collection
    .find(empty())

cursor = db.inventory.find({})

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

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

cursor = db.inventory.find({})

client[:inventory].find({})

var findObservable = collection.find(Document())

SELECT * FROM movies

SELECT * FROM inventory

SELECT * FROM inventory

SELECT * FROM inventory

SELECT * FROM inventory

SELECT * FROM inventory

SELECT * FROM inventory

SELECT * FROM inventory

SELECT * FROM inventory

SELECT * FROM inventory

SELECT * FROM inventory

SELECT * FROM inventory

SELECT * FROM inventory

SELECT * FROM inventory

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

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

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

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

filter := bson.D{{"<field>", <value>}}

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

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

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

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

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

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

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

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

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

db.movies.find( { rated: "PG-13" } )

{ status: "D" }

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

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

val findFlow = collection
    .find(eq("status", "D"))

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

const cursor = db.collection('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"))

SELECT * FROM movies WHERE rated = "PG-13"

SELECT * FROM inventory WHERE status = "D"

SELECT * FROM inventory WHERE status = "D"

SELECT * FROM inventory WHERE status = "D"

SELECT * FROM inventory WHERE status = "D"

SELECT * FROM inventory WHERE status = "D"

SELECT * FROM inventory WHERE status = "D"

SELECT * FROM inventory WHERE status = "D"

SELECT * FROM inventory WHERE status = "D"

SELECT * FROM inventory WHERE status = "D"

SELECT * FROM inventory WHERE status = "D"

SELECT * FROM inventory WHERE status = "D"

SELECT * FROM inventory WHERE status = "D"

SELECT * FROM inventory WHERE status = "D"

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

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

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

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

filter := bson.D{
    {"$and", bson.A{
        bson.D{{"field1", bson.D{{"$eq", value1}}}},
        bson.D{{"field2", bson.D{{"$lt", value2}}}},
    }},
}

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

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> }, ... }

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

db.movies.find( { rated: { $in: [ "G", "PG-13" ] } } )

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

mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "status", "{",
   "$in", "[",
   BCON_UTF8 ("A"), BCON_UTF8 ("D"),
   "]",
   "}");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);

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

val findFlow = 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->inventory->find(['status' => ['$in' => ['A', 'D']]]);

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

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

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

SELECT * FROM movies WHERE rated in ("G", "PG-13")

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

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

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

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

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

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

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

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

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

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

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

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

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

db.movies.find( { rated: "G", runtime: { $lt: 90 } } )

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

mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "status", BCON_UTF8 ("A"),
   "qty", "{",
   "$lt", BCON_INT64 (30),
   "}");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);

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

val findFlow = 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->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)))

SELECT * FROM movies WHERE rated = "G" AND runtime < 90

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

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

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

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

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

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

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

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

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

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

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

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

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

db.movies.find( { $or: [ { rated: "G" }, { runtime: { $lt: 90 } } ] } )

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

mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "$or", "[",
   "{",
   "status", BCON_UTF8 ("A"),
   "}","{",
   "qty", "{",
   "$lt", BCON_INT64 (30),
   "}",
   "}",
   "]");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);

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

val findFlow = 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->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)))

SELECT * FROM movies WHERE rated = "G" OR runtime < 90

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

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

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

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

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

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

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

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

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

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

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

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

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

db.movies.find( {
     rated: "G",
     $or: [ { runtime: { $lt: 90 } }, { title: /^T/ } ]
} )

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

mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "status", BCON_UTF8 ("A"),
   "$or", "[",
   "{",
   "qty", "{",
   "$lt", BCON_INT64 (30),
   "}",
   "}","{",
   "item", BCON_REGEX ("^p", ""),
   "}",
   "]");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);

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

val findFlow = 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->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")))
)

{
   rated: 'G',
   $or: [
     { runtime: { $lt: 90 } },
     { title: { $regex: '^T' } }
   ]
}

SELECT * FROM movies WHERE rated = "G"
AND ( runtime < 90 OR title LIKE "T%")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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