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

項目一覧

一致するドキュメントのすべてのフィールドを返す

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

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

プログラミング言語のドライバー。
MongoDB Atlas UI 。詳細については、「 MongoDB Atlas でクエリから返されるプロジェクトフィールド」を参照してください。
MongoDB Compass

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

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

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

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

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

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

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

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

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

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

Tip

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

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

Tip

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

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

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

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

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

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

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

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() メソッドは一致するドキュメント内のすべてのフィールドを返します。

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

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

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

次の式を Filter フィールドにコピーします。
```
{ status: "A" }
```
[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"

指定されたフィールドと`_id` フィールドのみを返します

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

db.inventory.find( { status: "A" }, { item: 1, status: 1 } )

次の式を Filter フィールドにコピーします。
```
{ status: "A" }
```
Options をクリックすると、追加のクエリオプションが開きます。
次の式を Project フィールドにコピーします。
```
{ item: 1, status: 1 }
```
[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`フィールドを非表示にする

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

db.inventory.find( { status: "A" }, { item: 1, status: 1, _id: 0 } )

次の式を Filter フィールドにコピーします。
```
{ status: "A" }
```
Options をクリックすると、追加のクエリオプションが開きます。
次の式を Project フィールドにコピーします。
```
{ item: 1, status: 1, _id: 0 }
```
[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()));

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

次の式を Filter フィールドにコピーします。
```
{ status: "A" }
```
Options をクリックすると、追加のクエリオプションが開きます。
次の式を Project フィールドにコピーします。
```
{ status: 0, instock: 0 }
```
[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"));

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

次の式を Filter フィールドにコピーします。
```
{ status: "A" }
```
Options をクリックすると、追加のクエリオプションが開きます。
次の式を Project フィールドにコピーします。
```
{ item: 1, status: 1, "size.uom": 1 }
```
[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"));

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

次の式を Filter フィールドにコピーします。
```
{ status: "A" }
```
Options をクリックすると、追加のクエリオプションが開きます。
次の式を Project フィールドにコピーします。
```
{ "size.uom": 0 }
```
[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"));

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

次の式を Filter フィールドにコピーします。
```
{ status: "A" }
```
Options をクリックすると、追加のクエリオプションが開きます。
次の式を Project フィールドにコピーします。
```
{ item: 1, status: 1, "instock.qty": 1 }
```
[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"));

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

次の式を Filter フィールドにコピーします。
```
{ status: "A" }
```
Options をクリックすると、追加のクエリオプションが開きます。
次の式を Project フィールドにコピーします。
```
{ item: 1, status: 1, instock: { $slice: -1 } }
```
[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)));

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

次の式を Filter フィールドにコピーします。
```
{ status: "A" }
```
Options をクリックすると、追加のクエリオプションが開きます。
次の式を Project フィールドにコピーします。
```
{ item: 1, status: 1, instock: { $slice: -1 } }
```
[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)));

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

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

次の式を Filter フィールドにコピーします。
```
{ status: "A" }
```
Options をクリックすると、追加のクエリオプションが開きます。
次の式を Project フィールドにコピーします。
```
{ item: 1, status: 1, instock: { $slice: -1 } }
```
[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)));

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

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

次の式を Filter フィールドにコピーします。
```
{ status: "A" }
```
Options をクリックすると、追加のクエリオプションが開きます。
次の式を Project フィールドにコピーします。
```
{ item: 1, status: 1, instock: { $slice: -1 } }
```
[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)));

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

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

次の式を Filter フィールドにコピーします。
```
{ status: "A" }
```
Options をクリックすると、追加のクエリオプションが開きます。
次の式を Project フィールドにコピーします。
```
{ item: 1, status: 1, instock: { $slice: -1 } }
```
[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)));

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

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

次の式を Filter フィールドにコピーします。
```
{ status: "A" }
```
Options をクリックすると、追加のクエリオプションが開きます。
次の式を Project フィールドにコピーします。
```
{ item: 1, status: 1, instock: { $slice: -1 } }
```
[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)));

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

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

次の式を Filter フィールドにコピーします。
```
{ status: "A" }
```
Options をクリックすると、追加のクエリオプションが開きます。
次の式を Project フィールドにコピーします。
```
{ item: 1, status: 1, instock: { $slice: -1 } }
```
[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)));

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

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

次の式を Filter フィールドにコピーします。
```
{ status: "A" }
```
Options をクリックすると、追加のクエリオプションが開きます。
次の式を Project フィールドにコピーします。
```
{ item: 1, status: 1, instock: { $slice: -1 } }
```
[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)));

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

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

次の式を Filter フィールドにコピーします。
```
{ status: "A" }
```
Options をクリックすると、追加のクエリオプションが開きます。
次の式を Project フィールドにコピーします。
```
{ item: 1, status: 1, instock: { $slice: -1 } }
```
[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)));

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

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

次の式を Filter フィールドにコピーします。
```
{ status: "A" }
```
Options をクリックすると、追加のクエリオプションが開きます。
次の式を Project フィールドにコピーします。
```
{ item: 1, status: 1, instock: { $slice: -1 } }
```
[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)));

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

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

次の式を Filter フィールドにコピーします。
```
{ status: "A" }
```
Options をクリックすると、追加のクエリオプションが開きます。
次の式を Project フィールドにコピーします。
```
{ item: 1, status: 1, instock: { $slice: -1 } }
```
[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)));

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

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

次の式を Filter フィールドにコピーします。
```
{ status: "A" }
```
Options をクリックすると、追加のクエリオプションが開きます。
次の式を Project フィールドにコピーします。
```
{ item: 1, status: 1, instock: { $slice: -1 } }
```
[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)));

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

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

次の式を Filter フィールドにコピーします。
```
{ status: "A" }
```
Options をクリックすると、追加のクエリオプションが開きます。
次の式を Project フィールドにコピーします。
```
{ item: 1, status: 1, instock: { $slice: -1 } }
```
[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)));

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

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

集計式が入力されているプロジェクトフィールド

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

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

注意

次の例では 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 配置にロードする方法について詳しくは、「サンプルデータのロード」を参照してください。

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

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

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

コレクションへ移動する

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

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

Filterフィールドの右側にある [ More Optionsをクリックします。
クエリフィルターを指定します。
Filter フィールドにクエリフィルタードキュメントを指定します。クエリフィルタードキュメントは、クエリ演算子を使用して検索条件を指定します。
次のクエリフィルタードキュメントを Filter 検索バーにコピーします。
```
{ year: 1924 }
```

プロジェクトするフィールドを指定する

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

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

{ title: 1, plot: 1 }

[ Apply ] をクリックします

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

_id
title
plot

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

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

その他の考慮事項

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

Tip

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

戻る

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

Null または欠落しているフィールド

Tip

Tip

一致するドキュメントのすべてのフィールドを返す

指定されたフィールドと_id フィールドのみを返します

_idフィールドを非表示にする

注意

除外されたフィールド以外のすべてを返す

注意

埋め込みドキュメント内の特定のフィールドを返す

埋め込みドキュメントの特定のフィールドを非表示にする

配列内の埋め込みドキュメントのプロジェクション

返された配列内のプロジェクト固有の配列要素

集計式が入力されているプロジェクト フィールド

注意

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

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

コレクションへ移動する

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

プロジェクトするフィールドを指定する

[ Apply ] をクリックします

その他の考慮事項

Tip

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

指定されたフィールドと`_id` フィールドのみを返します

`_id`フィールドを非表示にする

集計式が入力されているプロジェクトフィールド

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