对于 AI 代理：可在 https://www.mongodb.com/zh-cn/docs/llms.txt 获取文档索引—通过在任何 URL 路径后添加 .md 可获取所有页面的 Markdown 版本。
Docs 菜单
Docs 主页
/ /
读取
Docs 主页
/
开发中
/
增删改查操作
/
读取
Docs 主页
/
开发中
/
增删改查操作
/
读取

查询返回的项目字段

使用投影来选择查询返回的文档字段。您可以使用以下方法：

➤ 使用右上角的 Select your language（选择语言）下拉菜单，设置以下示例的语言或选择 MongoDB Compass。

默认情况下，MongoDB 中的查询返回匹配文档中的所有字段。要限制 MongoDB 发送到应用程序的数据量，可以添加投影文档来指定或限制要返回的字段。

本页提供的示例展示了使用 mongosh 中的 db.collection.find() 方法进行带有投影的查询操作。

本页提供了使用MongoDB Compass进行带有投影的查询操作的示例。

此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：

本页提供了使用 mongoc_collection_find_with_opts 进行带有投影的查询操作的示例。

此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：

本页提供的示例展示了使用MongoDB .NET/ C#驱动程序中的 MongoCollection.Find() 方法进行带有投影的查询操作。

此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：

本页提供了使用MongoDB Go驱动程序中的 Collection.Find 函数进行带有投影的查询操作的示例。

此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：

本页提供了使用 com.mongodb.reactivestreams 进行带有投影的查询操作的示例。 MongoDB Java Reactive Streams 驱动程序中的客户端方法。

此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：

本页提供了使用 com.mongodb 进行带有投影的查询操作的示例。 MongoDB Java同步驱动程序中的客户端方法。

提示

驾驶员提供 com.mongodb。客户端.model.Filters 辅助方法，以方便创建过滤文档。本页上的示例使用这些方法创建过滤文档。

此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：

本页提供了使用MongoDB Kotlin协程驱动程序中的 MongoCollection.find() 方法进行带投影的查询操作的示例。

提示

驾驶员提供 com.mongodb。客户端.model.Filters 辅助方法，以方便创建过滤文档。本页上的示例使用这些方法创建过滤文档。

此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：

本页提供了使用PyMongo Async API中的 pymongo.asynchronous.collection.AsyncCollection.find 方法进行带有投影的查询操作的示例。

此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：

本页提供了使用MongoDB Node.js驱动程序中的 Collection.find() 方法进行带有投影的查询操作的示例。

此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：

本页提供了使用MongoDB PHP库中的 MongoDB\\Collection::find() 方法进行带有投影的查询操作的示例。

此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：

本页提供了使用PyMongo Python驾驶员中的 pymongo.collection.Collection.find 方法进行带有投影的查询操作的示例。

此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：

本页提供了使用MongoDB Ruby驱动程序中的 Mongo::Collection#find() 方法进行带有投影的查询操作的示例。

此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：

本页提供的示例展示了使用MongoDB Scala驱动程序中的集合.find() 方法进行的投影的查询操作。

此页面上的示例使用的是 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 := []any{
	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 }
    ]
  }
]);
$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 将返回匹配文档中的所有字段。

If you do not specify a projection filter, the mongoc_collection_find_with_opts() function returns all fields in the matching documents.

如果未指定投影过滤，MongoCollection.Find() 方法将返回匹配文档中的所有字段。

如果未指定投影过滤，Find() 方法将返回匹配文档中的所有字段。

如果未指定投影，则 com.mongodb.客户端.MongoCollection.find 方法返回匹配文档中的所有字段。

If you do not specify a projection document, the MongoCollection.find() method returns all fields in the matching documents.

如果未指定投影过滤，则find 方法将返回匹配文档中的所有字段。

如果未指定投影文档，find() 方法将生成匹配文档中的所有字段。

如果未指定投影文档，则 find() 方法将返回匹配文档中的所有字段

如果未指定投影文档，则 find 方法将返回匹配文档中的所有字段。

如果未指定投影文档，find() 方法将返回匹配文档中的所有字段。

如果未指定投影，集合的.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->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 } )

  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。客户端.FindIterable。投影方法转换为 find 方法。该示例使用 com.mongodb。客户端.model.Projections 类，用于创建投影文档。

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->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 以便从结果中删除 _id 字段，如以下示例所示：

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。客户端.FindIterable。投影方法转换为 find 方法。该示例使用 com.mongodb。客户端.model.Projections 类，用于创建投影文档。

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->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。客户端.FindIterable。投影方法转换为 find 方法。该示例使用 com.mongodb。客户端.model.Projections 类，用于创建投影文档。

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->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。客户端.FindIterable。投影方法转换为 find 方法。该示例使用 com.mongodb。客户端.model.Projections 类，用于创建投影文档。

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->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。客户端.FindIterable。投影方法转换为 find 方法。该示例使用 com.mongodb。客户端.model.Projections 类，用于创建投影文档。

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->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。客户端.FindIterable。投影方法转换为 find 方法。该示例使用 com.mongodb。客户端.model.Projections 类，用于创建投影文档。

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->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。客户端.FindIterable。投影方法转换为 find 方法。该示例使用 com.mongodb。客户端.model.Projections 类，用于创建投影文档。

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

To specify a projection document, chain the FindFlow.projection() method to the find() method. The example uses the com.mongodb.client.model.Projections class to create the projection documents.

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->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。客户端.FindIterable。投影方法转换为 find 方法。该示例使用 com.mongodb。客户端.model.Projections 类，用于创建投影文档。

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

To specify a projection document, chain the FindFlow.projection() method to the find() method. The example uses the com.mongodb.client.model.Projections class to create the projection documents.

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->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。客户端.FindIterable。投影方法转换为 find 方法。该示例使用 com.mongodb。客户端.model.Projections 类，用于创建投影文档。

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

To specify a projection document, chain the FindFlow.projection() method to the find() method. The example uses the com.mongodb.client.model.Projections class to create the projection documents.

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->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。客户端.FindIterable。投影方法转换为 find 方法。该示例使用 com.mongodb。客户端.model.Projections 类，用于创建投影文档。

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

To specify a projection document, chain the FindFlow.projection() method to the find() method. The example uses the com.mongodb.client.model.Projections class to create the projection documents.

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->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。客户端.FindIterable。投影方法转换为 find 方法。该示例使用 com.mongodb。客户端.model.Projections 类，用于创建投影文档。

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

To specify a projection document, chain the FindFlow.projection() method to the find() method. The example uses the com.mongodb.client.model.Projections class to create the projection documents.

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->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。客户端.FindIterable。投影方法转换为 find 方法。该示例使用 com.mongodb。客户端.model.Projections 类，用于创建投影文档。

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

To specify a projection document, chain the FindFlow.projection() method to the find() method. The example uses the com.mongodb.client.model.Projections class to create the projection documents.

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->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。客户端.FindIterable。投影方法转换为 find 方法。该示例使用 com.mongodb。客户端.model.Projections 类，用于创建投影文档。

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

To specify a projection document, chain the FindFlow.projection() method to the find() method. The example uses the com.mongodb.client.model.Projections class to create the projection documents.

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->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。客户端.FindIterable。投影方法转换为 find 方法。该示例使用 com.mongodb。客户端.model.Projections 类，用于创建投影文档。

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

To specify a projection document, chain the FindFlow.projection() method to the find() method. The example uses the com.mongodb.client.model.Projections class to create the projection documents.

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->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。客户端.FindIterable。投影方法转换为 find 方法。该示例使用 com.mongodb。客户端.model.Projections 类，用于创建投影文档。

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

To specify a projection document, chain the FindFlow.projection() method to the find() method. The example uses the com.mongodb.client.model.Projections class to create the projection documents.

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->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。客户端.FindIterable。投影方法转换为 find 方法。该示例使用 com.mongodb。客户端.model.Projections 类，用于创建投影文档。

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

To specify a projection document, chain the FindFlow.projection() method to the find() method. The example uses the com.mongodb.client.model.Projections class to create the projection documents.

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->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。客户端.FindIterable。投影方法转换为 find 方法。该示例使用 com.mongodb。客户端.model.Projections 类，用于创建投影文档。

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

To specify a projection document, chain the FindFlow.projection() method to the find() method. The example uses the com.mongodb.client.model.Projections class to create the projection documents.

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->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。客户端.FindIterable。投影方法转换为 find 方法。该示例使用 com.mongodb。客户端.model.Projections 类，用于创建投影文档。

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

To specify a projection document, chain the FindFlow.projection() method to the find() method. The example uses the com.mongodb.client.model.Projections class to create the projection documents.

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->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。客户端.FindIterable。投影方法转换为 find 方法。该示例使用 com.mongodb。客户端.model.Projections 类，用于创建投影文档。

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

To specify a projection document, chain the FindFlow.projection() method to the find() method. The example uses the com.mongodb.client.model.Projections class to create the projection documents.

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->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。客户端.FindIterable。投影方法转换为 find 方法。该示例使用 com.mongodb。客户端.model.Projections 类，用于创建投影文档。

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

To specify a projection document, chain the FindFlow.projection() method to the find() method. The example uses the com.mongodb.client.model.Projections class to create the projection documents.

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->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 字段的值，并投影新字段 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 中投影查询返回的字段，请按照以下步骤操作：

1

在 MongoDB Atlas 用户界面中，转到您项目的 Clusters（集群）页面。

  1. 如果尚未显示，请从导航栏上的 Organizations 菜单中选择包含所需项目的组织。

  2. 如果尚未显示，请从导航栏的 Projects 菜单中选择您的项目。

  3. 在侧边栏中，单击 Database 标题下的 Clusters。

    此时会显示“集群”页面。

2

导航至集合

  1. 对于包含样本数据的集群，单击Browse Collections 。

  2. 在左侧导航窗格中，选择 sample_mflix 数据库。

  3. 选择 movies 集合。

3

指定筛选器字段

  1. 单击 More Options字段右侧的 。Filter

  2. 指定查询筛选器。

    在 Filter 字段中指定查询筛选器文档。查询筛选器文档使用查询运算符来指定搜索条件。

    将以下查询筛选器文档复制到 Filter 搜索栏：

    { year: 1924 }
4

指定要项目的字段

指定要在查询结果中返回的字段。

将以下项目文档复制到Project栏中：

{ title: 1, plot: 1 }
5

单击应用

此查询筛选器返回collection中字段与sample_mflix.movies year1924匹配的所有文档的以下字段：

  • _id

  • title

  • plot

MongoDB Atlas 默认返回_id字段。要省略_id字段，请将以下项目文档复制到Project栏中，然后单击Apply ：

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

其他注意事项

  • 当您使用$project聚合阶段时，它通常应该是管道中的最后一个阶段，用于指定要返回给客户端的字段。

    在管道的开头或中间使用 $project 阶段来减少传递到后续管道阶段的字段数量不太可能提高性能，因为数据库会自动执行此优化。

  • MongoDB 对投影执行额外的限制。有关详细信息，请参阅投影限制。

提示

后退
嵌入式文档数组
来年
Null 或缺失字段
给本页内容打分

在此页面上