Menu Docs

Página inicial do Docs

/

Manual do MongoDB

/

Operações CRUD

/

Campos do projeto para retornar da consulta

Nesta página

Retorno de todos os campos em documentos correspondentes

Retorno somente dos campos especificados e do campo _id
Supressão do campo _id
Retorno de todos os campos, exceto os excluídos
Retorno de campos específicos de documentos incorporados
Supressão de campos específicos em documentos incorporados
Projeção em documentos incorporados em uma array
Elementos de array específicos do projeto na array retornada
Projetar campos com expressões de aggregation
Campos do projeto para retornar de uma query com o MongoDB Atlas
Considerações adicionais

Você pode consultar documentos incorporados no MongoDB com os métodos:

O driver da sua linguagem de programação.
A UI do MongoDB Atlas. Para saber mais, consulte Campos do projeto para retornar de uma query com o MongoDB Atlas.
MongoDB Compass.

➤ Use o menu suspenso Selecione a linguagem no canto superior direito para definir a linguagem dos exemplos a seguir ou selecione MongoDB Compass.

Por padrão, as queries no MongoDB retornam todos os campos em documentos correspondentes. Para limitar a quantidade de dados que o MongoDB envia aos aplicativos, você pode incluir um documento de projeção para especificar ou restringir os campos a serem retornados.

Esta página fornece exemplos de operações de query com projeção usando o método db.collection.find() em mongosh.

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página fornece exemplos de operações de query com projeção usando o MongoDB Compass.

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página fornece exemplos de operações de query com projeção usando mongoc_collection_find_with_opts.

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página fornece exemplos de operações de query com projeção usando o método MongoCollection.Find() no driver C# do MongoDB.

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página fornece exemplos de operações de query com projeção usando a função Collection.Find no Driver Go do MongoDB.

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página fornece exemplos de operações de query com projeção usando o com.mongodb.reactivestreams. cliente.MongoCollection.find no MongoDB Java Reactive Streams Driver.

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página fornece exemplos de operações de query com projeção usando o método com.mongodb.client.MongoCollection.find no Driver Java síncrono do MongoDB.

Dica

O driver fornece os métodos auxiliares com.mongodb.client.model.Filters para facilitar a criação de documentos de filtro. Os exemplos nesta página usam esses métodos para criar os documentos de filtro.

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página fornece exemplos de query de consulta com projeção usando o método MongoCollection.find() no MongoDB Kotlin Coroutine Driver.

Dica

O driver fornece os métodos auxiliares com.mongodb.client.model.Filters para facilitar a criação de documentos de filtro. Os exemplos nesta página usam esses métodos para criar os documentos de filtro.

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página fornece exemplos de operações de query com projeção usando o método motor.motor_asyncio.AsyncIOMotorCollection.find no driver Motor.

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página fornece exemplos de operações de consulta com projeção usando o método Collection.find() no Driver Node.js do MongoDB.

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página fornece exemplos de operações de query com projeção usando o método MongoDB::Collection::find() no Driver Perl do MongoDB.

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página fornece exemplos de operações de query com projeção usando o método MongoDB\\Collection::find() na biblioteca PHP do MongoDB.

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página fornece exemplos de operações de consulta com projeção usando o método pymongo.collection.Collection.find no driver PyMongo Python.

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página fornece exemplos de operações de query com projeção usando o método Mongo::Collection#find() no MongoDB Ruby Driver.

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página fornece exemplos de operações de query com projeção usando o método collection.find() no MongoDB Scala Driver.

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção 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 } ] }
]

Para obter instruções sobre como inserir documentos no MongoDB Compass, consulte Insira documentos.

mongoc_collection_t *collection;
mongoc_bulk_operation_t *bulk;
bson_t *doc;
bool r;
bson_error_t error;
bson_t reply;
collection = mongoc_database_get_collection (db, "inventory");
bulk = mongoc_collection_create_bulk_operation_with_opts (collection, NULL);
doc = BCON_NEW (
   "item", BCON_UTF8 ("journal"),
   "status", BCON_UTF8 ("A"),
   "size", "{",
   "h", BCON_DOUBLE (14),
   "w", BCON_DOUBLE (21),
   "uom", BCON_UTF8 ("cm"),
   "}",
   "instock", "[",
   "{",
   "warehouse", BCON_UTF8 ("A"),
   "qty", BCON_INT64 (5),
   "}",
   "]");
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("notebook"),
   "status", BCON_UTF8 ("A"),
   "size", "{",
   "h", BCON_DOUBLE (8.5),
   "w", BCON_DOUBLE (11),
   "uom", BCON_UTF8 ("in"),
   "}",
   "instock", "[",
   "{",
   "warehouse", BCON_UTF8 ("C"),
   "qty", BCON_INT64 (5),
   "}",
   "]");
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("paper"),
   "status", BCON_UTF8 ("D"),
   "size", "{",
   "h", BCON_DOUBLE (8.5),
   "w", BCON_DOUBLE (11),
   "uom", BCON_UTF8 ("in"),
   "}",
   "instock", "[",
   "{",
   "warehouse", BCON_UTF8 ("A"),
   "qty", BCON_INT64 (60),
   "}",
   "]");
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("planner"),
   "status", BCON_UTF8 ("D"),
   "size", "{",
   "h", BCON_DOUBLE (22.85),
   "w", BCON_DOUBLE (30),
   "uom", BCON_UTF8 ("cm"),
   "}",
   "instock", "[",
   "{",
   "warehouse", BCON_UTF8 ("A"),
   "qty", BCON_INT64 (40),
   "}",
   "]");
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("postcard"),
   "status", BCON_UTF8 ("A"),
   "size", "{",
   "h", BCON_DOUBLE (10),
   "w", BCON_DOUBLE (15.25),
   "uom", BCON_UTF8 ("cm"),
   "}",
   "instock", "[",
   "{",
   "warehouse", BCON_UTF8 ("B"),
   "qty", BCON_INT64 (15),
   "}","{",
   "warehouse", BCON_UTF8 ("C"),
   "qty", BCON_INT64 (35),
   "}",
   "]");
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
/* "reply" is initialized on success or error */
r = (bool) mongoc_bulk_operation_execute (bulk, &reply, &error);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
}

var documents = new[]
{
    new BsonDocument
    {
        { "item", "journal" },
        { "status", "A" },
        { "size", new BsonDocument { { "h", 14 }, { "w", 21 }, { "uom", "cm" } } },
        { "instock", new BsonArray
            {
                new BsonDocument { { "warehouse", "A" }, { "qty", 5 } } }
            }
    },
    new BsonDocument
    {
        { "item", "notebook" },
        { "status", "A" },
        { "size", new BsonDocument { { "h", 8.5 }, { "w", 11 }, { "uom", "in" } } },
        { "instock", new BsonArray
            {
                new BsonDocument { { "warehouse", "C" }, { "qty", 5 } } }
            }
    },
    new BsonDocument
    {
        { "item", "paper" },
        { "status", "D" },
        { "size", new BsonDocument { { "h", 8.5 }, { "w", 11 }, { "uom", "in" } } },
        { "instock", new BsonArray
            {
                new BsonDocument { { "warehouse", "A" }, { "qty", 60 } } }
            }
    },
    new BsonDocument
    {
        { "item", "planner" },
        { "status", "D" },
        { "size", new BsonDocument { { "h", 22.85 }, { "w", 30 }, { "uom", "cm" } } },
        { "instock", new BsonArray
            {
                new BsonDocument { { "warehouse", "A" }, { "qty", 40 } } }
            }
    },
    new BsonDocument
    {
        { "item", "postcard" },
        { "status", "A" },
        { "size", new BsonDocument { { "h", 10 }, { "w", 15.25 }, { "uom", "cm" } } },
        { "instock", new BsonArray
            {
                new BsonDocument { { "warehouse", "B" }, { "qty", 15 } },
                new BsonDocument { { "warehouse", "C" }, { "qty", 35 } } }
            }
    }
};
collection.InsertMany(documents);

docs := []interface{}{
	bson.D{
		{"item", "journal"},
		{"status", "A"},
		{"size", bson.D{
			{"h", 14},
			{"w", 21},
			{"uom", "cm"},
		}},
		{"instock", bson.A{
			bson.D{
				{"warehouse", "A"},
				{"qty", 5},
			},
		}},
	},
	bson.D{
		{"item", "notebook"},
		{"status", "A"},
		{"size", bson.D{
			{"h", 8.5},
			{"w", 11},
			{"uom", "in"},
		}},
		{"instock", bson.A{
			bson.D{
				{"warehouse", "EC"},
				{"qty", 5},
			},
		}},
	},
	bson.D{
		{"item", "paper"},
		{"status", "D"},
		{"size", bson.D{
			{"h", 8.5},
			{"w", 11},
			{"uom", "in"},
		}},
		{"instock", bson.A{
			bson.D{
				{"warehouse", "A"},
				{"qty", 60},
			},
		}},
	},
	bson.D{
		{"item", "planner"},
		{"status", "D"},
		{"size", bson.D{
			{"h", 22.85},
			{"w", 30},
			{"uom", "cm"},
		}},
		{"instock", bson.A{
			bson.D{
				{"warehouse", "A"},
				{"qty", 40},
			},
		}},
	},
	bson.D{
		{"item", "postcard"},
		{"status", "A"},
		{"size", bson.D{
			{"h", 10},
			{"w", 15.25},
			{"uom", "cm"},
		}},
		{"instock", bson.A{
			bson.D{
				{"warehouse", "B"},
				{"qty", 15},
			},
			bson.D{
				{"warehouse", "EC"},
				{"qty", 35},
			},
		}},
	},
}
result, err := coll.InsertMany(context.TODO(), docs)

Publisher<Success> insertManyPublisher = collection.insertMany(asList(
    Document.parse("{ item: 'journal', status: 'A', size: { h: 14, w: 21, uom: 'cm' }, instock: [ { warehouse: 'A', qty: 5 }]}"),
    Document.parse("{ item: 'notebook', status: 'A',  size: { h: 8.5, w: 11, uom: 'in' }, instock: [ { warehouse: 'C', qty: 5}]}"),
    Document.parse("{ item: 'paper', status: 'D', size: { h: 8.5, w: 11, uom: 'in' }, instock: [ { warehouse: 'A', qty: 60 }]}"),
    Document.parse("{ item: 'planner', status: 'D', size: { h: 22.85, w: 30, uom: 'cm' }, instock: [ { warehouse: 'A', qty: 40}]}"),
    Document.parse("{ item: 'postcard', status: 'A', size: { h: 10, w: 15.25, uom: 'cm' }, "
            + "instock: [ { warehouse: 'B', qty: 15 }, { warehouse: 'C', qty: 35 } ] }")
));

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

collection.insertMany(
    listOf(
        Document("item", "journal")
            .append("status", "A")
            .append("size", Document("h", 14).append("w", 21).append("uom", "cm"))
            .append("instock", listOf(
                Document("warehouse", "A").append("qty", 5),
            )),
        Document("item", "notebook")
            .append("status", "A")
            .append("size", Document("h", 8.5).append("w", 11).append("uom", "in"))
            .append("instock", listOf(
                Document("warehouse", "C").append("qty", 5),
            )),
        Document("item", "paper")
            .append("status", "D")
            .append("size", Document("h", 8.5).append("w", 11).append("uom", "in"))
            .append("instock", listOf(
                Document("warehouse", "A").append("qty", 60),
            )),
        Document("item", "planner")
            .append("status", "D")
            .append("size", Document("h", 22.85).append("w", 30).append("uom", "cm"))
            .append("instock", listOf(
                Document("warehouse", "A").append("qty", 40),
            )),
        Document("item", "postcard")
            .append("status", "A")
            .append("size", Document("h", 10).append("w", 15.25).append("uom", "cm"))
            .append("instock", listOf(
                Document("warehouse", "B").append("qty", 15),
                Document("warehouse", "C").append("qty", 35)
            )),
    )
)

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

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

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

$insertManyResult = $db->inventory->insertMany([
    [
        'item' => 'journal',
        'status' => 'A',
        'size' => ['h' => 14, 'w' => 21, 'uom' => 'cm'],
        'instock' => [
            ['warehouse' => 'A', 'qty' => 5],
        ],
    ],
    [
        'item' => 'notebook',
        'status' => 'A',
        'size' => ['h' => 8.5, 'w' => 11, 'uom' => 'in'],
        'instock' => [
            ['warehouse' => 'C', 'qty' => 5],
        ],
    ],
    [
        'item' => 'paper',
        'status' => 'D',
        'size' => ['h' => 8.5, 'w' => 11, 'uom' => 'in'],
        'instock' => [
            ['warehouse' => 'A', 'qty' => 60],
        ],
    ],
    [
        'item' => 'planner',
        'status' => 'D',
        'size' => ['h' => 22.85, 'w' => 30, 'uom' => 'cm'],
        'instock' => [
            ['warehouse' => 'A', 'qty' => 40],
        ],
    ],
    [
        'item' => 'postcard',
        'status' => 'A',
        'size' => ['h' => 10, 'w' => 15.25, 'uom' => 'cm'],
        'instock' => [
            ['warehouse' => 'B', 'qty' => 15],
            ['warehouse' => 'C', 'qty' => 35],
        ],
    ],
]);

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

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

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

Retorno de todos os campos em documentos correspondentes

Se você não especificar um documento de projeção, o método db.collection.find() retornará todos os campos nos documentos correspondentes.

Se você não especificar um documento de projeção, o Compass retornará todos os campos nos documentos correspondentes.

Se você não especificar um filtro de projeção, o método MongoCollection.Find() retornará todos os campos nos documentos correspondentes.

Se você não especificar uma projeção, o com.mongodb.reactivestreams. cliente.MongoCollection.find método retorna todos os campos nos documentos correspondentes.

Se você não especificar uma projeção, o método com.mongodb.client.MongoCollection.find retornará todos os campos nos documentos correspondentes.

Se você não especificar um documento de projeção , o MongoCollection.find() method returns all fields in the matching documents.

Se você não especificar um documento de projeção, o método find() produzirá todos os campos nos documentos correspondentes.

Se você não especificar um documento de projeção, o método find() retornará todos os campos nos documentos correspondentes.

Se você não especificar um documento de projeção, o método find() retornará todos os campos nos documentos correspondentes.

Se você não especificar um documento de projeção, o método find retornará todos os campos nos documentos correspondentes.

Se você não especificar um documento de projeção, o método find() retornará todos os campos nos documentos correspondentes.

Se você não especificar uma projeção, o método collection.find() retorna todos os campos nos documentos correspondentes.

O exemplo a seguir retorna todos os campos de todos os documentos da collection inventory em que status é igual a "A":

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

Copie a seguinte expressão no campo Filter:
```
{ status: "A" }
```
Clique em Find.

mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("status", BCON_UTF8 ("A"));
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);

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

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

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

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

val findFlow = collection
    .find(eq("status", "A"))

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

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

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

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

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

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

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

A operação corresponde à seguinte declaração SQL:

SELECT * from inventory WHERE status = "A"

Retorne os campos especificados e o campo `_id` apenas

Uma projeção pode incluir explicitamente vários campos configurando o <field> para 1 no documento de projeção. A operação a seguir retorna todos os documentos que correspondem à query. No conjunto de resultados, somente os campos item, status e, por padrão, os campos _id retornam nos documentos correspondentes.

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

Copie a seguinte expressão no campo Filter:
```
{ status: "A" }
```
Clique em Options para abrir as opções de consulta adicionais.
Copie a seguinte expressão no campo Project:
```
{ item: 1, status: 1 }
```
Clique em 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);

Certifique-se também de limpar quaisquer recursos abertos ligando para os seguintes métodos, conforme apropriado:

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

Para especificar um documento de projeção , encadeie o com.mongodb. cliente.FindIterable. projeção método para o find método . O exemplo usa o com.mongodb. cliente.model.Projections classe para criar os documentos de projeção .

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

val findFlow = collection
    .find(eq("status", "A")).projection(include("item", "status"))

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

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

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

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

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

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

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

A operação corresponde à seguinte declaração SQL:

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

Suprimir o campo `_id`

Você pode remover o campo _id dos resultados definindo-o como 0 na projeção, como no exemplo a seguir:

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

Copie a seguinte expressão no campo Filter:
```
{ status: "A" }
```
Clique em Options para abrir as opções de consulta adicionais.
Copie a seguinte expressão no campo Project:
```
{ item: 1, status: 1, _id: 0 }
```
Clique em 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()));

Para especificar um documento de projeção , encadeie o com.mongodb. cliente.FindIterable. projeção método para o find método . O exemplo usa o com.mongodb. cliente.model.Projections classe para criar os documentos de projeção .

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

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

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

const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1, _id: 0 });

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

$cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1, '_id' => 0]],
);

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

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

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

A operação corresponde à seguinte declaração SQL:

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

Observação

Com exceção do campo _id, você não pode combinar declarações de inclusão e exclusão em documentos de projeção.

Retorno de todos os campos, exceto os excluídos

Em vez de listar os campos para retornar no documento correspondente, você pode usar uma projeção para excluir campos específicos. O exemplo a seguir retorna todos os campos, exceto os campos status e instock nos documentos correspondentes:

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

Copie a seguinte expressão no campo Filter:
```
{ status: "A" }
```
Clique em Options para abrir as opções de consulta adicionais.
Copie a seguinte expressão no campo Project:
```
{ status: 0, instock: 0 }
```
Clique em 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"));

Para especificar um documento de projeção , encadeie o com.mongodb. cliente.FindIterable. projeção método para o find método . O exemplo usa o com.mongodb. cliente.model.Projections classe para criar os documentos de projeção .

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

val findFlow = collection
    .find(eq("status", "A")).projection(exclude("item", "status"))

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

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

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

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

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

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

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

Observação

Com exceção do campo _id, você não pode combinar declarações de inclusão e exclusão em documentos de projeção.

Retorno de campos específicos de documentos incorporados

Você pode retornar campos específicos de um documento incorporado. Use a notação de ponto para se referir ao campo incorporado e defina como 1 no documento de projeção.

O exemplo a seguir retorna:

O campo _id (retornado por padrão),
O campo item,
O campo status,
O campo uom do documento size.

O campo uom permanece incorporado no documento size.

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

Copie a seguinte expressão no campo Filter:
```
{ status: "A" }
```
Clique em Options para abrir as opções de consulta adicionais.
Copie a seguinte expressão no campo Project:
```
{ item: 1, status: 1, "size.uom": 1 }
```
Clique em 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"));

Para especificar um documento de projeção , encadeie o com.mongodb. cliente.FindIterable. projeção método para o find método . O exemplo usa o com.mongodb. cliente.model.Projections classe para criar os documentos de projeção .

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

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

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

const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1, 'size.uom': 1 });

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

$cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1, 'size.uom' => 1]],
);

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

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

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

Você também pode especificar campos incorporados usando o formulário aninhado. Por exemplo, { item: 1, status: 1, size: { uom: 1 } }.

Supressão de campos específicos em documentos incorporados

Você pode suprimir campos específicos de um documento incorporado. Use a notação de ponto para fazer referência ao campo incorporado no documento de projeção e defina como 0.

O exemplo a seguir especifica uma projeção para excluir o campo uom dentro do documento size. Todos os outros campos são retornados nos documentos correspondentes:

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

Copie a seguinte expressão no campo Filter:
```
{ status: "A" }
```
Clique em Options para abrir as opções de consulta adicionais.
Copie a seguinte expressão no campo Project:
```
{ "size.uom": 0 }
```
Clique em 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"));

Para especificar um documento de projeção , encadeie o com.mongodb. cliente.FindIterable. projeção método para o find método . O exemplo usa o com.mongodb. cliente.model.Projections classe para criar os documentos de projeção .

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

val findFlow = collection
    .find(eq("status", "A")).projection(exclude("size.uom"))

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

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

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

$cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['size.uom' => 0]],
);

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

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

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

Você também pode especificar campos incorporados usando o formulário aninhado. Por exemplo, { size: { uom: 0 } }.

Projeção em documentos incorporados em uma array

Use a notação de pontos para projetar campos específicos dentro de documentos incorporados em uma array.

O exemplo a seguir especifica uma projeção para retornar:

O campo _id (retornado por padrão),
O campo item,
O campo status,
O campo qty nos documentos incorporados na array instock.

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

Copie a seguinte expressão no campo Filter:
```
{ status: "A" }
```
Clique em Options para abrir as opções de consulta adicionais.
Copie a seguinte expressão no campo Project:
```
{ item: 1, status: 1, "instock.qty": 1 }
```
Clique em 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"));

Para especificar um documento de projeção , encadeie o com.mongodb. cliente.FindIterable. projeção método para o find método . O exemplo usa o com.mongodb. cliente.model.Projections classe para criar os documentos de projeção .

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

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

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

const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1, 'instock.qty': 1 });

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

$cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1, 'instock.qty' => 1]],
);

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

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

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

Elementos de array específicos do projeto na array retornada

Para campos com arrays, o MongoDB fornece os seguintes operadores de projeções para manipular arrays: $elemMatch, $slice e $.

O exemplo a seguir utiliza o operador de projeção $slice para retornar o último elemento na matriz instock:

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

Copie a seguinte expressão no campo Filter:
```
{ status: "A" }
```
Clique em Options para abrir as opções de consulta adicionais.
Copie a seguinte expressão no campo Project:
```
{ item: 1, status: 1, instock: { $slice: -1 } }
```
Clique em 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)));

Para especificar um documento de projeção , encadeie o com.mongodb. cliente.FindIterable. projeção método para o find método . O exemplo usa o com.mongodb. cliente.model.Projections classe para criar os documentos de projeção .

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

Para especificar um documento de projeção , encadeie o FindFlow. projeção() método para o método find() . O exemplo usa o com.mongodb. cliente.model.Projections classe para criar os documentos de projeção .

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

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

const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1, instock: { $slice: -1 } });

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

$cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]],
);

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

client[:inventory].find({ status: 'A' },
                        projection: {'item' => 1,
                                     'status' => 1,
                                     'instock' => { '$slice' => -1 } })

findObservable = collection.find(equal("status", "A"))
  .projection(fields(include("item", "status"), slice("instock", -1)))

$elemMatch, $slice e $ são os únicos operadores que você pode usar para projetar elementos específicos a serem incluídos na array retornada. Por exemplo, você não pode projetar elementos de array específicos utilizando o índice de array; por exemplo A projeção do { "instock.0": 1 } não projeta a array com o primeiro elemento.

Para campos com arrays, o MongoDB fornece os seguintes operadores de projeções para manipular arrays: $elemMatch, $slice e $.

O exemplo a seguir utiliza o operador de projeção $slice para retornar o último elemento na matriz instock:

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

Copie a seguinte expressão no campo Filter:
```
{ status: "A" }
```
Clique em Options para abrir as opções de consulta adicionais.
Copie a seguinte expressão no campo Project:
```
{ item: 1, status: 1, instock: { $slice: -1 } }
```
Clique em 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)));

Para especificar um documento de projeção , encadeie o com.mongodb. cliente.FindIterable. projeção método para o find método . O exemplo usa o com.mongodb. cliente.model.Projections classe para criar os documentos de projeção .

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

Para especificar um documento de projeção , encadeie o FindFlow. projeção() método para o método find() . O exemplo usa o com.mongodb. cliente.model.Projections classe para criar os documentos de projeção .

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

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

const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1, instock: { $slice: -1 } });

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

$cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]],
);

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

client[:inventory].find({ status: 'A' },
                        projection: {'item' => 1,
                                     'status' => 1,
                                     'instock' => { '$slice' => -1 } })

findObservable = collection.find(equal("status", "A"))
  .projection(fields(include("item", "status"), slice("instock", -1)))

Para campos com arrays, o MongoDB fornece os seguintes operadores de projeções para manipular arrays: $elemMatch, $slice e $.

O exemplo a seguir utiliza o operador de projeção $slice para retornar o último elemento na matriz instock:

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

Copie a seguinte expressão no campo Filter:
```
{ status: "A" }
```
Clique em Options para abrir as opções de consulta adicionais.
Copie a seguinte expressão no campo Project:
```
{ item: 1, status: 1, instock: { $slice: -1 } }
```
Clique em 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)));

Para especificar um documento de projeção , encadeie o com.mongodb. cliente.FindIterable. projeção método para o find método . O exemplo usa o com.mongodb. cliente.model.Projections classe para criar os documentos de projeção .

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

Para especificar um documento de projeção , encadeie o FindFlow. projeção() método para o método find() . O exemplo usa o com.mongodb. cliente.model.Projections classe para criar os documentos de projeção .

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

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

const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1, instock: { $slice: -1 } });

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

$cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]],
);

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

client[:inventory].find({ status: 'A' },
                        projection: {'item' => 1,
                                     'status' => 1,
                                     'instock' => { '$slice' => -1 } })

findObservable = collection.find(equal("status", "A"))
  .projection(fields(include("item", "status"), slice("instock", -1)))

$elemMatch, $slice e $ são os únicos operadores que você pode usar para projeto elementos específicos a serem incluídos na array retornada.

Por exemplo, a operação a seguir não projetará a array com o primeiro elemento:

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

Para campos com arrays, o MongoDB fornece os seguintes operadores de projeções para manipular arrays: $elemMatch, $slice e $.

O exemplo a seguir utiliza o operador de projeção $slice para retornar o último elemento na matriz instock:

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

Copie a seguinte expressão no campo Filter:
```
{ status: "A" }
```
Clique em Options para abrir as opções de consulta adicionais.
Copie a seguinte expressão no campo Project:
```
{ item: 1, status: 1, instock: { $slice: -1 } }
```
Clique em 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)));

Para especificar um documento de projeção , encadeie o com.mongodb. cliente.FindIterable. projeção método para o find método . O exemplo usa o com.mongodb. cliente.model.Projections classe para criar os documentos de projeção .

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

Para especificar um documento de projeção , encadeie o FindFlow. projeção() método para o método find() . O exemplo usa o com.mongodb. cliente.model.Projections classe para criar os documentos de projeção .

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

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

const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1, instock: { $slice: -1 } });

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

$cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]],
);

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

client[:inventory].find({ status: 'A' },
                        projection: {'item' => 1,
                                     'status' => 1,
                                     'instock' => { '$slice' => -1 } })

findObservable = collection.find(equal("status", "A"))
  .projection(fields(include("item", "status"), slice("instock", -1)))

$elemMatch, $slice e $ são os únicos operadores que você pode usar para projetar elementos específicos a serem incluídos na array retornada. Por exemplo, você não pode projetar elementos de array específicos utilizando o índice de array; por exemplo A projeção do include("instock.0") não projeta a array com o primeiro elemento.

Para campos com arrays, o MongoDB fornece os seguintes operadores de projeções para manipular arrays: $elemMatch, $slice e $.

O exemplo a seguir utiliza o operador de projeção $slice para retornar o último elemento na matriz instock:

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

Copie a seguinte expressão no campo Filter:
```
{ status: "A" }
```
Clique em Options para abrir as opções de consulta adicionais.
Copie a seguinte expressão no campo Project:
```
{ item: 1, status: 1, instock: { $slice: -1 } }
```
Clique em 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)));

Para especificar um documento de projeção , encadeie o com.mongodb. cliente.FindIterable. projeção método para o find método . O exemplo usa o com.mongodb. cliente.model.Projections classe para criar os documentos de projeção .

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

Para especificar um documento de projeção , encadeie o FindFlow. projeção() método para o método find() . O exemplo usa o com.mongodb. cliente.model.Projections classe para criar os documentos de projeção .

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

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

const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1, instock: { $slice: -1 } });

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

$cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]],
);

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

client[:inventory].find({ status: 'A' },
                        projection: {'item' => 1,
                                     'status' => 1,
                                     'instock' => { '$slice' => -1 } })

findObservable = collection.find(equal("status", "A"))
  .projection(fields(include("item", "status"), slice("instock", -1)))

$elemMatch, $slice e $ são os únicos operadores que você pode usar para projetar elementos específicos a serem incluídos na array retornada. Por exemplo, você não pode projetar elementos de array específicos utilizando o índice de array; por exemplo A projeção do include("instock.0") não projeta a array com o primeiro elemento.

Para campos com arrays, o MongoDB fornece os seguintes operadores de projeções para manipular arrays: $elemMatch, $slice e $.

O exemplo a seguir utiliza o operador de projeção $slice para retornar o último elemento na matriz instock:

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

Copie a seguinte expressão no campo Filter:
```
{ status: "A" }
```
Clique em Options para abrir as opções de consulta adicionais.
Copie a seguinte expressão no campo Project:
```
{ item: 1, status: 1, instock: { $slice: -1 } }
```
Clique em 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)));

Para especificar um documento de projeção , encadeie o com.mongodb. cliente.FindIterable. projeção método para o find método . O exemplo usa o com.mongodb. cliente.model.Projections classe para criar os documentos de projeção .

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

Para especificar um documento de projeção , encadeie o FindFlow. projeção() método para o método find() . O exemplo usa o com.mongodb. cliente.model.Projections classe para criar os documentos de projeção .

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

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

const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1, instock: { $slice: -1 } });

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

$cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]],
);

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

client[:inventory].find({ status: 'A' },
                        projection: {'item' => 1,
                                     'status' => 1,
                                     'instock' => { '$slice' => -1 } })

findObservable = collection.find(equal("status", "A"))
  .projection(fields(include("item", "status"), slice("instock", -1)))

$elemMatch, $slice e $ são os únicos operadores que você pode usar para projetar elementos específicos a serem incluídos na array retornada. Por exemplo, você não pode projetar elementos de array específicos utilizando o índice de array; por exemplo A projeção do include("instock.0") não projeta a array com o primeiro elemento.

Para campos com arrays, o MongoDB fornece os seguintes operadores de projeções para manipular arrays: $elemMatch, $slice e $.

O exemplo a seguir utiliza o operador de projeção $slice para retornar o último elemento na matriz instock:

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

Copie a seguinte expressão no campo Filter:
```
{ status: "A" }
```
Clique em Options para abrir as opções de consulta adicionais.
Copie a seguinte expressão no campo Project:
```
{ item: 1, status: 1, instock: { $slice: -1 } }
```
Clique em 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)));

Para especificar um documento de projeção , encadeie o com.mongodb. cliente.FindIterable. projeção método para o find método . O exemplo usa o com.mongodb. cliente.model.Projections classe para criar os documentos de projeção .

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

Para especificar um documento de projeção , encadeie o FindFlow. projeção() método para o método find() . O exemplo usa o com.mongodb. cliente.model.Projections classe para criar os documentos de projeção .

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

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

const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1, instock: { $slice: -1 } });

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

$cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]],
);

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

client[:inventory].find({ status: 'A' },
                        projection: {'item' => 1,
                                     'status' => 1,
                                     'instock' => { '$slice' => -1 } })

findObservable = collection.find(equal("status", "A"))
  .projection(fields(include("item", "status"), slice("instock", -1)))

$elemMatch, $slice e $ são os únicos operadores que você pode usar para projetar elementos específicos a serem incluídos na array retornada. Por exemplo, você não pode projetar elementos de array específicos utilizando o índice de array; por exemplo A projeção do include("instock.0") não projeta a array com o primeiro elemento.

Para campos com arrays, o MongoDB fornece os seguintes operadores de projeções para manipular arrays: $elemMatch, $slice e $.

O exemplo a seguir utiliza o operador de projeção $slice para retornar o último elemento na matriz instock:

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

Copie a seguinte expressão no campo Filter:
```
{ status: "A" }
```
Clique em Options para abrir as opções de consulta adicionais.
Copie a seguinte expressão no campo Project:
```
{ item: 1, status: 1, instock: { $slice: -1 } }
```
Clique em 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)));

Para especificar um documento de projeção , encadeie o com.mongodb. cliente.FindIterable. projeção método para o find método . O exemplo usa o com.mongodb. cliente.model.Projections classe para criar os documentos de projeção .

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

Para especificar um documento de projeção , encadeie o FindFlow. projeção() método para o método find() . O exemplo usa o com.mongodb. cliente.model.Projections classe para criar os documentos de projeção .

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

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

const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1, instock: { $slice: -1 } });

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

$cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]],
);

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

client[:inventory].find({ status: 'A' },
                        projection: {'item' => 1,
                                     'status' => 1,
                                     'instock' => { '$slice' => -1 } })

findObservable = collection.find(equal("status", "A"))
  .projection(fields(include("item", "status"), slice("instock", -1)))

$elemMatch, $slice e $ são os únicos operadores que você pode usar para projetar elementos específicos a serem incluídos na array retornada. Por exemplo, você não pode projetar elementos de array específicos utilizando o índice de array; por exemplo A projeção do { "instock.0": 1 } não projeta a array com o primeiro elemento.

Para campos com arrays, o MongoDB fornece os seguintes operadores de projeções para manipular arrays: $elemMatch, $slice e $.

O exemplo a seguir utiliza o operador de projeção $slice para retornar o último elemento na matriz instock:

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

Copie a seguinte expressão no campo Filter:
```
{ status: "A" }
```
Clique em Options para abrir as opções de consulta adicionais.
Copie a seguinte expressão no campo Project:
```
{ item: 1, status: 1, instock: { $slice: -1 } }
```
Clique em 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)));

Para especificar um documento de projeção , encadeie o com.mongodb. cliente.FindIterable. projeção método para o find método . O exemplo usa o com.mongodb. cliente.model.Projections classe para criar os documentos de projeção .

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

Para especificar um documento de projeção , encadeie o FindFlow. projeção() método para o método find() . O exemplo usa o com.mongodb. cliente.model.Projections classe para criar os documentos de projeção .

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

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

const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1, instock: { $slice: -1 } });

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

$cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]],
);

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

client[:inventory].find({ status: 'A' },
                        projection: {'item' => 1,
                                     'status' => 1,
                                     'instock' => { '$slice' => -1 } })

findObservable = collection.find(equal("status", "A"))
  .projection(fields(include("item", "status"), slice("instock", -1)))

$elemMatch, $slice e $ são os únicos operadores que você pode usar para projetar elementos específicos a serem incluídos na array retornada. Por exemplo, você não pode projetar elementos de array específicos utilizando o índice de array; por exemplo A projeção do { "instock.0" => 1 } não projeta a array com o primeiro elemento.

Para campos com arrays, o MongoDB fornece os seguintes operadores de projeções para manipular arrays: $elemMatch, $slice e $.

O exemplo a seguir utiliza o operador de projeção $slice para retornar o último elemento na matriz instock:

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

Copie a seguinte expressão no campo Filter:
```
{ status: "A" }
```
Clique em Options para abrir as opções de consulta adicionais.
Copie a seguinte expressão no campo Project:
```
{ item: 1, status: 1, instock: { $slice: -1 } }
```
Clique em 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)));

Para especificar um documento de projeção , encadeie o com.mongodb. cliente.FindIterable. projeção método para o find método . O exemplo usa o com.mongodb. cliente.model.Projections classe para criar os documentos de projeção .

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

Para especificar um documento de projeção , encadeie o FindFlow. projeção() método para o método find() . O exemplo usa o com.mongodb. cliente.model.Projections classe para criar os documentos de projeção .

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

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

const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1, instock: { $slice: -1 } });

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

$cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]],
);

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

client[:inventory].find({ status: 'A' },
                        projection: {'item' => 1,
                                     'status' => 1,
                                     'instock' => { '$slice' => -1 } })

findObservable = collection.find(equal("status", "A"))
  .projection(fields(include("item", "status"), slice("instock", -1)))

$elemMatch, $slice e $ são os únicos operadores que você pode usar para projetar elementos específicos a serem incluídos na array retornada. Por exemplo, você não pode projetar elementos de array específicos utilizando o índice de array; por exemplo A projeção do [ "instock.0" => 1 ] não projeta a array com o primeiro elemento.

Para campos com arrays, o MongoDB fornece os seguintes operadores de projeções para manipular arrays: $elemMatch, $slice e $.

O exemplo a seguir utiliza o operador de projeção $slice para retornar o último elemento na matriz instock:

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

Copie a seguinte expressão no campo Filter:
```
{ status: "A" }
```
Clique em Options para abrir as opções de consulta adicionais.
Copie a seguinte expressão no campo Project:
```
{ item: 1, status: 1, instock: { $slice: -1 } }
```
Clique em 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)));

Para especificar um documento de projeção , encadeie o com.mongodb. cliente.FindIterable. projeção método para o find método . O exemplo usa o com.mongodb. cliente.model.Projections classe para criar os documentos de projeção .

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

Para especificar um documento de projeção , encadeie o FindFlow. projeção() método para o método find() . O exemplo usa o com.mongodb. cliente.model.Projections classe para criar os documentos de projeção .

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

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

const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1, instock: { $slice: -1 } });

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

$cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]],
);

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

client[:inventory].find({ status: 'A' },
                        projection: {'item' => 1,
                                     'status' => 1,
                                     'instock' => { '$slice' => -1 } })

findObservable = collection.find(equal("status", "A"))
  .projection(fields(include("item", "status"), slice("instock", -1)))

$elemMatch, $slice e $ são os únicos operadores que você pode usar para projetar elementos específicos a serem incluídos na array retornada. Por exemplo, você não pode projetar elementos de array específicos utilizando o índice de array; por exemplo A projeção do { "instock.0": 1 } não projeta a array com o primeiro elemento.

Para campos com arrays, o MongoDB fornece os seguintes operadores de projeções para manipular arrays: $elemMatch, $slice e $.

O exemplo a seguir utiliza o operador de projeção $slice para retornar o último elemento na matriz instock:

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

Copie a seguinte expressão no campo Filter:
```
{ status: "A" }
```
Clique em Options para abrir as opções de consulta adicionais.
Copie a seguinte expressão no campo Project:
```
{ item: 1, status: 1, instock: { $slice: -1 } }
```
Clique em 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)));

Para especificar um documento de projeção , encadeie o com.mongodb. cliente.FindIterable. projeção método para o find método . O exemplo usa o com.mongodb. cliente.model.Projections classe para criar os documentos de projeção .

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

Para especificar um documento de projeção , encadeie o FindFlow. projeção() método para o método find() . O exemplo usa o com.mongodb. cliente.model.Projections classe para criar os documentos de projeção .

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

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

const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1, instock: { $slice: -1 } });

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

$cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]],
);

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

client[:inventory].find({ status: 'A' },
                        projection: {'item' => 1,
                                     'status' => 1,
                                     'instock' => { '$slice' => -1 } })

findObservable = collection.find(equal("status", "A"))
  .projection(fields(include("item", "status"), slice("instock", -1)))

$elemMatch, $slice e $ são os únicos operadores que você pode usar para projetar elementos específicos a serem incluídos na array retornada. Por exemplo, você não pode projetar elementos de array específicos utilizando o índice de array; por exemplo A projeção do { "instock.0" => 1 } não projeta a array com o primeiro elemento.

Para campos com arrays, o MongoDB fornece os seguintes operadores de projeções para manipular arrays: $elemMatch, $slice e $.

O exemplo a seguir utiliza o operador de projeção $slice para retornar o último elemento na matriz instock:

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

Copie a seguinte expressão no campo Filter:
```
{ status: "A" }
```
Clique em Options para abrir as opções de consulta adicionais.
Copie a seguinte expressão no campo Project:
```
{ item: 1, status: 1, instock: { $slice: -1 } }
```
Clique em 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)));

Para especificar um documento de projeção , encadeie o com.mongodb. cliente.FindIterable. projeção método para o find método . O exemplo usa o com.mongodb. cliente.model.Projections classe para criar os documentos de projeção .

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

Para especificar um documento de projeção , encadeie o FindFlow. projeção() método para o método find() . O exemplo usa o com.mongodb. cliente.model.Projections classe para criar os documentos de projeção .

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

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

const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1, instock: { $slice: -1 } });

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

$cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]],
);

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

client[:inventory].find({ status: 'A' },
                        projection: {'item' => 1,
                                     'status' => 1,
                                     'instock' => { '$slice' => -1 } })

findObservable = collection.find(equal("status", "A"))
  .projection(fields(include("item", "status"), slice("instock", -1)))

$elemMatch, $slice e $ são os únicos operadores que você pode usar para projetar elementos específicos a serem incluídos na array retornada. Por exemplo, você não pode projetar elementos de array específicos utilizando o índice de array; por exemplo A projeção do include("instock.0") não projeta a array com o primeiro elemento.

Projetar campos com expressões de aggregation

Você pode especificar expressões de aggregation em uma projeção de query. Expressões de aggregation permitem projetar novos campos e modificar os valores dos campos existentes.

Por exemplo, a operação abaixo usa expressões de aggregation para substituir o valor do campo status e projetar novos campos area e reportNumber.

Observação

O exemplo a seguir utiliza a sintaxe MongoDB Shell. Para obter exemplos de projeção com agregação, consulte a documentação do driver.

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

Campos do projeto para retornar de uma query com o MongoDB Atlas

O exemplo nesta seção utiliza o conjunto de dados de filmes de amostra. Para saber como carregar o conjunto de dados de amostra em sua implantação do MongoDB Atlas, consulte Carregue dados de amostra.

Para projetar campos para retornar de uma consulta no MongoDB Atlas, siga estas etapas:

1

Na IU do MongoDB Atlas, acesse a página Clusters do seu projeto.

Se ainda não tiver sido exibido, selecione a organização que contém seu projeto no menu Organizations na barra de navegação.
Se ainda não estiver exibido, selecione seu projeto no menu Projects na barra de navegação.
Se ainda não estiver exibido, clique em Clusters na barra lateral.
A página Clusters é exibida.

2

Navegue até a coleção

Para o cluster que contém os dados de amostra, clique em Browse Collections.
No painel de navegação esquerdo, selecione o banco de dados sample_mflix.
Selecione a collection movies.

3

Especifique o campo Filtro

Clique em More Options no lado direito do campo Filter .
Especifique o filtro de query.
Especifique o documento de filtro de queries no campo Filter. Um documento de filtro de queries usa operadores de consulta para especificar as condições de pesquisa.
Copie o seguinte documento de filtro de queries para a barra de pesquisa Filter:
```
{ year: 1924 }
```

4

Especifique os campos para projetar

Especifique o(s) campo(s) a ser retornado nos resultados da query.

Copie o seguinte documento do projeto para a barra Project :

{ title: 1, plot: 1 }

5

Clique em Aplicar

Este filtro de query retorna os seguintes campos para todos os documentos na coleção sample_mflix.movies em que o campo year corresponde a 1924 :

_id
title
plot

O MongoDB Atlas retorna o campo _id por padrão. Para omitir o campo _id , copie o seguinte documento do projeto na barra Project e clique em Apply:

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

Considerações adicionais

O MongoDB impõe restrições adicionais em relação às projeções. Consulte Restrições de Projeção para detalhes.

Dica

Veja também:

Voltar

arrays de documentos incorporados

Próximo

Campos nulos ou ausentes

Selecione a linguagem

Nesta página

Retorno de todos os campos em documentos correspondentes
Retorno somente dos campos especificados e do campo _id
Supressão do campo _id
Retorno de todos os campos, exceto os excluídos
Retorno de campos específicos de documentos incorporados
Supressão de campos específicos em documentos incorporados
Projeção em documentos incorporados em uma array
Elementos de array específicos do projeto na array retornada
Projetar campos com expressões de aggregation
Campos do projeto para retornar de uma query com o MongoDB Atlas
Considerações adicionais