Docs Menu
Docs Home
/
MongoDBマニュアル
/ /

クエリから返されるプロジェクト フィールド

項目一覧

  • 一致するドキュメントのすべてのフィールドを返す
  • 指定されたフィールドと _idフィールドのみを返します
  • _id フィールドを非表示にする
  • 除外されたフィールド以外のすべてを返す
  • 埋め込みドキュメント内の特定のフィールドを返す
  • 埋め込みドキュメントの特定のフィールドを非表示にする
  • 配列内の埋め込みドキュメントのプロジェクション
  • 返された配列内のプロジェクト固有の配列要素
  • 集計式が入力されているプロジェクト フィールド
  • MongoDB Atlas でクエリから返されるプロジェクト フィールド
  • その他の考慮事項

MongoDB 内の埋め込みドキュメントには次の方法でクエリを実行できます。

  • プログラミング言語のドライバー。

  • MongoDB Atlas UI 。 詳細については、「 MongoDB Atlas でクエリから返されるプロジェクト フィールド 」を参照してください。

  • MongoDB Compass


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


デフォルトでは、MongoDB のクエリは一致するドキュメント内のすべてのフィールドを返します。MongoDB がアプリケーションに送信するデータ量を制限するには、返されるフィールドを指定または制限するプロジェクション ドキュメントを含めることができます。

このページでは、MongoDB Compass を使用したプロジェクションによるクエリ操作の例を取り上げます。

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

このページでは、 mongoc_collection_find_with_opts を使用した、プロジェクションによるクエリ操作の例を取り上げます。

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

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

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

このページでは、Collection.Find メソッドを使用した、プロジェクションにおける MongoDB Go ドライバーでのクエリ操作の例を取り上げます。

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

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

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

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

Tip

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

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

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

Tip

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

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

このページでは、motor.motor_asyncio.AsyncIOMotorCollection.find メソッドを使用した、プロジェクションにおける Motorドライバーでのクエリ操作の例を取り上げます。

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

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

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

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

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

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

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

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

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

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

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

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

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

db.inventory.insertMany( [
{ item: "journal", status: "A", size: { h: 14, w: 21, uom: "cm" }, instock: [ { warehouse: "A", qty: 5 } ] },
{ item: "notebook", status: "A", size: { h: 8.5, w: 11, uom: "in" }, instock: [ { warehouse: "C", qty: 5 } ] },
{ item: "paper", status: "D", size: { h: 8.5, w: 11, uom: "in" }, instock: [ { warehouse: "A", qty: 60 } ] },
{ item: "planner", status: "D", size: { h: 22.85, w: 30, uom: "cm" }, instock: [ { warehouse: "A", qty: 40 } ] },
{ item: "postcard", status: "A", size: { h: 10, w: 15.25, uom: "cm" }, instock: [ { warehouse: "B", qty: 15 }, { warehouse: "C", qty: 35 } ] }
]);
[
{ "item": "journal", "status": "A", "size": { "h": 14, "w": 21, "uom": "cm" }, "instock": [ { "warehouse": "A", "qty": 5 } ] },
{ "item": "notebook", "status": "A", "size": { "h": 8.5, "w": 11, "uom": "in" }, "instock": [ { "warehouse": "C", "qty": 5 } ] },
{ "item": "paper", "status": "D", "size": { "h": 8.5, "w": 11, "uom": "in" }, "instock": [ { "warehouse": "A", "qty": 60 } ] },
{ "item": "planner", "status": "D", "size": { "h": 22.85, "w": 30, "uom": "cm" }, "instock": [ { "warehouse": "A", "qty": 40 } ] },
{ "item": "postcard", "status": "A", "size": { "h": 10, "w": 15.25, "uom": "cm" }, "instock": [ { "warehouse": "B", "qty": 15 }, { "warehouse": "C", "qty": 35 } ] }
]

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"),
"status", BCON_UTF8 ("A"),
"size", "{",
"h", BCON_DOUBLE (14),
"w", BCON_DOUBLE (21),
"uom", BCON_UTF8 ("cm"),
"}",
"instock", "[",
"{",
"warehouse", BCON_UTF8 ("A"),
"qty", BCON_INT64 (5),
"}",
"]");
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"),
"status", BCON_UTF8 ("A"),
"size", "{",
"h", BCON_DOUBLE (8.5),
"w", BCON_DOUBLE (11),
"uom", BCON_UTF8 ("in"),
"}",
"instock", "[",
"{",
"warehouse", BCON_UTF8 ("C"),
"qty", BCON_INT64 (5),
"}",
"]");
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"),
"status", BCON_UTF8 ("D"),
"size", "{",
"h", BCON_DOUBLE (8.5),
"w", BCON_DOUBLE (11),
"uom", BCON_UTF8 ("in"),
"}",
"instock", "[",
"{",
"warehouse", BCON_UTF8 ("A"),
"qty", BCON_INT64 (60),
"}",
"]");
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"),
"status", BCON_UTF8 ("D"),
"size", "{",
"h", BCON_DOUBLE (22.85),
"w", BCON_DOUBLE (30),
"uom", BCON_UTF8 ("cm"),
"}",
"instock", "[",
"{",
"warehouse", BCON_UTF8 ("A"),
"qty", BCON_INT64 (40),
"}",
"]");
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"),
"status", BCON_UTF8 ("A"),
"size", "{",
"h", BCON_DOUBLE (10),
"w", BCON_DOUBLE (15.25),
"uom", BCON_UTF8 ("cm"),
"}",
"instock", "[",
"{",
"warehouse", BCON_UTF8 ("B"),
"qty", BCON_INT64 (15),
"}","{",
"warehouse", BCON_UTF8 ("C"),
"qty", BCON_INT64 (35),
"}",
"]");
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" },
{ "status", "A" },
{ "size", new BsonDocument { { "h", 14 }, { "w", 21 }, { "uom", "cm" } } },
{ "instock", new BsonArray
{
new BsonDocument { { "warehouse", "A" }, { "qty", 5 } } }
}
},
new BsonDocument
{
{ "item", "notebook" },
{ "status", "A" },
{ "size", new BsonDocument { { "h", 8.5 }, { "w", 11 }, { "uom", "in" } } },
{ "instock", new BsonArray
{
new BsonDocument { { "warehouse", "C" }, { "qty", 5 } } }
}
},
new BsonDocument
{
{ "item", "paper" },
{ "status", "D" },
{ "size", new BsonDocument { { "h", 8.5 }, { "w", 11 }, { "uom", "in" } } },
{ "instock", new BsonArray
{
new BsonDocument { { "warehouse", "A" }, { "qty", 60 } } }
}
},
new BsonDocument
{
{ "item", "planner" },
{ "status", "D" },
{ "size", new BsonDocument { { "h", 22.85 }, { "w", 30 }, { "uom", "cm" } } },
{ "instock", new BsonArray
{
new BsonDocument { { "warehouse", "A" }, { "qty", 40 } } }
}
},
new BsonDocument
{
{ "item", "postcard" },
{ "status", "A" },
{ "size", new BsonDocument { { "h", 10 }, { "w", 15.25 }, { "uom", "cm" } } },
{ "instock", new BsonArray
{
new BsonDocument { { "warehouse", "B" }, { "qty", 15 } },
new BsonDocument { { "warehouse", "C" }, { "qty", 35 } } }
}
}
};
collection.InsertMany(documents);
docs := []interface{}{
bson.D{
{"item", "journal"},
{"status", "A"},
{"size", bson.D{
{"h", 14},
{"w", 21},
{"uom", "cm"},
}},
{"instock", bson.A{
bson.D{
{"warehouse", "A"},
{"qty", 5},
},
}},
},
bson.D{
{"item", "notebook"},
{"status", "A"},
{"size", bson.D{
{"h", 8.5},
{"w", 11},
{"uom", "in"},
}},
{"instock", bson.A{
bson.D{
{"warehouse", "EC"},
{"qty", 5},
},
}},
},
bson.D{
{"item", "paper"},
{"status", "D"},
{"size", bson.D{
{"h", 8.5},
{"w", 11},
{"uom", "in"},
}},
{"instock", bson.A{
bson.D{
{"warehouse", "A"},
{"qty", 60},
},
}},
},
bson.D{
{"item", "planner"},
{"status", "D"},
{"size", bson.D{
{"h", 22.85},
{"w", 30},
{"uom", "cm"},
}},
{"instock", bson.A{
bson.D{
{"warehouse", "A"},
{"qty", 40},
},
}},
},
bson.D{
{"item", "postcard"},
{"status", "A"},
{"size", bson.D{
{"h", 10},
{"w", 15.25},
{"uom", "cm"},
}},
{"instock", bson.A{
bson.D{
{"warehouse", "B"},
{"qty", 15},
},
bson.D{
{"warehouse", "EC"},
{"qty", 35},
},
}},
},
}
result, err := coll.InsertMany(context.TODO(), docs)
Publisher<Success> insertManyPublisher = collection.insertMany(asList(
Document.parse("{ item: 'journal', status: 'A', size: { h: 14, w: 21, uom: 'cm' }, instock: [ { warehouse: 'A', qty: 5 }]}"),
Document.parse("{ item: 'notebook', status: 'A', size: { h: 8.5, w: 11, uom: 'in' }, instock: [ { warehouse: 'C', qty: 5}]}"),
Document.parse("{ item: 'paper', status: 'D', size: { h: 8.5, w: 11, uom: 'in' }, instock: [ { warehouse: 'A', qty: 60 }]}"),
Document.parse("{ item: 'planner', status: 'D', size: { h: 22.85, w: 30, uom: 'cm' }, instock: [ { warehouse: 'A', qty: 40}]}"),
Document.parse("{ item: 'postcard', status: 'A', size: { h: 10, w: 15.25, uom: 'cm' }, "
+ "instock: [ { warehouse: 'B', qty: 15 }, { warehouse: 'C', qty: 35 } ] }")
));
collection.insertMany(asList(
Document.parse("{ item: 'journal', status: 'A', size: { h: 14, w: 21, uom: 'cm' }, instock: [ { warehouse: 'A', qty: 5 }]}"),
Document.parse("{ item: 'notebook', status: 'A', size: { h: 8.5, w: 11, uom: 'in' }, instock: [ { warehouse: 'C', qty: 5}]}"),
Document.parse("{ item: 'paper', status: 'D', size: { h: 8.5, w: 11, uom: 'in' }, instock: [ { warehouse: 'A', qty: 60 }]}"),
Document.parse("{ item: 'planner', status: 'D', size: { h: 22.85, w: 30, uom: 'cm' }, instock: [ { warehouse: 'A', qty: 40}]}"),
Document.parse("{ item: 'postcard', status: 'A', size: { h: 10, w: 15.25, uom: 'cm' }, "
+ "instock: [ { warehouse: 'B', qty: 15 }, { warehouse: 'C', qty: 35 } ] }")
));
collection.insertMany(
listOf(
Document("item", "journal")
.append("status", "A")
.append("size", Document("h", 14).append("w", 21).append("uom", "cm"))
.append("instock", listOf(
Document("warehouse", "A").append("qty", 5),
)),
Document("item", "notebook")
.append("status", "A")
.append("size", Document("h", 8.5).append("w", 11).append("uom", "in"))
.append("instock", listOf(
Document("warehouse", "C").append("qty", 5),
)),
Document("item", "paper")
.append("status", "D")
.append("size", Document("h", 8.5).append("w", 11).append("uom", "in"))
.append("instock", listOf(
Document("warehouse", "A").append("qty", 60),
)),
Document("item", "planner")
.append("status", "D")
.append("size", Document("h", 22.85).append("w", 30).append("uom", "cm"))
.append("instock", listOf(
Document("warehouse", "A").append("qty", 40),
)),
Document("item", "postcard")
.append("status", "A")
.append("size", Document("h", 10).append("w", 15.25).append("uom", "cm"))
.append("instock", listOf(
Document("warehouse", "B").append("qty", 15),
Document("warehouse", "C").append("qty", 35)
)),
)
)
await db.inventory.insert_many(
[
{
"item": "journal",
"status": "A",
"size": {"h": 14, "w": 21, "uom": "cm"},
"instock": [{"warehouse": "A", "qty": 5}],
},
{
"item": "notebook",
"status": "A",
"size": {"h": 8.5, "w": 11, "uom": "in"},
"instock": [{"warehouse": "C", "qty": 5}],
},
{
"item": "paper",
"status": "D",
"size": {"h": 8.5, "w": 11, "uom": "in"},
"instock": [{"warehouse": "A", "qty": 60}],
},
{
"item": "planner",
"status": "D",
"size": {"h": 22.85, "w": 30, "uom": "cm"},
"instock": [{"warehouse": "A", "qty": 40}],
},
{
"item": "postcard",
"status": "A",
"size": {"h": 10, "w": 15.25, "uom": "cm"},
"instock": [{"warehouse": "B", "qty": 15}, {"warehouse": "C", "qty": 35}],
},
]
)
await db.collection('inventory').insertMany([
{
item: 'journal',
status: 'A',
size: { h: 14, w: 21, uom: 'cm' },
instock: [{ warehouse: 'A', qty: 5 }]
},
{
item: 'notebook',
status: 'A',
size: { h: 8.5, w: 11, uom: 'in' },
instock: [{ warehouse: 'C', qty: 5 }]
},
{
item: 'paper',
status: 'D',
size: { h: 8.5, w: 11, uom: 'in' },
instock: [{ warehouse: 'A', qty: 60 }]
},
{
item: 'planner',
status: 'D',
size: { h: 22.85, w: 30, uom: 'cm' },
instock: [{ warehouse: 'A', qty: 40 }]
},
{
item: 'postcard',
status: 'A',
size: { h: 10, w: 15.25, uom: 'cm' },
instock: [
{ warehouse: 'B', qty: 15 },
{ warehouse: 'C', qty: 35 }
]
}
]);
$db->coll("inventory")->insert_many(
[
{
item => "journal",
status => "A",
size => { h => 14, w => 21, uom => "cm" },
instock => [ { warehouse => "A", qty => 5 } ]
},
{
item => "notebook",
status => "A",
size => { h => 8.5, w => 11, uom => "in" },
instock => [ { warehouse => "C", qty => 5 } ]
},
{
item => "paper",
status => "D",
size => { h => 8.5, w => 11, uom => "in" },
instock => [ { warehouse => "A", qty => 60 } ]
},
{
item => "planner",
status => "D",
size => { h => 22.85, w => 30, uom => "cm" },
instock => [ { warehouse => "A", qty => 40 } ]
},
{
item => "postcard",
status => "A",
size => { h => 10, w => 15.25, uom => "cm" },
instock => [
{ warehouse => "B", qty => 15 },
{ warehouse => "C", qty => 35 }
]
}
]
);
$insertManyResult = $db->inventory->insertMany([
[
'item' => 'journal',
'status' => 'A',
'size' => ['h' => 14, 'w' => 21, 'uom' => 'cm'],
'instock' => [
['warehouse' => 'A', 'qty' => 5],
],
],
[
'item' => 'notebook',
'status' => 'A',
'size' => ['h' => 8.5, 'w' => 11, 'uom' => 'in'],
'instock' => [
['warehouse' => 'C', 'qty' => 5],
],
],
[
'item' => 'paper',
'status' => 'D',
'size' => ['h' => 8.5, 'w' => 11, 'uom' => 'in'],
'instock' => [
['warehouse' => 'A', 'qty' => 60],
],
],
[
'item' => 'planner',
'status' => 'D',
'size' => ['h' => 22.85, 'w' => 30, 'uom' => 'cm'],
'instock' => [
['warehouse' => 'A', 'qty' => 40],
],
],
[
'item' => 'postcard',
'status' => 'A',
'size' => ['h' => 10, 'w' => 15.25, 'uom' => 'cm'],
'instock' => [
['warehouse' => 'B', 'qty' => 15],
['warehouse' => 'C', 'qty' => 35],
],
],
]);
db.inventory.insert_many(
[
{
"item": "journal",
"status": "A",
"size": {"h": 14, "w": 21, "uom": "cm"},
"instock": [{"warehouse": "A", "qty": 5}],
},
{
"item": "notebook",
"status": "A",
"size": {"h": 8.5, "w": 11, "uom": "in"},
"instock": [{"warehouse": "C", "qty": 5}],
},
{
"item": "paper",
"status": "D",
"size": {"h": 8.5, "w": 11, "uom": "in"},
"instock": [{"warehouse": "A", "qty": 60}],
},
{
"item": "planner",
"status": "D",
"size": {"h": 22.85, "w": 30, "uom": "cm"},
"instock": [{"warehouse": "A", "qty": 40}],
},
{
"item": "postcard",
"status": "A",
"size": {"h": 10, "w": 15.25, "uom": "cm"},
"instock": [{"warehouse": "B", "qty": 15}, {"warehouse": "C", "qty": 35}],
},
]
)
client[:inventory].insert_many([{ item: 'journal',
status: 'A',
size: { h: 14, w: 21, uom: 'cm' },
instock: [ { warehouse: 'A', qty: 5 }] },
{ item: 'notebook',
status: 'A',
size: { h: 8.5, w: 11, uom: 'in' },
instock: [ { warehouse: 'C', qty: 5 }] },
{ item: 'paper',
status: 'D',
size: { h: 8.5, w: 11, uom: 'in' },
instock: [ { warehouse: 'A', qty: 60 }] },
{ item: 'planner',
status: 'D',
size: { h: 22.85, w: 30, uom: 'cm' },
instock: [ { warehouse: 'A', qty: 40 }] },
{ item: 'postcard',
status: 'A',
size: { h: 10, w: 15.25, uom: 'cm' },
instock: [ { warehouse: 'B', qty: 15 },
{ warehouse: 'C', qty: 35 }] }])
collection.insertMany(Seq(
Document("""{ item: "journal", status: "A", size: { h: 14, w: 21, uom: "cm" }, instock: [ { warehouse: "A", qty: 5 } ] }"""),
Document("""{ item: "notebook", status: "A", size: { h: 8.5, w: 11, uom: "in" }, instock: [ { warehouse: "C", qty: 5 } ] }"""),
Document("""{ item: "paper", status: "D", size: { h: 8.5, w: 11, uom: "in" }, instock: [ { warehouse: "A", qty: 60 } ] }"""),
Document("""{ item: "planner", status: "D", size: { h: 22.85, w: 30, uom: "cm" }, instock: [ { warehouse: "A", qty: 40 } ] }"""),
Document("""{ item: "postcard", status: "A", size: { h: 10, w: 15.25, uom: "cm" },
instock: [ { warehouse: "B", qty: 15 }, { warehouse: "C", qty: 35 } ] }""")
)).execute()

プロジェクションドキュメントを指定しない場合、db.collection.find() メソッドは一致するドキュメントのすべてのフィールドを返します。

プロジェクションドキュメントを指定しない場合、Compass は一致するドキュメントのすべてのフィールドを返します。

プロジェクション フィルターを指定しない場合は、MongoCollection.Find() メソッドが、一致するドキュメント内のすべてのフィールドを返します。

プロジェクション を指定しない場合、 com.mongodb.reactivestreams.client.MongoCollection.find メソッドが、一致するドキュメント内のすべてのフィールドを返します。

プロジェクションを指定しない場合、com.mongodb.client.MongoCollection.find メソッドは、一致するドキュメント内のすべてのフィールドを返します。

プロジェクション ドキュメントを指定しない場合、 MongoCollection.find()メソッドが、一致するドキュメント内のすべてのフィールドを返します。

プロジェクションドキュメントを指定しない場合、find() メソッドは一致するドキュメント内のすべてのフィールドを返します。

プロジェクションドキュメントを指定しない場合、find() メソッドは一致するドキュメント内のすべてのフィールドを返します。

プロジェクションドキュメントを指定しない場合、find()メソッドは一致するドキュメントのすべてのフィールドを返します。

プロジェクション ドキュメントを指定しない場合、find メソッドは一致するドキュメントのすべてのフィールドを返します。

プロジェクションドキュメントを指定しない場合、find() メソッドは一致するドキュメント内のすべてのフィールドを返します。

プロジェクションを指定しない場合は、collection.find()メソッドが、一致するドキュメント内のすべてのフィールドを返します。

次の例では、inventory コレクション内の status"A" に等しいすべてのドキュメントのすべてのフィールドを返します。

db.inventory.find( { status: "A" } )
  1. 次の式を Filter フィールドにコピーします。

    { status: "A" }
  2. [Find] をクリックします。

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"));
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);
var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var result = collection.Find(filter).ToList();
cursor, err := coll.Find(
context.TODO(),
bson.D{{"status", "A"}},
)
FindPublisher<Document> findPublisher = collection.find(eq("status", "A"));
FindIterable<Document> findIterable = collection.find(eq("status", "A"));
val findFlow = collection
.find(eq("status", "A"))
cursor = db.inventory.find({"status": "A"})
const cursor = db.collection('inventory').find({
status: 'A'
});
$cursor = $db->coll("inventory")->find( { status => "A" } );
$cursor = $db->inventory->find(['status' => 'A']);
cursor = db.inventory.find({"status": "A"})
client[:inventory].find(status: 'A')
var findObservable = collection.find(equal("status", "A"))

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

SELECT * from inventory WHERE status = "A"

プロジェクション ドキュメントで <field>1 に設定することで、プロジェクションに複数のフィールドを明示的に含めることができます。次の操作は、クエリに一致するすべてのドキュメントを返します。結果のセットでは、item フィールド、status フィールド、デフォルトでは _id フィールドのみが一致するドキュメントに返されます。

db.inventory.find( { status: "A" }, { item: 1, status: 1 } )
  1. 次の式を Filter フィールドにコピーします。

    { status: "A" }
  2. Options をクリックすると、追加のクエリオプションが開きます。

  3. 次の式を Project フィールドにコピーします。

    { item: 1, status: 1 }
  4. [Find] をクリックします。

mongoc_collection_t *collection;
bson_t *filter;
bson_t *opts;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("status", BCON_UTF8 ("A"));
opts = BCON_NEW ("projection", "{", "item", BCON_INT64 (1),
"status", BCON_INT64 (1), "}");
cursor = mongoc_collection_find_with_opts (collection, filter, opts, NULL);

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

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status");
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();
projection := bson.D{
{"item", 1},
{"status", 1},
}
cursor, err := coll.Find(
context.TODO(),
bson.D{
{"status", "A"},
},
options.Find().SetProjection(projection),
)
findPublisher = collection.find(eq("status", "A")).projection(include("item", "status"));

プロジェクション ドキュメントを指定するには、 com.mongodb.client.FindIterable.projection メソッドをfind メソッドに適用します。この例では com.mongodb.client.model を使用します。プロジェクション クラスを使用してプロジェクション ドキュメントを作成します。

findIterable = collection.find(eq("status", "A")).projection(include("item", "status"));
val findFlow = collection
.find(eq("status", "A")).projection(include("item", "status"))
cursor = db.inventory.find({"status": "A"}, {"item": 1, "status": 1})
const cursor = db
.collection('inventory')
.find({
status: 'A'
})
.project({ item: 1, status: 1 });
$cursor = $db->coll("inventory")->find(
{ status => "A" }, { projection => { item => 1, status => 1 } }
);
$cursor = $db->inventory->find(
['status' => 'A'],
['projection' => ['item' => 1, 'status' => 1]],
);
cursor = db.inventory.find({"status": "A"}, {"item": 1, "status": 1})
client[:inventory].find({ status: 'A' },
projection: { item: 1, status: 1 })
findObservable = collection.find(equal("status", "A")).projection(include("item", "status"))

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

SELECT _id, item, status from inventory WHERE status = "A"

次の例のように、プロジェクションで _id フィールドを 0 に設定することで、結果からそのフィールドを除くことができます。

db.inventory.find( { status: "A" }, { item: 1, status: 1, _id: 0 } )
  1. 次の式を Filter フィールドにコピーします。

    { status: "A" }
  2. Options をクリックすると、追加のクエリオプションが開きます。

  3. 次の式を Project フィールドにコピーします。

    { item: 1, status: 1, _id: 0 }
  4. [Find] をクリックします。

mongoc_collection_t *collection;
bson_t *filter;
bson_t *opts;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("status", BCON_UTF8 ("A"));
opts = BCON_NEW ("projection", "{", "item", BCON_INT64 (1),
"status", BCON_INT64 (1),
"_id", BCON_INT64 (0), "}");
cursor = mongoc_collection_find_with_opts (collection, filter, opts, NULL);
var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Exclude("_id");
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();
projection := bson.D{
{"item", 1},
{"status", 1},
{"_id", 0},
}
cursor, err := coll.Find(
context.TODO(),
bson.D{
{"status", "A"},
},
options.Find().SetProjection(projection),
)
findPublisher = collection.find(eq("status", "A"))
.projection(fields(include("item", "status"), excludeId()));

プロジェクション ドキュメントを指定するには、 com.mongodb.client.FindIterable.projection メソッドをfind メソッドに適用します。この例では com.mongodb.client.model を使用します。プロジェクション クラスを使用してプロジェクション ドキュメントを作成します。

findIterable = collection.find(eq("status", "A"))
.projection(fields(include("item", "status"), excludeId()));
val findFlow = collection
.find(eq("status", "A")).projection(fields(include("item", "status"), excludeId()))
cursor = db.inventory.find({"status": "A"}, {"item": 1, "status": 1, "_id": 0})
const cursor = db
.collection('inventory')
.find({
status: 'A'
})
.project({ item: 1, status: 1, _id: 0 });
$cursor = $db->coll("inventory")->find(
{ status => "A" }, { projection => { item => 1, status => 1, "_id" => 0 } }
);
$cursor = $db->inventory->find(
['status' => 'A'],
['projection' => ['item' => 1, 'status' => 1, '_id' => 0]],
);
cursor = db.inventory.find({"status": "A"}, {"item": 1, "status": 1, "_id": 0})
client[:inventory].find({ status: 'A' },
projection: { item: 1, status: 1, _id: 0 })
findObservable = collection.find(equal("status", "A"))
.projection(fields(include("item", "status"), excludeId()))

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

SELECT item, status from inventory WHERE status = "A"

注意

_id フィールドを除き、プロジェクション ドキュメントに含むステートメントと除外するステートメントを組み合わせることはできません。

一致するドキュメントで返すフィールドを一覧表示する代わりに、プロジェクションを使用して特定のフィールドを除外できます。次の例では、一致するドキュメントの status フィールドと instock フィールドを除くすべてのフィールドが返されます。

db.inventory.find( { status: "A" }, { status: 0, instock: 0 } )
  1. 次の式を Filter フィールドにコピーします。

    { status: "A" }
  2. Options をクリックすると、追加のクエリオプションが開きます。

  3. 次の式を Project フィールドにコピーします。

    { status: 0, instock: 0 }
  4. [Find] をクリックします。

mongoc_collection_t *collection;
bson_t *filter;
bson_t *opts;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("status", BCON_UTF8 ("A"));
opts = BCON_NEW ("projection", "{", "status", BCON_INT64 (0),
"instock", BCON_INT64 (0), "}");
cursor = mongoc_collection_find_with_opts (collection, filter, opts, NULL);
var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Exclude("status").Exclude("instock");
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();
projection := bson.D{
{"status", 0},
{"instock", 0},
}
cursor, err := coll.Find(
context.TODO(),
bson.D{
{"status", "A"},
},
options.Find().SetProjection(projection),
)
findPublisher = collection.find(eq("status", "A")).projection(exclude("item", "status"));

プロジェクション ドキュメントを指定するには、 com.mongodb.client.FindIterable.projection メソッドをfind メソッドに適用します。この例では com.mongodb.client.model を使用します。プロジェクション クラスを使用してプロジェクション ドキュメントを作成します。

findIterable = collection.find(eq("status", "A")).projection(exclude("item", "status"));
val findFlow = collection
.find(eq("status", "A")).projection(exclude("item", "status"))
cursor = db.inventory.find({"status": "A"}, {"status": 0, "instock": 0})
const cursor = db
.collection('inventory')
.find({
status: 'A'
})
.project({ status: 0, instock: 0 });
$cursor = $db->coll("inventory")->find(
{ status => "A" }, { projection => { status => 0, instock => 0 } }
);
$cursor = $db->inventory->find(
['status' => 'A'],
['projection' => ['status' => 0, 'instock' => 0]],
);
cursor = db.inventory.find({"status": "A"}, {"status": 0, "instock": 0})
client[:inventory].find({ status: 'A' },
projection: { status: 0, instock: 0 })
findObservable = collection.find(equal("status", "A")).projection(exclude("item", "status"))

注意

_id フィールドを除き、プロジェクション ドキュメントに含むステートメントと除外するステートメントを組み合わせることはできません。

埋め込みドキュメント内の特定のフィールドを返すことができます。ドット表記を使用して埋め込みフィールドを参照し、プロジェクション ドキュメントで 1 に設定します。

以下の例では、次の値が返されます。

  • _id フィールド(デフォルトで返されます)

  • item フィールド

  • status フィールド

  • size ドキュメントの uom フィールド

uom フィールドは size ドキュメントに埋め込まれたままになります。

db.inventory.find(
{ status: "A" },
{ item: 1, status: 1, "size.uom": 1 }
)
  1. 次の式を Filter フィールドにコピーします。

    { status: "A" }
  2. Options をクリックすると、追加のクエリオプションが開きます。

  3. 次の式を Project フィールドにコピーします。

    { item: 1, status: 1, "size.uom": 1 }
  4. [Find] をクリックします。

mongoc_collection_t *collection;
bson_t *filter;
bson_t *opts;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("status", BCON_UTF8 ("A"));
opts = BCON_NEW ("projection", "{", "item", BCON_INT64 (1),
"status", BCON_INT64 (1),
"size.uom", BCON_INT64 (1), "}");
cursor = mongoc_collection_find_with_opts (collection, filter, opts, NULL);
var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Include("size.uom");
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();
projection := bson.D{
{"item", 1},
{"status", 1},
{"size.uom", 1},
}
cursor, err := coll.Find(
context.TODO(),
bson.D{
{"status", "A"},
},
options.Find().SetProjection(projection),
)
findPublisher = collection.find(eq("status", "A")).projection(include("item", "status", "size.uom"));

プロジェクション ドキュメントを指定するには、 com.mongodb.client.FindIterable.projection メソッドをfind メソッドに適用します。この例では com.mongodb.client.model を使用します。プロジェクション クラスを使用してプロジェクション ドキュメントを作成します。

findIterable = collection.find(eq("status", "A")).projection(include("item", "status", "size.uom"));
val findFlow = collection
.find(eq("status", "A")).projection(include("item", "status", "size.uom"))
cursor = db.inventory.find({"status": "A"}, {"item": 1, "status": 1, "size.uom": 1})
const cursor = db
.collection('inventory')
.find({
status: 'A'
})
.project({ item: 1, status: 1, 'size.uom': 1 });
$cursor = $db->coll("inventory")->find(
{ status => "A" }, { projection => { item => 1, status => 1, "size.uom" => 1 } }
);
$cursor = $db->inventory->find(
['status' => 'A'],
['projection' => ['item' => 1, 'status' => 1, 'size.uom' => 1]],
);
cursor = db.inventory.find({"status": "A"}, {"item": 1, "status": 1, "size.uom": 1})
client[:inventory].find({ status: 'A' },
projection: { 'item' => 1, 'status' => 1, 'size.uom' => 1 })
findObservable = collection.find(equal("status", "A")).projection(include("item", "status", "size.uom"))

ネストされたフォームを使用して埋め込みフィールドを指定することもできます。たとえば、{ item: 1, status: 1, size: { uom: 1 } }などです。

埋め込みドキュメント内の特定のフィールドを非表示にできます。ドット表記を使用してプロジェクション ドキュメント内の埋め込みフィールドを参照し、0 に設定します。

次の例では、size ドキュメント内の uom フィールドを除外するプロジェクションを指定します。一致するドキュメントには、他のすべてのフィールドが返されます。

db.inventory.find(
{ status: "A" },
{ "size.uom": 0 }
)
  1. 次の式を Filter フィールドにコピーします。

    { status: "A" }
  2. Options をクリックすると、追加のクエリオプションが開きます。

  3. 次の式を Project フィールドにコピーします。

    { "size.uom": 0 }
  4. [Find] をクリックします。

mongoc_collection_t *collection;
bson_t *filter;
bson_t *opts;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("status", BCON_UTF8 ("A"));
opts = BCON_NEW ("projection", "{", "size.uom", BCON_INT64 (0), "}");
cursor = mongoc_collection_find_with_opts (collection, filter, opts, NULL);
var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Exclude("size.uom");
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();
projection := bson.D{
{"size.uom", 0},
}
cursor, err := coll.Find(
context.TODO(),
bson.D{
{"status", "A"},
},
options.Find().SetProjection(projection),
)
findPublisher = collection.find(eq("status", "A")).projection(exclude("size.uom"));

プロジェクション ドキュメントを指定するには、 com.mongodb.client.FindIterable.projection メソッドをfind メソッドに適用します。この例では com.mongodb.client.model を使用します。プロジェクション クラスを使用してプロジェクション ドキュメントを作成します。

findIterable = collection.find(eq("status", "A")).projection(exclude("size.uom"));
val findFlow = collection
.find(eq("status", "A")).projection(exclude("size.uom"))
cursor = db.inventory.find({"status": "A"}, {"size.uom": 0})
const cursor = db
.collection('inventory')
.find({
status: 'A'
})
.project({ 'size.uom': 0 });
$cursor = $db->coll("inventory")->find(
{ status => "A" }, { projection => { "size.uom" => 0 } }
);
$cursor = $db->inventory->find(
['status' => 'A'],
['projection' => ['size.uom' => 0]],
);
cursor = db.inventory.find({"status": "A"}, {"size.uom": 0})
client[:inventory].find({ status: 'A' },
projection: { 'size.uom' => 0 })
findObservable = collection.find(equal("status", "A")).projection(exclude("size.uom"))

ネストされたフォームを使用して埋め込みフィールドを指定することもできます。たとえば、{ size: { uom: 0 } }などです。

ドット表記を使用して、配列に埋め込まれたドキュメント内の特定のフィールドをプロジェクトします。

次の例では、返すプロジェクションを指定します。

  • _id フィールド(デフォルトで返されます)

  • item フィールド

  • status フィールド

  • instock 配列に埋め込まれたドキュメントの qty フィールド

db.inventory.find( { status: "A" }, { item: 1, status: 1, "instock.qty": 1 } )
  1. 次の式を Filter フィールドにコピーします。

    { status: "A" }
  2. Options をクリックすると、追加のクエリオプションが開きます。

  3. 次の式を Project フィールドにコピーします。

    { item: 1, status: 1, "instock.qty": 1 }
  4. [Find] をクリックします。

mongoc_collection_t *collection;
bson_t *filter;
bson_t *opts;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("status", BCON_UTF8 ("A"));
opts = BCON_NEW ("projection", "{", "item", BCON_INT64 (1),
"status", BCON_INT64 (1),
"instock.qty", BCON_INT64 (1), "}");
cursor = mongoc_collection_find_with_opts (collection, filter, opts, NULL);
var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Include("instock.qty");
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();
projection := bson.D{
{"item", 1},
{"status", 1},
{"instock.qty", 1},
}
cursor, err := coll.Find(
context.TODO(),
bson.D{
{"status", "A"},
},
options.Find().SetProjection(projection),
)
findPublisher = collection.find(eq("status", "A")).projection(include("item", "status", "instock.qty"));

プロジェクション ドキュメントを指定するには、 com.mongodb.client.FindIterable.projection メソッドをfind メソッドに適用します。この例では com.mongodb.client.model を使用します。プロジェクション クラスを使用してプロジェクション ドキュメントを作成します。

findIterable = collection.find(eq("status", "A")).projection(include("item", "status", "instock.qty"));
val findFlow = collection
.find(eq("status", "A")).projection(include("item", "status", "instock.qty"))
cursor = db.inventory.find({"status": "A"}, {"item": 1, "status": 1, "instock.qty": 1})
const cursor = db
.collection('inventory')
.find({
status: 'A'
})
.project({ item: 1, status: 1, 'instock.qty': 1 });
$cursor = $db->coll("inventory")->find( { status => "A" },
{ projection => { item => 1, status => 1, "instock.qty" => 1 } } );
$cursor = $db->inventory->find(
['status' => 'A'],
['projection' => ['item' => 1, 'status' => 1, 'instock.qty' => 1]],
);
cursor = db.inventory.find({"status": "A"}, {"item": 1, "status": 1, "instock.qty": 1})
client[:inventory].find({ status: 'A' },
projection: {'item' => 1, 'status' => 1, 'instock.qty' => 1 })
findObservable = collection.find(equal("status", "A")).projection(include("item", "status", "instock.qty"))

配列を含むフィールドの場合、MongoDB は、$elemMatch$slice$ の配列を操作するための次のプロジェクション演算子を提供します。

次の例では、$slice プロジェクション演算子を使用して、instock 配列の最後の要素を返します。

db.inventory.find( { status: "A" }, { item: 1, status: 1, instock: { $slice: -1 } } )
  1. 次の式を Filter フィールドにコピーします。

    { status: "A" }
  2. Options をクリックすると、追加のクエリオプションが開きます。

  3. 次の式を Project フィールドにコピーします。

    { item: 1, status: 1, instock: { $slice: -1 } }
  4. [Find] をクリックします。

mongoc_collection_t *collection;
bson_t *filter;
bson_t *opts;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("status", BCON_UTF8 ("A"));
opts = BCON_NEW ("projection", "{", "item", BCON_INT64 (1),
"status", BCON_INT64 (1),
"instock", "{",
"$slice", BCON_INT64 (-1),
"}", "}");
cursor = mongoc_collection_find_with_opts (collection, filter, opts, NULL);
var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Slice("instock", -1);
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();
projection := bson.D{
{"item", 1},
{"status", 1},
{"instock", bson.D{
{"$slice", -1},
}},
}
cursor, err := coll.Find(
context.TODO(),
bson.D{
{"status", "A"},
},
options.Find().SetProjection(projection),
)
findPublisher = collection.find(eq("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)));

プロジェクション ドキュメントを指定するには、 com.mongodb.client.FindIterable.projection メソッドをfind メソッドに適用します。この例では com.mongodb.client.model を使用します。プロジェクション クラスを使用してプロジェクション ドキュメントを作成します。

findIterable = collection.find(eq("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)));

プロジェクション ドキュメントを指定するには、 FindFlow.projection()メソッドをfind()メソッドに適用します。 この例では com.mongodb.client.model を使用します。プロジェクション クラスを使用してプロジェクション ドキュメントを作成します。

val findFlow = collection
.find(eq("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)))
cursor = db.inventory.find(
{"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
const cursor = db
.collection('inventory')
.find({
status: 'A'
})
.project({ item: 1, status: 1, instock: { $slice: -1 } });
$cursor = $db->coll("inventory")->find(
{ status => "A" },
{ projection => { item => 1, status => 1, instock => { '$slice' => -1 } } }
);
$cursor = $db->inventory->find(
['status' => 'A'],
['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]],
);
cursor = db.inventory.find(
{"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
client[:inventory].find({ status: 'A' },
projection: {'item' => 1,
'status' => 1,
'instock' => { '$slice' => -1 } })
findObservable = collection.find(equal("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)))

返される配列に含める特定の要素をプロジェクションするために使用できる演算子は、 $elemMatch$slice 、および$のみです。 例えば、配列インデックスを使用して特定の配列要素をプロジェクションすることは できません。例: { "instock.0": 1 }プロジェクションでは、最初の要素を含む配列は プロジェクションされませ

配列を含むフィールドの場合、MongoDB は、$elemMatch$slice$ の配列を操作するための次のプロジェクション演算子を提供します。

次の例では、$slice プロジェクション演算子を使用して、instock 配列の最後の要素を返します。

db.inventory.find( { status: "A" }, { item: 1, status: 1, instock: { $slice: -1 } } )
  1. 次の式を Filter フィールドにコピーします。

    { status: "A" }
  2. Options をクリックすると、追加のクエリオプションが開きます。

  3. 次の式を Project フィールドにコピーします。

    { item: 1, status: 1, instock: { $slice: -1 } }
  4. [Find] をクリックします。

mongoc_collection_t *collection;
bson_t *filter;
bson_t *opts;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("status", BCON_UTF8 ("A"));
opts = BCON_NEW ("projection", "{", "item", BCON_INT64 (1),
"status", BCON_INT64 (1),
"instock", "{",
"$slice", BCON_INT64 (-1),
"}", "}");
cursor = mongoc_collection_find_with_opts (collection, filter, opts, NULL);
var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Slice("instock", -1);
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();
projection := bson.D{
{"item", 1},
{"status", 1},
{"instock", bson.D{
{"$slice", -1},
}},
}
cursor, err := coll.Find(
context.TODO(),
bson.D{
{"status", "A"},
},
options.Find().SetProjection(projection),
)
findPublisher = collection.find(eq("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)));

プロジェクション ドキュメントを指定するには、 com.mongodb.client.FindIterable.projection メソッドをfind メソッドに適用します。この例では com.mongodb.client.model を使用します。プロジェクション クラスを使用してプロジェクション ドキュメントを作成します。

findIterable = collection.find(eq("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)));

プロジェクション ドキュメントを指定するには、 FindFlow.projection()メソッドをfind()メソッドに適用します。 この例では com.mongodb.client.model を使用します。プロジェクション クラスを使用してプロジェクション ドキュメントを作成します。

val findFlow = collection
.find(eq("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)))
cursor = db.inventory.find(
{"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
const cursor = db
.collection('inventory')
.find({
status: 'A'
})
.project({ item: 1, status: 1, instock: { $slice: -1 } });
$cursor = $db->coll("inventory")->find(
{ status => "A" },
{ projection => { item => 1, status => 1, instock => { '$slice' => -1 } } }
);
$cursor = $db->inventory->find(
['status' => 'A'],
['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]],
);
cursor = db.inventory.find(
{"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
client[:inventory].find({ status: 'A' },
projection: {'item' => 1,
'status' => 1,
'instock' => { '$slice' => -1 } })
findObservable = collection.find(equal("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)))

配列を含むフィールドの場合、MongoDB は、$elemMatch$slice$ の配列を操作するための次のプロジェクション演算子を提供します。

次の例では、$slice プロジェクション演算子を使用して、instock 配列の最後の要素を返します。

db.inventory.find( { status: "A" }, { item: 1, status: 1, instock: { $slice: -1 } } )
  1. 次の式を Filter フィールドにコピーします。

    { status: "A" }
  2. Options をクリックすると、追加のクエリオプションが開きます。

  3. 次の式を Project フィールドにコピーします。

    { item: 1, status: 1, instock: { $slice: -1 } }
  4. [Find] をクリックします。

mongoc_collection_t *collection;
bson_t *filter;
bson_t *opts;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("status", BCON_UTF8 ("A"));
opts = BCON_NEW ("projection", "{", "item", BCON_INT64 (1),
"status", BCON_INT64 (1),
"instock", "{",
"$slice", BCON_INT64 (-1),
"}", "}");
cursor = mongoc_collection_find_with_opts (collection, filter, opts, NULL);
var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Slice("instock", -1);
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();
projection := bson.D{
{"item", 1},
{"status", 1},
{"instock", bson.D{
{"$slice", -1},
}},
}
cursor, err := coll.Find(
context.TODO(),
bson.D{
{"status", "A"},
},
options.Find().SetProjection(projection),
)
findPublisher = collection.find(eq("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)));

プロジェクション ドキュメントを指定するには、 com.mongodb.client.FindIterable.projection メソッドをfind メソッドに適用します。この例では com.mongodb.client.model を使用します。プロジェクション クラスを使用してプロジェクション ドキュメントを作成します。

findIterable = collection.find(eq("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)));

プロジェクション ドキュメントを指定するには、 FindFlow.projection()メソッドをfind()メソッドに適用します。 この例では com.mongodb.client.model を使用します。プロジェクション クラスを使用してプロジェクション ドキュメントを作成します。

val findFlow = collection
.find(eq("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)))
cursor = db.inventory.find(
{"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
const cursor = db
.collection('inventory')
.find({
status: 'A'
})
.project({ item: 1, status: 1, instock: { $slice: -1 } });
$cursor = $db->coll("inventory")->find(
{ status => "A" },
{ projection => { item => 1, status => 1, instock => { '$slice' => -1 } } }
);
$cursor = $db->inventory->find(
['status' => 'A'],
['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]],
);
cursor = db.inventory.find(
{"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
client[:inventory].find({ status: 'A' },
projection: {'item' => 1,
'status' => 1,
'instock' => { '$slice' => -1 } })
findObservable = collection.find(equal("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)))

返される配列に含める特定の要素をプロジェクションするために使用できる演算子は、 $elemMatch$slice 、および$のみです。

例えば、次の操作では、最初の要素を含む配列はプロジェクションされません。

Builders<BsonDocument>.Projection.Include("instock.0")

配列を含むフィールドの場合、MongoDB は、$elemMatch$slice$ の配列を操作するための次のプロジェクション演算子を提供します。

次の例では、$slice プロジェクション演算子を使用して、instock 配列の最後の要素を返します。

db.inventory.find( { status: "A" }, { item: 1, status: 1, instock: { $slice: -1 } } )
  1. 次の式を Filter フィールドにコピーします。

    { status: "A" }
  2. Options をクリックすると、追加のクエリオプションが開きます。

  3. 次の式を Project フィールドにコピーします。

    { item: 1, status: 1, instock: { $slice: -1 } }
  4. [Find] をクリックします。

mongoc_collection_t *collection;
bson_t *filter;
bson_t *opts;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("status", BCON_UTF8 ("A"));
opts = BCON_NEW ("projection", "{", "item", BCON_INT64 (1),
"status", BCON_INT64 (1),
"instock", "{",
"$slice", BCON_INT64 (-1),
"}", "}");
cursor = mongoc_collection_find_with_opts (collection, filter, opts, NULL);
var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Slice("instock", -1);
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();
projection := bson.D{
{"item", 1},
{"status", 1},
{"instock", bson.D{
{"$slice", -1},
}},
}
cursor, err := coll.Find(
context.TODO(),
bson.D{
{"status", "A"},
},
options.Find().SetProjection(projection),
)
findPublisher = collection.find(eq("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)));

プロジェクション ドキュメントを指定するには、 com.mongodb.client.FindIterable.projection メソッドをfind メソッドに適用します。この例では com.mongodb.client.model を使用します。プロジェクション クラスを使用してプロジェクション ドキュメントを作成します。

findIterable = collection.find(eq("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)));

プロジェクション ドキュメントを指定するには、 FindFlow.projection()メソッドをfind()メソッドに適用します。 この例では com.mongodb.client.model を使用します。プロジェクション クラスを使用してプロジェクション ドキュメントを作成します。

val findFlow = collection
.find(eq("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)))
cursor = db.inventory.find(
{"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
const cursor = db
.collection('inventory')
.find({
status: 'A'
})
.project({ item: 1, status: 1, instock: { $slice: -1 } });
$cursor = $db->coll("inventory")->find(
{ status => "A" },
{ projection => { item => 1, status => 1, instock => { '$slice' => -1 } } }
);
$cursor = $db->inventory->find(
['status' => 'A'],
['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]],
);
cursor = db.inventory.find(
{"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
client[:inventory].find({ status: 'A' },
projection: {'item' => 1,
'status' => 1,
'instock' => { '$slice' => -1 } })
findObservable = collection.find(equal("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)))

返される配列に含める特定の要素をプロジェクションするために使用できる演算子は、 $elemMatch$slice 、および$のみです。 例えば、配列インデックスを使用して特定の配列要素をプロジェクションすることは できません。例: include("instock.0")プロジェクションでは、最初の要素を含む配列は プロジェクションされませ

配列を含むフィールドの場合、MongoDB は、$elemMatch$slice$ の配列を操作するための次のプロジェクション演算子を提供します。

次の例では、$slice プロジェクション演算子を使用して、instock 配列の最後の要素を返します。

db.inventory.find( { status: "A" }, { item: 1, status: 1, instock: { $slice: -1 } } )
  1. 次の式を Filter フィールドにコピーします。

    { status: "A" }
  2. Options をクリックすると、追加のクエリオプションが開きます。

  3. 次の式を Project フィールドにコピーします。

    { item: 1, status: 1, instock: { $slice: -1 } }
  4. [Find] をクリックします。

mongoc_collection_t *collection;
bson_t *filter;
bson_t *opts;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("status", BCON_UTF8 ("A"));
opts = BCON_NEW ("projection", "{", "item", BCON_INT64 (1),
"status", BCON_INT64 (1),
"instock", "{",
"$slice", BCON_INT64 (-1),
"}", "}");
cursor = mongoc_collection_find_with_opts (collection, filter, opts, NULL);
var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Slice("instock", -1);
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();
projection := bson.D{
{"item", 1},
{"status", 1},
{"instock", bson.D{
{"$slice", -1},
}},
}
cursor, err := coll.Find(
context.TODO(),
bson.D{
{"status", "A"},
},
options.Find().SetProjection(projection),
)
findPublisher = collection.find(eq("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)));

プロジェクション ドキュメントを指定するには、 com.mongodb.client.FindIterable.projection メソッドをfind メソッドに適用します。この例では com.mongodb.client.model を使用します。プロジェクション クラスを使用してプロジェクション ドキュメントを作成します。

findIterable = collection.find(eq("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)));

プロジェクション ドキュメントを指定するには、 FindFlow.projection()メソッドをfind()メソッドに適用します。 この例では com.mongodb.client.model を使用します。プロジェクション クラスを使用してプロジェクション ドキュメントを作成します。

val findFlow = collection
.find(eq("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)))
cursor = db.inventory.find(
{"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
const cursor = db
.collection('inventory')
.find({
status: 'A'
})
.project({ item: 1, status: 1, instock: { $slice: -1 } });
$cursor = $db->coll("inventory")->find(
{ status => "A" },
{ projection => { item => 1, status => 1, instock => { '$slice' => -1 } } }
);
$cursor = $db->inventory->find(
['status' => 'A'],
['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]],
);
cursor = db.inventory.find(
{"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
client[:inventory].find({ status: 'A' },
projection: {'item' => 1,
'status' => 1,
'instock' => { '$slice' => -1 } })
findObservable = collection.find(equal("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)))

返される配列に含める特定の要素をプロジェクションするために使用できる演算子は、 $elemMatch$slice 、および$のみです。 例えば、配列インデックスを使用して特定の配列要素をプロジェクションすることは できません。例: include("instock.0")プロジェクションでは、最初の要素を含む配列は プロジェクションされませ

配列を含むフィールドの場合、MongoDB は、$elemMatch$slice$ の配列を操作するための次のプロジェクション演算子を提供します。

次の例では、$slice プロジェクション演算子を使用して、instock 配列の最後の要素を返します。

db.inventory.find( { status: "A" }, { item: 1, status: 1, instock: { $slice: -1 } } )
  1. 次の式を Filter フィールドにコピーします。

    { status: "A" }
  2. Options をクリックすると、追加のクエリオプションが開きます。

  3. 次の式を Project フィールドにコピーします。

    { item: 1, status: 1, instock: { $slice: -1 } }
  4. [Find] をクリックします。

mongoc_collection_t *collection;
bson_t *filter;
bson_t *opts;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("status", BCON_UTF8 ("A"));
opts = BCON_NEW ("projection", "{", "item", BCON_INT64 (1),
"status", BCON_INT64 (1),
"instock", "{",
"$slice", BCON_INT64 (-1),
"}", "}");
cursor = mongoc_collection_find_with_opts (collection, filter, opts, NULL);
var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Slice("instock", -1);
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();
projection := bson.D{
{"item", 1},
{"status", 1},
{"instock", bson.D{
{"$slice", -1},
}},
}
cursor, err := coll.Find(
context.TODO(),
bson.D{
{"status", "A"},
},
options.Find().SetProjection(projection),
)
findPublisher = collection.find(eq("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)));

プロジェクション ドキュメントを指定するには、 com.mongodb.client.FindIterable.projection メソッドをfind メソッドに適用します。この例では com.mongodb.client.model を使用します。プロジェクション クラスを使用してプロジェクション ドキュメントを作成します。

findIterable = collection.find(eq("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)));

プロジェクション ドキュメントを指定するには、 FindFlow.projection()メソッドをfind()メソッドに適用します。 この例では com.mongodb.client.model を使用します。プロジェクション クラスを使用してプロジェクション ドキュメントを作成します。

val findFlow = collection
.find(eq("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)))
cursor = db.inventory.find(
{"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
const cursor = db
.collection('inventory')
.find({
status: 'A'
})
.project({ item: 1, status: 1, instock: { $slice: -1 } });
$cursor = $db->coll("inventory")->find(
{ status => "A" },
{ projection => { item => 1, status => 1, instock => { '$slice' => -1 } } }
);
$cursor = $db->inventory->find(
['status' => 'A'],
['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]],
);
cursor = db.inventory.find(
{"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
client[:inventory].find({ status: 'A' },
projection: {'item' => 1,
'status' => 1,
'instock' => { '$slice' => -1 } })
findObservable = collection.find(equal("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)))

返される配列に含める特定の要素をプロジェクションするために使用できる演算子は、 $elemMatch$slice 、および$のみです。 例えば、配列インデックスを使用して特定の配列要素をプロジェクションすることは できません。例: include("instock.0")プロジェクションでは、最初の要素を含む配列は プロジェクションされませ

配列を含むフィールドの場合、MongoDB は、$elemMatch$slice$ の配列を操作するための次のプロジェクション演算子を提供します。

次の例では、$slice プロジェクション演算子を使用して、instock 配列の最後の要素を返します。

db.inventory.find( { status: "A" }, { item: 1, status: 1, instock: { $slice: -1 } } )
  1. 次の式を Filter フィールドにコピーします。

    { status: "A" }
  2. Options をクリックすると、追加のクエリオプションが開きます。

  3. 次の式を Project フィールドにコピーします。

    { item: 1, status: 1, instock: { $slice: -1 } }
  4. [Find] をクリックします。

mongoc_collection_t *collection;
bson_t *filter;
bson_t *opts;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("status", BCON_UTF8 ("A"));
opts = BCON_NEW ("projection", "{", "item", BCON_INT64 (1),
"status", BCON_INT64 (1),
"instock", "{",
"$slice", BCON_INT64 (-1),
"}", "}");
cursor = mongoc_collection_find_with_opts (collection, filter, opts, NULL);
var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Slice("instock", -1);
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();
projection := bson.D{
{"item", 1},
{"status", 1},
{"instock", bson.D{
{"$slice", -1},
}},
}
cursor, err := coll.Find(
context.TODO(),
bson.D{
{"status", "A"},
},
options.Find().SetProjection(projection),
)
findPublisher = collection.find(eq("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)));

プロジェクション ドキュメントを指定するには、 com.mongodb.client.FindIterable.projection メソッドをfind メソッドに適用します。この例では com.mongodb.client.model を使用します。プロジェクション クラスを使用してプロジェクション ドキュメントを作成します。

findIterable = collection.find(eq("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)));

プロジェクション ドキュメントを指定するには、 FindFlow.projection()メソッドをfind()メソッドに適用します。 この例では com.mongodb.client.model を使用します。プロジェクション クラスを使用してプロジェクション ドキュメントを作成します。

val findFlow = collection
.find(eq("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)))
cursor = db.inventory.find(
{"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
const cursor = db
.collection('inventory')
.find({
status: 'A'
})
.project({ item: 1, status: 1, instock: { $slice: -1 } });
$cursor = $db->coll("inventory")->find(
{ status => "A" },
{ projection => { item => 1, status => 1, instock => { '$slice' => -1 } } }
);
$cursor = $db->inventory->find(
['status' => 'A'],
['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]],
);
cursor = db.inventory.find(
{"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
client[:inventory].find({ status: 'A' },
projection: {'item' => 1,
'status' => 1,
'instock' => { '$slice' => -1 } })
findObservable = collection.find(equal("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)))

返される配列に含める特定の要素をプロジェクションするために使用できる演算子は、 $elemMatch$slice 、および$のみです。 例えば、配列インデックスを使用して特定の配列要素をプロジェクションすることは できません。例: include("instock.0")プロジェクションでは、最初の要素を含む配列は プロジェクションされませ

配列を含むフィールドの場合、MongoDB は、$elemMatch$slice$ の配列を操作するための次のプロジェクション演算子を提供します。

次の例では、$slice プロジェクション演算子を使用して、instock 配列の最後の要素を返します。

db.inventory.find( { status: "A" }, { item: 1, status: 1, instock: { $slice: -1 } } )
  1. 次の式を Filter フィールドにコピーします。

    { status: "A" }
  2. Options をクリックすると、追加のクエリオプションが開きます。

  3. 次の式を Project フィールドにコピーします。

    { item: 1, status: 1, instock: { $slice: -1 } }
  4. [Find] をクリックします。

mongoc_collection_t *collection;
bson_t *filter;
bson_t *opts;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("status", BCON_UTF8 ("A"));
opts = BCON_NEW ("projection", "{", "item", BCON_INT64 (1),
"status", BCON_INT64 (1),
"instock", "{",
"$slice", BCON_INT64 (-1),
"}", "}");
cursor = mongoc_collection_find_with_opts (collection, filter, opts, NULL);
var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Slice("instock", -1);
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();
projection := bson.D{
{"item", 1},
{"status", 1},
{"instock", bson.D{
{"$slice", -1},
}},
}
cursor, err := coll.Find(
context.TODO(),
bson.D{
{"status", "A"},
},
options.Find().SetProjection(projection),
)
findPublisher = collection.find(eq("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)));

プロジェクション ドキュメントを指定するには、 com.mongodb.client.FindIterable.projection メソッドをfind メソッドに適用します。この例では com.mongodb.client.model を使用します。プロジェクション クラスを使用してプロジェクション ドキュメントを作成します。

findIterable = collection.find(eq("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)));

プロジェクション ドキュメントを指定するには、 FindFlow.projection()メソッドをfind()メソッドに適用します。 この例では com.mongodb.client.model を使用します。プロジェクション クラスを使用してプロジェクション ドキュメントを作成します。

val findFlow = collection
.find(eq("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)))
cursor = db.inventory.find(
{"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
const cursor = db
.collection('inventory')
.find({
status: 'A'
})
.project({ item: 1, status: 1, instock: { $slice: -1 } });
$cursor = $db->coll("inventory")->find(
{ status => "A" },
{ projection => { item => 1, status => 1, instock => { '$slice' => -1 } } }
);
$cursor = $db->inventory->find(
['status' => 'A'],
['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]],
);
cursor = db.inventory.find(
{"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
client[:inventory].find({ status: 'A' },
projection: {'item' => 1,
'status' => 1,
'instock' => { '$slice' => -1 } })
findObservable = collection.find(equal("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)))

返される配列に含める特定の要素をプロジェクションするために使用できる演算子は、 $elemMatch$slice 、および$のみです。 例えば、配列インデックスを使用して特定の配列要素をプロジェクションすることは できません。例: { "instock.0": 1 }プロジェクションでは、最初の要素を含む配列は プロジェクションされませ

配列を含むフィールドの場合、MongoDB は、$elemMatch$slice$ の配列を操作するための次のプロジェクション演算子を提供します。

次の例では、$slice プロジェクション演算子を使用して、instock 配列の最後の要素を返します。

db.inventory.find( { status: "A" }, { item: 1, status: 1, instock: { $slice: -1 } } )
  1. 次の式を Filter フィールドにコピーします。

    { status: "A" }
  2. Options をクリックすると、追加のクエリオプションが開きます。

  3. 次の式を Project フィールドにコピーします。

    { item: 1, status: 1, instock: { $slice: -1 } }
  4. [Find] をクリックします。

mongoc_collection_t *collection;
bson_t *filter;
bson_t *opts;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("status", BCON_UTF8 ("A"));
opts = BCON_NEW ("projection", "{", "item", BCON_INT64 (1),
"status", BCON_INT64 (1),
"instock", "{",
"$slice", BCON_INT64 (-1),
"}", "}");
cursor = mongoc_collection_find_with_opts (collection, filter, opts, NULL);
var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Slice("instock", -1);
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();
projection := bson.D{
{"item", 1},
{"status", 1},
{"instock", bson.D{
{"$slice", -1},
}},
}
cursor, err := coll.Find(
context.TODO(),
bson.D{
{"status", "A"},
},
options.Find().SetProjection(projection),
)
findPublisher = collection.find(eq("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)));

プロジェクション ドキュメントを指定するには、 com.mongodb.client.FindIterable.projection メソッドをfind メソッドに適用します。この例では com.mongodb.client.model を使用します。プロジェクション クラスを使用してプロジェクション ドキュメントを作成します。

findIterable = collection.find(eq("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)));

プロジェクション ドキュメントを指定するには、 FindFlow.projection()メソッドをfind()メソッドに適用します。 この例では com.mongodb.client.model を使用します。プロジェクション クラスを使用してプロジェクション ドキュメントを作成します。

val findFlow = collection
.find(eq("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)))
cursor = db.inventory.find(
{"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
const cursor = db
.collection('inventory')
.find({
status: 'A'
})
.project({ item: 1, status: 1, instock: { $slice: -1 } });
$cursor = $db->coll("inventory")->find(
{ status => "A" },
{ projection => { item => 1, status => 1, instock => { '$slice' => -1 } } }
);
$cursor = $db->inventory->find(
['status' => 'A'],
['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]],
);
cursor = db.inventory.find(
{"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
client[:inventory].find({ status: 'A' },
projection: {'item' => 1,
'status' => 1,
'instock' => { '$slice' => -1 } })
findObservable = collection.find(equal("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)))

返される配列に含める特定の要素をプロジェクションするために使用できる演算子は、 $elemMatch$slice 、および$のみです。 例えば、配列インデックスを使用して特定の配列要素をプロジェクションすることは できません。例: { "instock.0" => 1 }プロジェクションでは、最初の要素を含む配列は プロジェクションされませ

配列を含むフィールドの場合、MongoDB は、$elemMatch$slice$ の配列を操作するための次のプロジェクション演算子を提供します。

次の例では、$slice プロジェクション演算子を使用して、instock 配列の最後の要素を返します。

db.inventory.find( { status: "A" }, { item: 1, status: 1, instock: { $slice: -1 } } )
  1. 次の式を Filter フィールドにコピーします。

    { status: "A" }
  2. Options をクリックすると、追加のクエリオプションが開きます。

  3. 次の式を Project フィールドにコピーします。

    { item: 1, status: 1, instock: { $slice: -1 } }
  4. [Find] をクリックします。

mongoc_collection_t *collection;
bson_t *filter;
bson_t *opts;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("status", BCON_UTF8 ("A"));
opts = BCON_NEW ("projection", "{", "item", BCON_INT64 (1),
"status", BCON_INT64 (1),
"instock", "{",
"$slice", BCON_INT64 (-1),
"}", "}");
cursor = mongoc_collection_find_with_opts (collection, filter, opts, NULL);
var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Slice("instock", -1);
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();
projection := bson.D{
{"item", 1},
{"status", 1},
{"instock", bson.D{
{"$slice", -1},
}},
}
cursor, err := coll.Find(
context.TODO(),
bson.D{
{"status", "A"},
},
options.Find().SetProjection(projection),
)
findPublisher = collection.find(eq("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)));

プロジェクション ドキュメントを指定するには、 com.mongodb.client.FindIterable.projection メソッドをfind メソッドに適用します。この例では com.mongodb.client.model を使用します。プロジェクション クラスを使用してプロジェクション ドキュメントを作成します。

findIterable = collection.find(eq("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)));

プロジェクション ドキュメントを指定するには、 FindFlow.projection()メソッドをfind()メソッドに適用します。 この例では com.mongodb.client.model を使用します。プロジェクション クラスを使用してプロジェクション ドキュメントを作成します。

val findFlow = collection
.find(eq("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)))
cursor = db.inventory.find(
{"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
const cursor = db
.collection('inventory')
.find({
status: 'A'
})
.project({ item: 1, status: 1, instock: { $slice: -1 } });
$cursor = $db->coll("inventory")->find(
{ status => "A" },
{ projection => { item => 1, status => 1, instock => { '$slice' => -1 } } }
);
$cursor = $db->inventory->find(
['status' => 'A'],
['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]],
);
cursor = db.inventory.find(
{"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
client[:inventory].find({ status: 'A' },
projection: {'item' => 1,
'status' => 1,
'instock' => { '$slice' => -1 } })
findObservable = collection.find(equal("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)))

返される配列に含める特定の要素をプロジェクションするために使用できる演算子は、 $elemMatch$slice 、および$のみです。 例えば、配列インデックスを使用して特定の配列要素をプロジェクションすることは できません。例: [ "instock.0" => 1 ]プロジェクションでは、最初の要素を含む配列は プロジェクションされませ

配列を含むフィールドの場合、MongoDB は、$elemMatch$slice$ の配列を操作するための次のプロジェクション演算子を提供します。

次の例では、$slice プロジェクション演算子を使用して、instock 配列の最後の要素を返します。

db.inventory.find( { status: "A" }, { item: 1, status: 1, instock: { $slice: -1 } } )
  1. 次の式を Filter フィールドにコピーします。

    { status: "A" }
  2. Options をクリックすると、追加のクエリオプションが開きます。

  3. 次の式を Project フィールドにコピーします。

    { item: 1, status: 1, instock: { $slice: -1 } }
  4. [Find] をクリックします。

mongoc_collection_t *collection;
bson_t *filter;
bson_t *opts;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("status", BCON_UTF8 ("A"));
opts = BCON_NEW ("projection", "{", "item", BCON_INT64 (1),
"status", BCON_INT64 (1),
"instock", "{",
"$slice", BCON_INT64 (-1),
"}", "}");
cursor = mongoc_collection_find_with_opts (collection, filter, opts, NULL);
var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Slice("instock", -1);
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();
projection := bson.D{
{"item", 1},
{"status", 1},
{"instock", bson.D{
{"$slice", -1},
}},
}
cursor, err := coll.Find(
context.TODO(),
bson.D{
{"status", "A"},
},
options.Find().SetProjection(projection),
)
findPublisher = collection.find(eq("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)));

プロジェクション ドキュメントを指定するには、 com.mongodb.client.FindIterable.projection メソッドをfind メソッドに適用します。この例では com.mongodb.client.model を使用します。プロジェクション クラスを使用してプロジェクション ドキュメントを作成します。

findIterable = collection.find(eq("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)));

プロジェクション ドキュメントを指定するには、 FindFlow.projection()メソッドをfind()メソッドに適用します。 この例では com.mongodb.client.model を使用します。プロジェクション クラスを使用してプロジェクション ドキュメントを作成します。

val findFlow = collection
.find(eq("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)))
cursor = db.inventory.find(
{"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
const cursor = db
.collection('inventory')
.find({
status: 'A'
})
.project({ item: 1, status: 1, instock: { $slice: -1 } });
$cursor = $db->coll("inventory")->find(
{ status => "A" },
{ projection => { item => 1, status => 1, instock => { '$slice' => -1 } } }
);
$cursor = $db->inventory->find(
['status' => 'A'],
['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]],
);
cursor = db.inventory.find(
{"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
client[:inventory].find({ status: 'A' },
projection: {'item' => 1,
'status' => 1,
'instock' => { '$slice' => -1 } })
findObservable = collection.find(equal("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)))

返される配列に含める特定の要素をプロジェクションするために使用できる演算子は、 $elemMatch$slice 、および$のみです。 例えば、配列インデックスを使用して特定の配列要素をプロジェクションすることは できません。例: { "instock.0": 1 }プロジェクションでは、最初の要素を含む配列は プロジェクションされませ

配列を含むフィールドの場合、MongoDB は、$elemMatch$slice$ の配列を操作するための次のプロジェクション演算子を提供します。

次の例では、$slice プロジェクション演算子を使用して、instock 配列の最後の要素を返します。

db.inventory.find( { status: "A" }, { item: 1, status: 1, instock: { $slice: -1 } } )
  1. 次の式を Filter フィールドにコピーします。

    { status: "A" }
  2. Options をクリックすると、追加のクエリオプションが開きます。

  3. 次の式を Project フィールドにコピーします。

    { item: 1, status: 1, instock: { $slice: -1 } }
  4. [Find] をクリックします。

mongoc_collection_t *collection;
bson_t *filter;
bson_t *opts;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("status", BCON_UTF8 ("A"));
opts = BCON_NEW ("projection", "{", "item", BCON_INT64 (1),
"status", BCON_INT64 (1),
"instock", "{",
"$slice", BCON_INT64 (-1),
"}", "}");
cursor = mongoc_collection_find_with_opts (collection, filter, opts, NULL);
var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Slice("instock", -1);
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();
projection := bson.D{
{"item", 1},
{"status", 1},
{"instock", bson.D{
{"$slice", -1},
}},
}
cursor, err := coll.Find(
context.TODO(),
bson.D{
{"status", "A"},
},
options.Find().SetProjection(projection),
)
findPublisher = collection.find(eq("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)));

プロジェクション ドキュメントを指定するには、 com.mongodb.client.FindIterable.projection メソッドをfind メソッドに適用します。この例では com.mongodb.client.model を使用します。プロジェクション クラスを使用してプロジェクション ドキュメントを作成します。

findIterable = collection.find(eq("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)));

プロジェクション ドキュメントを指定するには、 FindFlow.projection()メソッドをfind()メソッドに適用します。 この例では com.mongodb.client.model を使用します。プロジェクション クラスを使用してプロジェクション ドキュメントを作成します。

val findFlow = collection
.find(eq("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)))
cursor = db.inventory.find(
{"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
const cursor = db
.collection('inventory')
.find({
status: 'A'
})
.project({ item: 1, status: 1, instock: { $slice: -1 } });
$cursor = $db->coll("inventory")->find(
{ status => "A" },
{ projection => { item => 1, status => 1, instock => { '$slice' => -1 } } }
);
$cursor = $db->inventory->find(
['status' => 'A'],
['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]],
);
cursor = db.inventory.find(
{"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
client[:inventory].find({ status: 'A' },
projection: {'item' => 1,
'status' => 1,
'instock' => { '$slice' => -1 } })
findObservable = collection.find(equal("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)))

返される配列に含める特定の要素をプロジェクションするために使用できる演算子は、 $elemMatch$slice 、および$のみです。 例えば、配列インデックスを使用して特定の配列要素をプロジェクションすることは できません。例: { "instock.0" => 1 }プロジェクションでは、最初の要素を含む配列は プロジェクションされませ

配列を含むフィールドの場合、MongoDB は、$elemMatch$slice$ の配列を操作するための次のプロジェクション演算子を提供します。

次の例では、$slice プロジェクション演算子を使用して、instock 配列の最後の要素を返します。

db.inventory.find( { status: "A" }, { item: 1, status: 1, instock: { $slice: -1 } } )
  1. 次の式を Filter フィールドにコピーします。

    { status: "A" }
  2. Options をクリックすると、追加のクエリオプションが開きます。

  3. 次の式を Project フィールドにコピーします。

    { item: 1, status: 1, instock: { $slice: -1 } }
  4. [Find] をクリックします。

mongoc_collection_t *collection;
bson_t *filter;
bson_t *opts;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("status", BCON_UTF8 ("A"));
opts = BCON_NEW ("projection", "{", "item", BCON_INT64 (1),
"status", BCON_INT64 (1),
"instock", "{",
"$slice", BCON_INT64 (-1),
"}", "}");
cursor = mongoc_collection_find_with_opts (collection, filter, opts, NULL);
var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Slice("instock", -1);
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();
projection := bson.D{
{"item", 1},
{"status", 1},
{"instock", bson.D{
{"$slice", -1},
}},
}
cursor, err := coll.Find(
context.TODO(),
bson.D{
{"status", "A"},
},
options.Find().SetProjection(projection),
)
findPublisher = collection.find(eq("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)));

プロジェクション ドキュメントを指定するには、 com.mongodb.client.FindIterable.projection メソッドをfind メソッドに適用します。この例では com.mongodb.client.model を使用します。プロジェクション クラスを使用してプロジェクション ドキュメントを作成します。

findIterable = collection.find(eq("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)));

プロジェクション ドキュメントを指定するには、 FindFlow.projection()メソッドをfind()メソッドに適用します。 この例では com.mongodb.client.model を使用します。プロジェクション クラスを使用してプロジェクション ドキュメントを作成します。

val findFlow = collection
.find(eq("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)))
cursor = db.inventory.find(
{"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
const cursor = db
.collection('inventory')
.find({
status: 'A'
})
.project({ item: 1, status: 1, instock: { $slice: -1 } });
$cursor = $db->coll("inventory")->find(
{ status => "A" },
{ projection => { item => 1, status => 1, instock => { '$slice' => -1 } } }
);
$cursor = $db->inventory->find(
['status' => 'A'],
['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]],
);
cursor = db.inventory.find(
{"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
client[:inventory].find({ status: 'A' },
projection: {'item' => 1,
'status' => 1,
'instock' => { '$slice' => -1 } })
findObservable = collection.find(equal("status", "A"))
.projection(fields(include("item", "status"), slice("instock", -1)))

返される配列に含める特定の要素をプロジェクションするために使用できる演算子は、 $elemMatch$slice 、および$のみです。 例えば、配列インデックスを使用して特定の配列要素をプロジェクションすることは できません。例: include("instock.0")プロジェクションでは、最初の要素を含む配列は プロジェクションされませ

集計式はクエリ プロジェクションで指定できます。集計式により、新しいフィールドのプロジェクションや、既存フィールドの値の変更ができます。

たとえば、次の操作では、集計式を使用して status フィールドの値を上書きし、新しいフィールド areareportNumber のプロジェクションをします。

注意

次の例では MongoDB Shell 構文を使用します。集計を使用したプロジェクションのドライバーの例については、ドライバーのドキュメントを参照してください。

db.inventory.find(
{ },
{
_id: 0,
item: 1,
status: {
$switch: {
branches: [
{
case: { $eq: [ "$status", "A" ] },
then: "Available"
},
{
case: { $eq: [ "$status", "D" ] },
then: "Discontinued"
},
],
default: "No status found"
}
},
area: {
$concat: [
{ $toString: { $multiply: [ "$size.h", "$size.w" ] } },
" ",
"$size.uom"
]
},
reportNumber: { $literal: 1 }
}
)
[
{
item: 'journal',
status: 'Available',
area: '294 cm',
reportNumber: 1
},
{
item: 'planner',
status: 'Discontinued',
area: '685.5 cm',
reportNumber: 1
},
{
item: 'notebook',
status: 'Available',
area: '93.5 in',
reportNumber: 1
},
{
item: 'paper',
status: 'Discontinued',
area: '93.5 in',
reportNumber: 1
},
{
item: 'postcard',
status: 'Available',
area: '152.5 cm',
reportNumber: 1
}
]

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

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

1
  1. まだ表示されていない場合は、希望するプロジェクトを含む組織を選択しますナビゲーション バーのOrganizationsメニュー

  2. まだ表示されていない場合は、ナビゲーション バーの Projects メニューからプロジェクトを選択します。

  3. まだ表示されていない場合は、サイドバーの [ Clusters ] をクリックします。

    [ Clusters (クラスター) ] ページが表示されます。

2
  1. サンプル データを含むクラスターで、[ Browse Collections ] をクリックします。

  2. 左側のナビゲーション ペインで、sample_mflix データベースを選択します。

  3. movies コレクションを選択します。

3
  1. Filterフィールドの右側にある [ More Optionsをクリックします。

  2. クエリフィルターを指定します。

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

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

    { year: 1924 }
4

クエリ結果で返すフィールドを指定します。

次のプロジェクト ドキュメントをProjectバーにコピーします。

{ title: 1, plot: 1 }
5

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

  • _id

  • title

  • plot

MongoDB Atlas はデフォルトで_idフィールドを返します。 _idフィールドを省略するには、次のプロジェクト ドキュメントをProjectバーにコピーし、 Applyをクリックします。

{ title: 1, plot: 1, _id: 0 }

MongoDB は、プロジェクションに関して追加の制限を適用します。詳細については、「プロジェクションの制限」を参照してください。

Tip

以下も参照してください。

戻る

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