Navigation

Project Fields to Return from Query

This page provides examples in:

    By default, queries in MongoDB return all fields in matching documents. To limit the amount of data that MongoDB sends to applications, you can include a projection document to specify or restrict fields to return.

    • Other

    This page provides examples of query operations with projection using the db.collection.find() method in the mongo shell. The examples on this page use the inventory collection. To populate the inventory collection, run the following:

    This page provides examples of query operations with projection using MongoDB Compass. The examples on this page use the inventory collection. Populate the inventory collection with the following documents:

    This page provides examples of query operations with projection using the pymongo.collection.Collection.find() method in the PyMongo Python driver. The examples on this page use the inventory collection. To populate the inventory collection, run the following:

    This page provides examples of query operations with projection using the com.mongodb.client.MongoCollection.find method in the MongoDB Java Synchronous Driver.

    Tip

    The driver provides com.mongodb.client.model.Filters helper methods to facilitate the creation of filter documents. The examples on this page use these methods to create the filter documents.

    The examples on this page use the inventory collection. To populate the inventory collection, run the following:

    This page provides examples of query operations with projection using the Collection.find() method in the MongoDB Node.js Driver. The examples on this page use the inventory collection. To populate the inventory collection, run the following:

    This page provides examples of query operations with projection using the MongoDB\Collection::find() method in the MongoDB PHP Library. The examples on this page use the inventory collection. To populate the inventory collection, run the following:

    This page provides examples of query operations with projection using the motor.motor_asyncio.AsyncIOMotorCollection.find() method in the Motor driver. The examples on this page use the inventory collection. To populate the inventory collection, run the following:

    This page provides examples of query operations with projection using the com.mongodb.reactivestreams.client.MongoCollection.find method in the MongoDB Java Reactive Streams Driver.

    The examples on this page use the inventory collection. To populate the inventory collection, run the following:

    This page provides examples of query operations with projection using the MongoCollection.Find() method in the MongoDB C# Driver. The examples on this page use the inventory collection. To populate the inventory collection, run the following:

    This page provides examples of query operations with projection using the MongoDB::Collection::find() method in the MongoDB Perl Driver. The examples on this page use the inventory collection. To populate the inventory collection, run the following:

    This page provides examples of query operations with projection using the Mongo::Collection#find() method in the MongoDB Ruby Driver. The examples on this page use the inventory collection. To populate the inventory collection, run the following:

    This page provides examples of query operations with projection using the collection.find() method in the MongoDB Scala Driver. The examples on this page use the inventory collection. To populate the inventory collection, run the following:

    This page provides examples of query operations with projection using the Collection.Find function in the MongoDB Go Driver. The examples on this page use the inventory collection. To populate the inventory collection, run the following:

    • Other
    copy 
    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 } ] }
]);

    You can run the operation in the web shell below:

    copy 
    [
  { 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 } ] }
]

    For instructions on inserting documents in MongoDB Compass, see Insert Documents.

    copy 
    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}]}])
    copy 
    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 } ] }")
));
    copy 
    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 }
    ]
  }
]);
    copy 
    $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],
        ],
    ],
]);
    copy 
    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}]}])
    copy 
    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 } ] }")
));
    copy 
    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);
    copy 
    $db->coll("inventory")->insert_many(
    [
        {
            item   => "journal",
            status => "A",
            size   => { h => 14, w => 21, uom => "cm" },
            instock => [ { warehouse => "A", qty => 5 } ]
        },
        {
            item   => "notebook",
            status => "A",
            size   => { h => 8.5, w => 11, uom => "in" },
            instock => [ { warehouse => "C", qty => 5 } ]
        },
        {
            item   => "paper",
            status => "D",
            size   => { h => 8.5, w => 11, uom => "in" },
            instock => [ { warehouse => "A", qty => 60 } ]
        },
        {
            item   => "planner",
            status => "D",
            size   => { h => 22.85, w => 30, uom => "cm" },
            instock => [ { warehouse => "A", qty => 40 } ]
        },
        {
            item    => "postcard",
            status  => "A",
            size    => { h => 10, w => 15.25, uom => "cm" },
            instock => [
                { warehouse => "B", qty => 15 },
                { warehouse => "C", qty => 35 }
            ]
        }
    ]
);
    copy 
    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 }] }])
    copy 
    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()
    copy 
    docs := []interface{}{
	bson.D{
		{"item", "journal"},
		{"status", "A"},
		{"size", bson.D{
			{"h", 14},
			{"w", 21},
			{"uom", "cm"},
		}},
		{"instock", bson.A{
			bson.D{
				{"warehouse", "A"},
				{"qty", 5},
			},
		}},
	},
	bson.D{
		{"item", "notebook"},
		{"status", "A"},
		{"size", bson.D{
			{"h", 8.5},
			{"w", 11},
			{"uom", "in"},
		}},
		{"instock", bson.A{
			bson.D{
				{"warehouse", "EC"},
				{"qty", 5},
			},
		}},
	},
	bson.D{
		{"item", "paper"},
		{"status", "D"},
		{"size", bson.D{
			{"h", 8.5},
			{"w", 11},
			{"uom", "in"},
		}},
		{"instock", bson.A{
			bson.D{
				{"warehouse", "A"},
				{"qty", 60},
			},
		}},
	},
	bson.D{
		{"item", "planner"},
		{"status", "D"},
		{"size", bson.D{
			{"h", 22.85},
			{"w", 30},
			{"uom", "cm"},
		}},
		{"instock", bson.A{
			bson.D{
				{"warehouse", "A"},
				{"qty", 40},
			},
		}},
	},
	bson.D{
		{"item", "postcard"},
		{"status", "A"},
		{"size", bson.D{
			{"h", 10},
			{"w", 15.25},
			{"uom", "cm"},
		}},
		{"instock", bson.A{
			bson.D{
				{"warehouse", "B"},
				{"qty", 15},
			},
			bson.D{
				{"warehouse", "EC"},
				{"qty", 35},
			},
		}},
	},
}

result, err := coll.InsertMany(context.Background(), docs)

    Return All Fields in Matching Documents

    • Other

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

    If you do not specify a projection document, Compass returns all fields in the matching documents.

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

    If you do not specify a projection, the com.mongodb.client.MongoCollection.find method returns all fields in the matching documents.

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

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

    If you do not specify a projection, the com.mongodb.reactivestreams.client.MongoCollection.find method returns all fields in the matching documents.

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

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

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

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

    The following example returns all fields from all documents in the inventory collection where the status equals "A":

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

    1. Copy the following expression into the Filter field:

      copy 
      { status: "A" }

    2. Click Find.

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

    The operation corresponds to the following SQL statement:

    copy 
    SELECT * from inventory WHERE status = "A"

    Return the Specified Fields and the _id Field Only

    A projection can explicitly include several fields by setting the <field> to 1 in the projection document. 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.

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

    1. Copy the following expression into the Filter field:

      copy 
      { status: "A" }

    2. Click Options to open the additional query options.

    3. Copy the following expression into the Project field:

      copy 
      { item: 1, status: 1 }

    4. Click Find.

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

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

    copy 
    findIterable = collection.find(eq("status", "A")).projection(include("item", "status"));
    copy 
    const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1 });
    copy 
    $cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1]]
);
    copy 
    cursor = db.inventory.find(
    {"status": "A"}, {"item": 1, "status": 1})
    copy 
    findPublisher = collection.find(eq("status", "A")).projection(include("item", "status"));
    copy 
    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();
    copy 
    $cursor = $db->coll("inventory")->find(
    { status => "A" }, { projection => { item => 1, status => 1 } }
);
    copy 
    client[:inventory].find({ status: 'A' },
                       projection: { item: 1, status: 1 })
    copy 
    findObservable = collection.find(equal("status", "A")).projection(include("item", "status"))
    copy 
    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:

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

    Suppress _id Field

    You can remove the _id field from the results by setting it to 0 in the projection, as in the following example:

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

    1. Copy the following expression into the Filter field:

      copy 
      { status: "A" }

    2. Click Options to open the additional query options.

    3. Copy the following expression into the Project field:

      copy 
      { item: 1, status: 1, _id: 0 }

    4. Click Find.

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

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

    copy 
    findIterable = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), excludeId()));
    copy 
    const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1, _id: 0 });
    copy 
    $cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1, '_id' => 0]]
);
    copy 
    cursor = db.inventory.find(
    {"status": "A"}, {"item": 1, "status": 1, "_id": 0})
    copy 
    findPublisher = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), excludeId()));
    copy 
    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();
    copy 
    $cursor = $db->coll("inventory")->find(
    { status => "A" }, { projection => { item => 1, status => 1, "_id" => 0 } }
);
    copy 
    client[:inventory].find({ status: 'A' },
                        projection: { item: 1, status: 1, _id: 0 })
    copy 
    findObservable = collection.find(equal("status", "A"))
  .projection(fields(include("item", "status"), excludeId()))
    copy 
    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:

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

    Note

    With the exception of the _id field, you cannot combine inclusion and exclusion statements in projection documents.

    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:

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

    1. Copy the following expression into the Filter field:

      copy 
      { status: "A" }

    2. Click Options to open the additional query options.

    3. Copy the following expression into the Project field:

      copy 
      { status: 0, instock: 0 }

    4. Click Find.

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

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

    copy 
    findIterable = collection.find(eq("status", "A")).projection(exclude("item", "status"));
    copy 
    const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ status: 0, instock: 0 });
    copy 
    $cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['status' => 0, 'instock' => 0]]
);
    copy 
    cursor = db.inventory.find(
    {"status": "A"}, {"status": 0, "instock": 0})
    copy 
    findPublisher = collection.find(eq("status", "A")).projection(exclude("item", "status"));
    copy 
    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();
    copy 
    $cursor = $db->coll("inventory")->find(
    { status => "A" }, { projection => { status => 0, instock => 0 } }
);
    copy 
    client[:inventory].find({ status: 'A' },
                        projection: { status: 0, instock: 0 })
    copy 
    findObservable = collection.find(equal("status", "A")).projection(exclude("item", "status"))
    copy 
    projection := bson.D{
	{"status", 0},
	{"instock", 0},
}

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

    Note

    With the exception of the _id field, you cannot combine inclusion and exclusion statements in projection documents.

    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.

    The following example returns:

    • The _id field (returned by default),
    • The item field,
    • The status field,
    • The uom field in the size document.

    The uom field remains embedded in the size document.

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

    1. Copy the following expression into the Filter field:

      copy 
      { status: "A" }

    2. Click Options to open the additional query options.

    3. Copy the following expression into the Project field:

      copy 
      { item: 1, status: 1, "size.uom": 1 }

    4. Click Find.

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

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

    copy 
    findIterable = collection.find(eq("status", "A")).projection(include("item", "status", "size.uom"));
    copy 
    const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1, 'size.uom': 1 });
    copy 
    $cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1, 'size.uom' => 1]]
);
    copy 
    cursor = db.inventory.find(
    {"status": "A"}, {"item": 1, "status": 1, "size.uom": 1})
    copy 
    findPublisher = collection.find(eq("status", "A")).projection(include("item", "status", "size.uom"));
    copy 
    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();
    copy 
    $cursor = $db->coll("inventory")->find(
    { status => "A" }, { projection => { item => 1, status => 1, "size.uom" => 1 } }
);
    copy 
    client[:inventory].find({ status: 'A' },
                        projection: { 'item' => 1, 'status' => 1, 'size.uom' => 1 })
    copy 
    findObservable = collection.find(equal("status", "A")).projection(include("item", "status", "size.uom"))
    copy 
    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 } }.

    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.

    The following example specifies a projection to exclude the uom field inside the size document. All other fields are returned in the matching documents:

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

    1. Copy the following expression into the Filter field:

      copy 
      { status: "A" }

    2. Click Options to open the additional query options.

    3. Copy the following expression into the Project field:

      copy 
      { "size.uom": 0 }

    4. Click Find.

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

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

    copy 
    findIterable = collection.find(eq("status", "A")).projection(exclude("size.uom"));
    copy 
    const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ 'size.uom': 0 });
    copy 
    $cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['size.uom' => 0]]
);
    copy 
    cursor = db.inventory.find({"status": "A"}, {"size.uom": 0})
    copy 
    findPublisher = collection.find(eq("status", "A")).projection(exclude("size.uom"));
    copy 
    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();
    copy 
    $cursor = $db->coll("inventory")->find(
    { status => "A" }, { projection => { "size.uom" => 0 } }
);
    copy 
    client[:inventory].find({ status: 'A' },
                        projection: { 'size.uom' => 0 })
    copy 
    findObservable = collection.find(equal("status", "A")).projection(exclude("size.uom"))
    copy 
    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 } }.

    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),
    • The item field,
    • The status field,
    • The qty field in the documents embedded in the instock array.
    • Other
    copy 
    db.inventory.find( { status: "A" }, { item: 1, status: 1, "instock.qty": 1 } )

    1. Copy the following expression into the Filter field:

      copy 
      { status: "A" }

    2. Click Options to open the additional query options.

    3. Copy the following expression into the Project field:

      copy 
      { item: 1, status: 1, "instock.qty": 1 }

    4. Click Find.

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

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

    copy 
    findIterable = collection.find(eq("status", "A")).projection(include("item", "status", "instock.qty"));
    copy 
    const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1, 'instock.qty': 1 });
    copy 
    $cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1, 'instock.qty' => 1]]
);
    copy 
    cursor = db.inventory.find(
    {"status": "A"}, {"item": 1, "status": 1, "instock.qty": 1})
    copy 
    findPublisher = collection.find(eq("status", "A")).projection(include("item", "status", "instock.qty"));
    copy 
    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();
    copy 
    $cursor = $db->coll("inventory")->find( { status => "A" },
    { projection => { item => 1, status => 1, "instock.qty" => 1 } } );
    copy 
    client[:inventory].find({ status: 'A' },
                        projection: {'item' => 1, 'status' => 1, 'instock.qty' => 1 })
    copy 
    findObservable = collection.find(equal("status", "A")).projection(include("item", "status", "instock.qty"))
    copy 
    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

    • Other

    For fields that contain arrays, MongoDB provides the following projection operators for manipulating arrays: $elemMatch, $slice, and $.

    The following example uses the $slice projection operator to return the last element in the instock array:

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

    1. Copy the following expression into the Filter field:

      copy 
      { status: "A" }

    2. Click Options to open the additional query options.

    3. Copy the following expression into the Project field:

      copy 
      { item: 1, status: 1, instock: { $slice: -1 } }

    4. Click Find.

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

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

    copy 
    findIterable = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));
    copy 
    const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1, instock: { $slice: -1 } });
    copy 
    $cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]]
);
    copy 
    cursor = db.inventory.find(
    {"status": "A"},
    {"item": 1, "status": 1, "instock": {"$slice": -1}})
    copy 
    findPublisher = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));
    copy 
    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();
    copy 
    $cursor = $db->coll("inventory")->find(
    { status => "A" },
    { projection => { item => 1, status => 1, instock => { '$slice' => -1 } } }
);
    copy 
    client[:inventory].find({ status: 'A' },
                        projection: {'item' => 1,
                                     'status' => 1,
                                     'instock' => { '$slice' => -1 } })
    copy 
    findObservable = collection.find(equal("status", "A"))
  .projection(fields(include("item", "status"), slice("instock", -1)))
    copy 
    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),
)

    $elemMatch, $slice, and $ are the only way to project specific elements to include in the returned array. For instance, you cannot project specific array elements using the array index; e.g. { "instock.0": 1 } projection will not project the array with the first element.

    For fields that contain arrays, MongoDB provides the following projection operators for manipulating arrays: $elemMatch, $slice, and $.

    The following example uses the $slice projection operator to return the last element in the instock array:

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

    1. Copy the following expression into the Filter field:

      copy 
      { status: "A" }

    2. Click Options to open the additional query options.

    3. Copy the following expression into the Project field:

      copy 
      { item: 1, status: 1, instock: { $slice: -1 } }

    4. Click Find.

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

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

    copy 
    findIterable = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));
    copy 
    const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1, instock: { $slice: -1 } });
    copy 
    $cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]]
);
    copy 
    cursor = db.inventory.find(
    {"status": "A"},
    {"item": 1, "status": 1, "instock": {"$slice": -1}})
    copy 
    findPublisher = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));
    copy 
    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();
    copy 
    $cursor = $db->coll("inventory")->find(
    { status => "A" },
    { projection => { item => 1, status => 1, instock => { '$slice' => -1 } } }
);
    copy 
    client[:inventory].find({ status: 'A' },
                        projection: {'item' => 1,
                                     'status' => 1,
                                     'instock' => { '$slice' => -1 } })
    copy 
    findObservable = collection.find(equal("status", "A"))
  .projection(fields(include("item", "status"), slice("instock", -1)))
    copy 
    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),
)

    For fields that contain arrays, MongoDB provides the following projection operators for manipulating arrays: $elemMatch, $slice, and $.

    The following example uses the $slice projection operator to return the last element in the instock array:

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

    1. Copy the following expression into the Filter field:

      copy 
      { status: "A" }

    2. Click Options to open the additional query options.

    3. Copy the following expression into the Project field:

      copy 
      { item: 1, status: 1, instock: { $slice: -1 } }

    4. Click Find.

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

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

    copy 
    findIterable = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));
    copy 
    const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1, instock: { $slice: -1 } });
    copy 
    $cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]]
);
    copy 
    cursor = db.inventory.find(
    {"status": "A"},
    {"item": 1, "status": 1, "instock": {"$slice": -1}})
    copy 
    findPublisher = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));
    copy 
    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();
    copy 
    $cursor = $db->coll("inventory")->find(
    { status => "A" },
    { projection => { item => 1, status => 1, instock => { '$slice' => -1 } } }
);
    copy 
    client[:inventory].find({ status: 'A' },
                        projection: {'item' => 1,
                                     'status' => 1,
                                     'instock' => { '$slice' => -1 } })
    copy 
    findObservable = collection.find(equal("status", "A"))
  .projection(fields(include("item", "status"), slice("instock", -1)))
    copy 
    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),
)

    $elemMatch, $slice, and $ are the only way to project specific elements to include in the returned array. For instance, you cannot project specific array elements using the array index; e.g. { "instock.0": 1 } projection will not project the array with the first element.

    For fields that contain arrays, MongoDB provides the following projection operators for manipulating arrays: $elemMatch, $slice, and $.

    The following example uses the $slice projection operator to return the last element in the instock array:

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

    1. Copy the following expression into the Filter field:

      copy 
      { status: "A" }

    2. Click Options to open the additional query options.

    3. Copy the following expression into the Project field:

      copy 
      { item: 1, status: 1, instock: { $slice: -1 } }

    4. Click Find.

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

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

    copy 
    findIterable = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));
    copy 
    const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1, instock: { $slice: -1 } });
    copy 
    $cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]]
);
    copy 
    cursor = db.inventory.find(
    {"status": "A"},
    {"item": 1, "status": 1, "instock": {"$slice": -1}})
    copy 
    findPublisher = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));
    copy 
    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();
    copy 
    $cursor = $db->coll("inventory")->find(
    { status => "A" },
    { projection => { item => 1, status => 1, instock => { '$slice' => -1 } } }
);
    copy 
    client[:inventory].find({ status: 'A' },
                        projection: {'item' => 1,
                                     'status' => 1,
                                     'instock' => { '$slice' => -1 } })
    copy 
    findObservable = collection.find(equal("status", "A"))
  .projection(fields(include("item", "status"), slice("instock", -1)))
    copy 
    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),
)

    $elemMatch, $slice, and $ are the only way to project specific elements to include in the returned array. For instance, you cannot project specific array elements using the array index; e.g. include("instock.0") projection will not project the array with the first element.

    For fields that contain arrays, MongoDB provides the following projection operators for manipulating arrays: $elemMatch, $slice, and $.

    The following example uses the $slice projection operator to return the last element in the instock array:

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

    1. Copy the following expression into the Filter field:

      copy 
      { status: "A" }

    2. Click Options to open the additional query options.

    3. Copy the following expression into the Project field:

      copy 
      { item: 1, status: 1, instock: { $slice: -1 } }

    4. Click Find.

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

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

    copy 
    findIterable = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));
    copy 
    const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1, instock: { $slice: -1 } });
    copy 
    $cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]]
);
    copy 
    cursor = db.inventory.find(
    {"status": "A"},
    {"item": 1, "status": 1, "instock": {"$slice": -1}})
    copy 
    findPublisher = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));
    copy 
    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();
    copy 
    $cursor = $db->coll("inventory")->find(
    { status => "A" },
    { projection => { item => 1, status => 1, instock => { '$slice' => -1 } } }
);
    copy 
    client[:inventory].find({ status: 'A' },
                        projection: {'item' => 1,
                                     'status' => 1,
                                     'instock' => { '$slice' => -1 } })
    copy 
    findObservable = collection.find(equal("status", "A"))
  .projection(fields(include("item", "status"), slice("instock", -1)))
    copy 
    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),
)

    $elemMatch, $slice, and $ are the only way to project specific elements to include in the returned array. For instance, you cannot project specific array elements using the array index; e.g. { "instock.0": 1 } projection will not project the array with the first element.

    For fields that contain arrays, MongoDB provides the following projection operators for manipulating arrays: $elemMatch, $slice, and $.

    The following example uses the $slice projection operator to return the last element in the instock array:

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

    1. Copy the following expression into the Filter field:

      copy 
      { status: "A" }

    2. Click Options to open the additional query options.

    3. Copy the following expression into the Project field:

      copy 
      { item: 1, status: 1, instock: { $slice: -1 } }

    4. Click Find.

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

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

    copy 
    findIterable = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));
    copy 
    const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1, instock: { $slice: -1 } });
    copy 
    $cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]]
);
    copy 
    cursor = db.inventory.find(
    {"status": "A"},
    {"item": 1, "status": 1, "instock": {"$slice": -1}})
    copy 
    findPublisher = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));
    copy 
    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();
    copy 
    $cursor = $db->coll("inventory")->find(
    { status => "A" },
    { projection => { item => 1, status => 1, instock => { '$slice' => -1 } } }
);
    copy 
    client[:inventory].find({ status: 'A' },
                        projection: {'item' => 1,
                                     'status' => 1,
                                     'instock' => { '$slice' => -1 } })
    copy 
    findObservable = collection.find(equal("status", "A"))
  .projection(fields(include("item", "status"), slice("instock", -1)))
    copy 
    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),
)

    $elemMatch, $slice, and $ are the only way to project specific elements to include in the returned array. For instance, you cannot project specific array elements using the array index; e.g. [ "instock.0" => 1 ] projection will not project the array with the first element.

    For fields that contain arrays, MongoDB provides the following projection operators for manipulating arrays: $elemMatch, $slice, and $.

    The following example uses the $slice projection operator to return the last element in the instock array:

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

    1. Copy the following expression into the Filter field:

      copy 
      { status: "A" }

    2. Click Options to open the additional query options.

    3. Copy the following expression into the Project field:

      copy 
      { item: 1, status: 1, instock: { $slice: -1 } }

    4. Click Find.

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

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

    copy 
    findIterable = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));
    copy 
    const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1, instock: { $slice: -1 } });
    copy 
    $cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]]
);
    copy 
    cursor = db.inventory.find(
    {"status": "A"},
    {"item": 1, "status": 1, "instock": {"$slice": -1}})
    copy 
    findPublisher = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));
    copy 
    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();
    copy 
    $cursor = $db->coll("inventory")->find(
    { status => "A" },
    { projection => { item => 1, status => 1, instock => { '$slice' => -1 } } }
);
    copy 
    client[:inventory].find({ status: 'A' },
                        projection: {'item' => 1,
                                     'status' => 1,
                                     'instock' => { '$slice' => -1 } })
    copy 
    findObservable = collection.find(equal("status", "A"))
  .projection(fields(include("item", "status"), slice("instock", -1)))
    copy 
    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),
)

    $elemMatch, $slice, and $ are the only way to project specific elements to include in the returned array. For instance, you cannot project specific array elements using the array index; e.g. include("instock.0") projection will not project the array with the first element.

    For fields that contain arrays, MongoDB provides the following projection operators for manipulating arrays: $elemMatch, $slice, and $.

    The following example uses the $slice projection operator to return the last element in the instock array:

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

    1. Copy the following expression into the Filter field:

      copy 
      { status: "A" }

    2. Click Options to open the additional query options.

    3. Copy the following expression into the Project field:

      copy 
      { item: 1, status: 1, instock: { $slice: -1 } }

    4. Click Find.

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

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

    copy 
    findIterable = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));
    copy 
    const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1, instock: { $slice: -1 } });
    copy 
    $cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]]
);
    copy 
    cursor = db.inventory.find(
    {"status": "A"},
    {"item": 1, "status": 1, "instock": {"$slice": -1}})
    copy 
    findPublisher = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));
    copy 
    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();
    copy 
    $cursor = $db->coll("inventory")->find(
    { status => "A" },
    { projection => { item => 1, status => 1, instock => { '$slice' => -1 } } }
);
    copy 
    client[:inventory].find({ status: 'A' },
                        projection: {'item' => 1,
                                     'status' => 1,
                                     'instock' => { '$slice' => -1 } })
    copy 
    findObservable = collection.find(equal("status", "A"))
  .projection(fields(include("item", "status"), slice("instock", -1)))
    copy 
    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),
)

    $elemMatch, $slice, and $ are the only way to project specific elements to include in the returned array.

    For example, the following operation will not project the array with the first element:

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

    For fields that contain arrays, MongoDB provides the following projection operators for manipulating arrays: $elemMatch, $slice, and $.

    The following example uses the $slice projection operator to return the last element in the instock array:

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

    1. Copy the following expression into the Filter field:

      copy 
      { status: "A" }

    2. Click Options to open the additional query options.

    3. Copy the following expression into the Project field:

      copy 
      { item: 1, status: 1, instock: { $slice: -1 } }

    4. Click Find.

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

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

    copy 
    findIterable = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));
    copy 
    const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1, instock: { $slice: -1 } });
    copy 
    $cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]]
);
    copy 
    cursor = db.inventory.find(
    {"status": "A"},
    {"item": 1, "status": 1, "instock": {"$slice": -1}})
    copy 
    findPublisher = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));
    copy 
    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();
    copy 
    $cursor = $db->coll("inventory")->find(
    { status => "A" },
    { projection => { item => 1, status => 1, instock => { '$slice' => -1 } } }
);
    copy 
    client[:inventory].find({ status: 'A' },
                        projection: {'item' => 1,
                                     'status' => 1,
                                     'instock' => { '$slice' => -1 } })
    copy 
    findObservable = collection.find(equal("status", "A"))
  .projection(fields(include("item", "status"), slice("instock", -1)))
    copy 
    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),
)

    $elemMatch, $slice, and $ are the only way to project specific elements to include in the returned array. For instance, you cannot project specific array elements using the array index; e.g. { "instock.0" => 1 } projection will not project the array with the first element.

    For fields that contain arrays, MongoDB provides the following projection operators for manipulating arrays: $elemMatch, $slice, and $.

    The following example uses the $slice projection operator to return the last element in the instock array:

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

    1. Copy the following expression into the Filter field:

      copy 
      { status: "A" }

    2. Click Options to open the additional query options.

    3. Copy the following expression into the Project field:

      copy 
      { item: 1, status: 1, instock: { $slice: -1 } }

    4. Click Find.

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

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

    copy 
    findIterable = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));
    copy 
    const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1, instock: { $slice: -1 } });
    copy 
    $cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]]
);
    copy 
    cursor = db.inventory.find(
    {"status": "A"},
    {"item": 1, "status": 1, "instock": {"$slice": -1}})
    copy 
    findPublisher = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));
    copy 
    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();
    copy 
    $cursor = $db->coll("inventory")->find(
    { status => "A" },
    { projection => { item => 1, status => 1, instock => { '$slice' => -1 } } }
);
    copy 
    client[:inventory].find({ status: 'A' },
                        projection: {'item' => 1,
                                     'status' => 1,
                                     'instock' => { '$slice' => -1 } })
    copy 
    findObservable = collection.find(equal("status", "A"))
  .projection(fields(include("item", "status"), slice("instock", -1)))
    copy 
    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),
)

    $elemMatch, $slice, and $ are the only way to project specific elements to include in the returned array. For instance, you cannot project specific array elements using the array index; e.g. { "instock.0" => 1 } projection will not project the array with the first element.

    For fields that contain arrays, MongoDB provides the following projection operators for manipulating arrays: $elemMatch, $slice, and $.

    The following example uses the $slice projection operator to return the last element in the instock array:

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

    1. Copy the following expression into the Filter field:

      copy 
      { status: "A" }

    2. Click Options to open the additional query options.

    3. Copy the following expression into the Project field:

      copy 
      { item: 1, status: 1, instock: { $slice: -1 } }

    4. Click Find.

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

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

    copy 
    findIterable = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));
    copy 
    const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1, instock: { $slice: -1 } });
    copy 
    $cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]]
);
    copy 
    cursor = db.inventory.find(
    {"status": "A"},
    {"item": 1, "status": 1, "instock": {"$slice": -1}})
    copy 
    findPublisher = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));
    copy 
    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();
    copy 
    $cursor = $db->coll("inventory")->find(
    { status => "A" },
    { projection => { item => 1, status => 1, instock => { '$slice' => -1 } } }
);
    copy 
    client[:inventory].find({ status: 'A' },
                        projection: {'item' => 1,
                                     'status' => 1,
                                     'instock' => { '$slice' => -1 } })
    copy 
    findObservable = collection.find(equal("status", "A"))
  .projection(fields(include("item", "status"), slice("instock", -1)))
    copy 
    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),
)

    $elemMatch, $slice, and $ are the only way to project specific elements to include in the returned array. For instance, you cannot project specific array elements using the array index; e.g. include("instock.0") projection will not project the array with the first element.

    For fields that contain arrays, MongoDB provides the following projection operators for manipulating arrays: $elemMatch, $slice, and $.

    The following example uses the $slice projection operator to return the last element in the instock array:

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

    1. Copy the following expression into the Filter field:

      copy 
      { status: "A" }

    2. Click Options to open the additional query options.

    3. Copy the following expression into the Project field:

      copy 
      { item: 1, status: 1, instock: { $slice: -1 } }

    4. Click Find.

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

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

    copy 
    findIterable = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));
    copy 
    const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1, instock: { $slice: -1 } });
    copy 
    $cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]]
);
    copy 
    cursor = db.inventory.find(
    {"status": "A"},
    {"item": 1, "status": 1, "instock": {"$slice": -1}})
    copy 
    findPublisher = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));
    copy 
    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();
    copy 
    $cursor = $db->coll("inventory")->find(
    { status => "A" },
    { projection => { item => 1, status => 1, instock => { '$slice' => -1 } } }
);
    copy 
    client[:inventory].find({ status: 'A' },
                        projection: {'item' => 1,
                                     'status' => 1,
                                     'instock' => { '$slice' => -1 } })
    copy 
    findObservable = collection.find(equal("status", "A"))
  .projection(fields(include("item", "status"), slice("instock", -1)))
    copy 
    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),
)

    $elemMatch, $slice, and $ are the only way to project specific elements to include in the returned array. For instance, you cannot project specific array elements using the array index; e.g. include("instock.0") projection will not project the array with the first element.

    Additional Considerations

    Starting in MongoDB 4.4, MongoDB enforces additional restrictions with regards to projections. See Projection Restrictions for details.

    See also

    © MongoDB, Inc 2008-present. MongoDB, Mongo, and the leaf logo are registered trademarks of MongoDB, Inc.