Project Fields to Return from Query要从查询返回的项目字段¶

Return All Fields in Matching Documents返回匹配文档中的所有字段¶

The following example returns all fields from all documents in the inventory collection where the status equals "A":以下示例返回inventory集合中status为"A"的所有文档中的所有字段：

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

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

FindIterable<Document> findIterable = collection.find(eq("status", "A"));

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

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

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

FindPublisher<Document> findPublisher = collection.find(eq("status", "A"));

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

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

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

var findObservable = collection.find(equal("status", "A"))

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

The operation corresponds to the following SQL statement:该操作对应于以下SQL语句：

SELECT * from inventory WHERE status = "A"

Return the Specified Fields and the _id Field Only仅返回指定字段和_id字段¶

A projection can explicitly include several fields by setting the <field> to 1 in the projection document. 通过在投影文档中将<field>设置为1，投影可以显式包含若干个字段。The following operation returns all documents that match the query. 以下操作返回与查询匹配的所有文档。In the result set, only the item, status and, by default, the _id fields return in the matching documents.在结果集中，匹配文档中仅返回item、status以及默认情况下的_id字段。

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

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

findIterable = collection.find(eq("status", "A")).projection(include("item", "status"));

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

findPublisher = collection.find(eq("status", "A")).projection(include("item", "status"));

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

$cursor = $db->coll("inventory")->find(
    { status => "A" }, { projection => { item => 1, status => 1 } }
);

client[:inventory].find({ status: 'A' },
                       projection: { item: 1, status: 1 })

findObservable = collection.find(equal("status", "A")).projection(include("item", "status"))

projection := bson.D{
	{"item", 1},
	{"status", 1},
}

cursor, err := coll.Find(
	context.Background(),
	bson.D{
		{"status", "A"},
	},
	options.Find().SetProjection(projection),
)

The operation corresponds to the following SQL statement:该操作对应于以下SQL语句：

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

Suppress _id Field抑制_id字段¶

You can remove the _id field from the results by setting it to 0 in the projection, as in the following example:通过在投影中将_id字段设置为0，可以从结果中删除该字段，如下例所示：

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

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

findIterable = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), excludeId()));

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

findPublisher = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), excludeId()));

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

$cursor = $db->coll("inventory")->find(
    { status => "A" }, { projection => { 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()))

projection := bson.D{
	{"item", 1},
	{"status", 1},
	{"_id", 0},
}

cursor, err := coll.Find(
	context.Background(),
	bson.D{
		{"status", "A"},
	},
	options.Find().SetProjection(projection),
)

The operation corresponds to the following SQL statement:该操作对应于以下SQL语句：

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

Return All But the Excluded Fields返回除排除字段外的所有字段¶

Instead of listing the fields to return in the matching document, you can use a projection to exclude specific fields. 您可以使用投影排除特定字段，而不是在匹配文档中列出要返回的字段。The following example which returns all fields except for the status and the instock fields in the matching documents:以下示例返回匹配文档中除status和instock字段外的所有字段：

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

cursor = db.inventory.find(
    {"status": "A"}, {"status": 0, "instock": 0})

findIterable = collection.find(eq("status", "A")).projection(exclude("item", "status"));

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

findPublisher = collection.find(eq("status", "A")).projection(exclude("item", "status"));

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

$cursor = $db->coll("inventory")->find(
    { status => "A" }, { projection => { status => 0, instock => 0 } }
);

client[:inventory].find({ status: 'A' },
                        projection: { status: 0, instock: 0 })

findObservable = collection.find(equal("status", "A")).projection(exclude("item", "status"))

projection := bson.D{
	{"status", 0},
	{"instock", 0},
}

cursor, err := coll.Find(
	context.Background(),
	bson.D{
		{"status", "A"},
	},
	options.Find().SetProjection(projection),
)

Return Specific Fields in Embedded Documents返回嵌入文档中的特定字段¶

You can return specific fields in an embedded document. 可以在嵌入文档中返回特定字段。Use the dot notation to refer to the embedded field and set to 1 in the projection document.使用点表示法引用嵌入字段，并在投影文档中设置为1。

The following example returns:以下示例返回：

• The _id field (returned by default),_id字段（默认情况下返回），
• The item field,item字段，
• The status field,status字段，
• The uom field in the size document.size文档中的uom字段。

The uom field remains embedded in the size document.uom字段仍嵌入在size文档中。

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

cursor = db.inventory.find(
    {"status": "A"}, {"item": 1, "status": 1, "size.uom": 1})

findIterable = collection.find(eq("status", "A")).projection(include("item", "status", "size.uom"));

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

findPublisher = collection.find(eq("status", "A")).projection(include("item", "status", "size.uom"));

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

$cursor = $db->coll("inventory")->find(
    { status => "A" }, { projection => { 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"))

projection := bson.D{
	{"item", 1},
	{"status", 1},
	{"size.uom", 1},
}

cursor, err := coll.Find(
	context.Background(),
	bson.D{
		{"status", "A"},
	},
	options.Find().SetProjection(projection),
)

Starting in MongoDB 4.4, you can also specify embedded fields using the nested form, e.g. { item: 1, status: 1, size: { uom: 1 } }.从MongoDB 4.4开始，还可以使用嵌套形式指定嵌入字段，例如{ item: 1, status: 1, size: { uom: 1 } }。

Suppress Specific Fields in Embedded Documents抑制嵌入文档中的特定字段¶

You can suppress specific fields in an embedded document. 可以抑制嵌入文档中的特定字段。Use the dot notation to refer to the embedded field in the projection document and set to 0.使用点表示法引用投影文档中的嵌入字段，并设置为0。

The following example specifies a projection to exclude the uom field inside the size document. 以下示例指定一个投影，以排除size文档中的uom字段。All other fields are returned in the matching documents:所有其他字段将在匹配文档中返回：

db.inventory.find(
   { status: "A" },
   { "size.uom": 0 }
)

cursor = db.inventory.find({"status": "A"}, {"size.uom": 0})

findIterable = collection.find(eq("status", "A")).projection(exclude("size.uom"));

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

findPublisher = collection.find(eq("status", "A")).projection(exclude("size.uom"));

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

$cursor = $db->coll("inventory")->find(
    { status => "A" }, { projection => { "size.uom" => 0 } }
);

client[:inventory].find({ status: 'A' },
                        projection: { 'size.uom' => 0 })

findObservable = collection.find(equal("status", "A")).projection(exclude("size.uom"))

projection := bson.D{
	{"size.uom", 0},
}

cursor, err := coll.Find(
	context.Background(),
	bson.D{
		{"status", "A"},
	},
	options.Find().SetProjection(projection),
)

Starting in MongoDB 4.4, you can also specify embedded fields using the nested form, e.g. { size: { uom: 0 } }.从MongoDB 4.4开始，还可以使用嵌套形式指定嵌入字段，例如{ item: 1, status: 1, size: { uom: 1 } }。

Projection on Embedded Documents in an Array数组中嵌入文档的投影¶

Use dot notation to project specific fields inside documents embedded in an array.使用点表示法在嵌入数组的文档中投影特定字段。

The following example specifies a projection to return:以下示例指定要返回的投影：

• The _id field (returned by default),_id字段（默认情况下返回），
• The item field,item字段，
• The status field,status字段
• The qty field in the documents embedded in the instock array.instock数组中嵌入的文档中的qty字段。

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

cursor = db.inventory.find(
    {"status": "A"}, {"item": 1, "status": 1, "instock.qty": 1})

findIterable = collection.find(eq("status", "A")).projection(include("item", "status", "instock.qty"));

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

findPublisher = collection.find(eq("status", "A")).projection(include("item", "status", "instock.qty"));

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

$cursor = $db->coll("inventory")->find( { status => "A" },
    { projection => { 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"))

projection := bson.D{
	{"item", 1},
	{"status", 1},
	{"instock.qty", 1},
}

cursor, err := coll.Find(
	context.Background(),
	bson.D{
		{"status", "A"},
	},
	options.Find().SetProjection(projection),
)

Project Specific Array Elements in the Returned Array返回数组中特定于项目的数组元素¶

db.inventory.find( { status: "A" }, { item: 1, status: 1, instock: { $slice: -1 } } )

cursor = db.inventory.find(
    {"status": "A"},
    {"item": 1, "status": 1, "instock": {"$slice": -1}})

findIterable = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -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}})

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

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

$cursor = $db->coll("inventory")->find(
    { status => "A" },
    { projection => { 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)))

projection := bson.D{
	{"item", 1},
	{"status", 1},
	{"instock", bson.D{
		{"$slice", -1},
	}},
}

cursor, err := coll.Find(
	context.Background(),
	bson.D{
		{"status", "A"},
	},
	options.Find().SetProjection(projection),
)

db.inventory.find( { status: "A" }, { item: 1, status: 1, instock: { $slice: -1 } } )

cursor = db.inventory.find(
    {"status": "A"},
    {"item": 1, "status": 1, "instock": {"$slice": -1}})

findIterable = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -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}})

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

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

$cursor = $db->coll("inventory")->find(
    { status => "A" },
    { projection => { 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)))

projection := bson.D{
	{"item", 1},
	{"status", 1},
	{"instock", bson.D{
		{"$slice", -1},
	}},
}

cursor, err := coll.Find(
	context.Background(),
	bson.D{
		{"status", "A"},
	},
	options.Find().SetProjection(projection),
)

db.inventory.find( { status: "A" }, { item: 1, status: 1, instock: { $slice: -1 } } )

cursor = db.inventory.find(
    {"status": "A"},
    {"item": 1, "status": 1, "instock": {"$slice": -1}})

findIterable = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -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}})

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

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