쿼리에서 반환할 프로젝트 필드

쿼리에서 반환할 프로젝트 필드

이 페이지의 내용

일치하는 문서의 모든 필드 반환

지정된 필드 및 _id 필드만 반환
_id 필드 억제
제외된 필드를 제외한 모든 필드 반환
내장된 문서에서 특정 필드 반환
내장된 문서에서 특정 필드 미표시
배열에서 내장된 문서에 프로젝션
반환된 배열에 프로젝트별 배열 요소 프로젝션
집계 표현식으로 필드 투영
MongoDB Atlas를 사용하여 쿼리에서 반환할 프로젝트 필드
추가 고려 사항

다음 메서드를 사용하여 MongoDB에 내장된 문서를 쿼리할 수 있습니다.

프로그래밍 언어의 드라이버입니다.
MongoDB Atlas UI. 학습 보려면 MongoDB Atlas 를 사용하여 쿼리에서 반환할 프로젝트 필드를 참조하세요.
MongoDB Compass

오른쪽 상단의 언어 선택 드롭다운 메뉴를 사용하여 다음 예시의 언어를 설정하거나 MongoDB Compass를 선택합니다.

기본적으로 MongoDB의 쿼리는 일치하는 문서의 모든 필드를 반환합니다. MongoDB가 애플리케이션에 전송하는 데이터 양을 제한하려면 프로젝션 문서를 포함하여 반환할 필드를 지정하거나 제한할 수 있습니다.

이 페이지에서는mongosh 에서 db.collection.find() 메서드를 사용한 프로젝션 을 사용한 쿼리 작업의 예를 제공합니다

이 페이지의 예시에서는 inventory 컬렉션을 사용합니다. MongoDB 인스턴스의 테스트 데이터베이스에 연결한 다음 inventory 컬렉션을 만듭니다:

이 페이지에서는 MongoDB Compass를 사용하여 프로젝션을 사용한 쿼리 작업의 예시를 제공합니다.

이 페이지의 예시에서는 inventory 컬렉션을 사용합니다. MongoDB 인스턴스의 테스트 데이터베이스에 연결한 다음 inventory 컬렉션을 만듭니다:

이 페이지에서는 mongoc_collection_find_with_opts 를 사용한 프로젝션 을 사용한 쿼리 작업의 예를 제공합니다.

이 페이지의 예시에서는 inventory 컬렉션을 사용합니다. MongoDB 인스턴스의 테스트 데이터베이스에 연결한 다음 inventory 컬렉션을 만듭니다:

이 페이지에서는 MongoDB C# 드라이버에서 MongoCollection.Find() 메서드를 사용하여 프로젝션을 사용한 쿼리 작업의 예시를 보여줍니다.

이 페이지의 예시에서는 inventory 컬렉션을 사용합니다. MongoDB 인스턴스의 테스트 데이터베이스에 연결한 다음 inventory 컬렉션을 만듭니다:

이 페이지에서는 MongoDB Go 드라이버에서 Collection.Find 함수를 사용하여 프로젝션을 사용한 쿼리 작업의 예시를 보여줍니다.

이 페이지의 예시에서는 inventory 컬렉션을 사용합니다. MongoDB 인스턴스의 테스트 데이터베이스에 연결한 다음 inventory 컬렉션을 만듭니다:

이 페이지에서는 com.mongodb.reactivestreams 를 사용한 프로젝션 을 사용한 쿼리 작업의 예를 제공합니다. 클라이언트.MongoCollection.find MongoDB Java Reactive Streams 드라이버 의 메서드 .

이 페이지의 예시에서는 inventory 컬렉션을 사용합니다. MongoDB 인스턴스의 테스트 데이터베이스에 연결한 다음 inventory 컬렉션을 만듭니다:

이 페이지는 Java 동기식 드라이버에서 com.mongodb.client.MongoCollection.find 메서드를 사용하여 프로젝션을 사용한 쿼리 작업의 예시를 보여줍니다.

팁

이 드라이버는 필터 문서를 쉽게 만들 수 있도록 com.mongodb.client.model.Filters 헬퍼 메서드를 제공합니다. 이 페이지의 예시에서는 이러한 방법을 사용하여 필터 문서를 생성합니다.

이 페이지의 예시에서는 inventory 컬렉션을 사용합니다. MongoDB 인스턴스의 테스트 데이터베이스에 연결한 다음 inventory 컬렉션을 만듭니다:

이 페이지에서는 MongoCollection.find() 메서드 를 사용하여 프로젝션 이 포함된 쿼리 작업의 예를 제공합니다. 메서드를 MongoDB 코틀린 (Kotlin) 루틴 드라이버.

팁

이 드라이버는 필터 문서를 쉽게 만들 수 있도록 com.mongodb.client.model.Filters 헬퍼 메서드를 제공합니다. 이 페이지의 예시에서는 이러한 방법을 사용하여 필터 문서를 생성합니다.

이 페이지의 예시에서는 inventory 컬렉션을 사용합니다. MongoDB 인스턴스의 테스트 데이터베이스에 연결한 다음 inventory 컬렉션을 만듭니다:

이 페이지는 Motor 드라이버에서 motor.motor_asyncio.AsyncIOMotorCollection.find 메서드를 사용한 프로젝션이 포함된 쿼리 작업의 예를 제공합니다.

이 페이지의 예시에서는 inventory 컬렉션을 사용합니다. MongoDB 인스턴스의 테스트 데이터베이스에 연결한 다음 inventory 컬렉션을 만듭니다:

이 페이지에서는 Collection.find() 메서드를 사용한 프로젝션으로 수행하는 쿼리 작업의 예시를 제공합니다. MongoDB Node.js 드라이버에서 해당 작업을 수행합니다.

이 페이지의 예시에서는 inventory 컬렉션을 사용합니다. MongoDB 인스턴스의 테스트 데이터베이스에 연결한 다음 inventory 컬렉션을 만듭니다:

이 페이지에서는 MongoDB Perl 드라이버에서 MongoDB::Collection::find() 메서드를 사용하는 쿼리 작업의 예시를 제공합니다.

이 페이지의 예시에서는 inventory 컬렉션을 사용합니다. MongoDB 인스턴스의 테스트 데이터베이스에 연결한 다음 inventory 컬렉션을 만듭니다:

이 페이지는 MongoDB PHP 라이브러리에서 MongoDB\\Collection::find() 메서드를 사용해 프로젝션으로 쿼리 작업을 실행하는 예시를 설명합니다.

이 페이지의 예시에서는 inventory 컬렉션을 사용합니다. MongoDB 인스턴스의 테스트 데이터베이스에 연결한 다음 inventory 컬렉션을 만듭니다:

이 페이지는 PyMongo Python 드라이버에서 pymongo.collection.Collection.find 메서드를 사용한 프로젝션이 포함된 쿼리 작업의 예를 제공합니다.

이 페이지의 예시에서는 inventory 컬렉션을 사용합니다. MongoDB 인스턴스의 테스트 데이터베이스에 연결한 다음 inventory 컬렉션을 만듭니다:

이 페이지에서는 MongoDB Ruby 드라이버의 Mongo::Collection#find() 메서드를 사용하여 프로젝션이 적용된 쿼리 작업의 예시를 제공합니다.

이 페이지의 예시에서는 inventory 컬렉션을 사용합니다. MongoDB 인스턴스의 테스트 데이터베이스에 연결한 다음 inventory 컬렉션을 만듭니다:

이 페이지에서는 collection.find() 메서드를 사용하여 프로젝션이 적용된 쿼리 작업의 예시를 제공합니다. 이 메서드는 MongoDB Scala 드라이버 내에 있습니다.

이 페이지의 예시에서는 inventory 컬렉션을 사용합니다. MongoDB 인스턴스의 테스트 데이터베이스에 연결한 다음 inventory 컬렉션을 만듭니다:

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

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

MongoDB Compass에서 문서를 삽입하는 방법은 문서 삽입하기를 참조하세요.

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

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

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

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

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

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

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

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

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

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

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

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

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

일치하는 문서의 모든 필드 반환

프로젝션 문서를 지정하지 않으면 db.collection.find() 메서드는 일치하는 문서의 모든 필드를 반환합니다.

프로젝션 문서를 지정하지 않으면 Compass는 일치하는 문서의 모든 필드를 반환합니다.

프로젝션을 지정하지 않으면 MongoCollection.Find() 메서드는 일치하는 문서의 모든 필드를 반환합니다.

프로젝션 을 지정하지 않으면 com.mongodb.reactivestreams가 표시됩니다. 클라이언트.MongoCollection.find 메서드는 일치하는 문서의 모든 필드를 반환합니다.

프로젝션을 지정하지않으면 com.mongodb.client.MongoCollection.find 메서드는 일치하는 문서의 모든 필드를 반환합니다.

프로젝션 문서 를 지정하지 않으면 MongoCollection.find() 메서드는 일치하는 문서의 모든 필드를 반환합니다.

프로젝션 문서를 지정하지 않는 경우 find() 메서드는 일치하는 문서의 모든 필드를 생성합니다.

프로젝션 문서를 지정하지 않으면 find() 메서드는 일치하는 문서의 모든 필드를 반환합니다.

프로젝션 문서를 지정하지 않으면 find() 메서드는 일치하는 문서의 모든 필드를 반환합니다.

프로젝션 문서를 지정하지 않으면 find 메서드는 일치하는 문서의 모든 필드를 반환합니다.

프로젝션 문서를 지정하지 않으면 find() 메서드는 일치하는 문서의 모든 필드를 반환합니다.

프로젝션을 지정하지 않으면 collection.find() 메서드는 일치하는 문서의 모든 필드를 반환합니다.

다음 예에서는 inventory 컬렉션 내 status과 "A"가 동일한 모든 문서에서 모든 필드를 반환합니다.

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

다음 표현식을 Filter 필드에 복사합니다.
```
{ status: "A" }
```
Find를 클릭합니다.

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

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

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

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

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

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

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

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

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

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

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

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

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

이 작업은 다음 SQL 문에 해당합니다.

SELECT * from inventory WHERE status = "A"

지정된 필드 및 `_id` 필드만 반환

프로젝션 문서에서 <field>를 1로 설정하여 프로젝션에 여러 필드를 명시적으로 포함할 수 있습니다. 다음 작업은 쿼리와 일치하는 모든 문서를 반환합니다. 결과 세트에서는 item, status 및 기본적으로 _id 필드만 일치하는 문서에 반환됩니다.

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

다음 표현식을 Filter 필드에 복사합니다.
```
{ status: "A" }
```
Options를 클릭하여 추가 쿼리 옵션을 엽니다.
다음 표현식을 Project 필드에 복사합니다.
```
{ item: 1, status: 1 }
```
Find를 클릭합니다.

mongoc_collection_t *collection;
bson_t *filter;
bson_t *opts;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("status", BCON_UTF8 ("A"));
opts = BCON_NEW ("projection", "{", "item", BCON_INT64 (1),
"status", BCON_INT64 (1), "}");
cursor = mongoc_collection_find_with_opts (collection, filter, opts, NULL);

다음 메서드를 적절히 호출하여 열려 있는 리소스도 정리해야 합니다.

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

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

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

프로젝션 문서 를 지정하려면 com.mongodb를 연결합니다. 클라이언트.FindIterable. 프로젝션 메서드를 find 메서드로 변경합니다. 이 예시 에서는 com.mongodb를 사용합니다. 클라이언트.model.Projections 클래스를 사용하여 프로젝션 문서를 생성합니다.

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

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

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

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

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

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

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

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

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

이 작업은 다음 SQL 문에 해당합니다.

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

`_id` 필드 미표시

다음 예시와 같이 프로젝션에서 _id 필드를 0으로 설정하여 결과에서 제거할 수 있습니다.

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

다음 표현식을 Filter 필드에 복사합니다.
```
{ status: "A" }
```
Options를 클릭하여 추가 쿼리 옵션을 엽니다.
다음 표현식을 Project 필드에 복사합니다.
```
{ item: 1, status: 1, _id: 0 }
```
Find를 클릭합니다.

mongoc_collection_t *collection;
bson_t *filter;
bson_t *opts;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("status", BCON_UTF8 ("A"));
opts = BCON_NEW ("projection", "{", "item", BCON_INT64 (1),
"status", BCON_INT64 (1),
"_id", BCON_INT64 (0), "}");
cursor = mongoc_collection_find_with_opts (collection, filter, opts, NULL);

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Exclude("_id");
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();

projection := bson.D{
	{"item", 1},
	{"status", 1},
	{"_id", 0},
}
cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"status", "A"},
	},
	options.Find().SetProjection(projection),
)

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

프로젝션 문서 를 지정하려면 com.mongodb를 연결합니다. 클라이언트.FindIterable. 프로젝션 메서드를 find 메서드로 변경합니다. 이 예시 에서는 com.mongodb를 사용합니다. 클라이언트.model.Projections 클래스를 사용하여 프로젝션 문서를 생성합니다.

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

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

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

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

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

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

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

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

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

이 작업은 다음 SQL 문에 해당합니다.

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

참고

_id 필드를 제외하고 프로젝션 문서에서는 포함 및 제외 문을 결합할 수 없습니다.

제외된 필드를 제외한 모든 필드 반환

일치하는 문서에 반환할 필드를 나열하는 대신 프로젝션을 사용하여 특정 필드를 제외할 수 있습니다. 일치하는 문서에서 status 및 instock 필드를 제외한 모든 필드를 반환하는 다음 예시는 아래를 실행합니다.

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

다음 표현식을 Filter 필드에 복사합니다.
```
{ status: "A" }
```
Options를 클릭하여 추가 쿼리 옵션을 엽니다.
다음 표현식을 Project 필드에 복사합니다.
```
{ status: 0, instock: 0 }
```
Find를 클릭합니다.

mongoc_collection_t *collection;
bson_t *filter;
bson_t *opts;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("status", BCON_UTF8 ("A"));
opts = BCON_NEW ("projection", "{", "status", BCON_INT64 (0),
"instock", BCON_INT64 (0), "}");
cursor = mongoc_collection_find_with_opts (collection, filter, opts, NULL);

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

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

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

프로젝션 문서 를 지정하려면 com.mongodb를 연결합니다. 클라이언트.FindIterable. 프로젝션 메서드를 find 메서드로 변경합니다. 이 예시 에서는 com.mongodb를 사용합니다. 클라이언트.model.Projections 클래스를 사용하여 프로젝션 문서를 생성합니다.

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

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

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

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

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

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

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

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

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

참고

_id 필드를 제외하고 프로젝션 문서에서는 포함 및 제외 문을 결합할 수 없습니다.

내장된 문서에서 특정 필드 반환

내장된 문서의 특정 필드를 반환할 수 있습니다. 점 표기법을 사용하여 포함된 필드를 참조하고 프로젝션 문서에서 1로 설정합니다.

다음 예시는 다음을 반환합니다.

_id 필드(기본적으로 반환됨)
item 필드
status 필드
size 문서의 uom 필드

uom 필드는 size 문서에 포함된 상태로 유지됩니다.

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

다음 표현식을 Filter 필드에 복사합니다.
```
{ status: "A" }
```
Options를 클릭하여 추가 쿼리 옵션을 엽니다.
다음 표현식을 Project 필드에 복사합니다.
```
{ item: 1, status: 1, "size.uom": 1 }
```
Find를 클릭합니다.

mongoc_collection_t *collection;
bson_t *filter;
bson_t *opts;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("status", BCON_UTF8 ("A"));
opts = BCON_NEW ("projection", "{", "item", BCON_INT64 (1),
"status", BCON_INT64 (1),
"size.uom", BCON_INT64 (1), "}");
cursor = mongoc_collection_find_with_opts (collection, filter, opts, NULL);

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Include("size.uom");
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();

projection := bson.D{
	{"item", 1},
	{"status", 1},
	{"size.uom", 1},
}
cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"status", "A"},
	},
	options.Find().SetProjection(projection),
)

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

프로젝션 문서 를 지정하려면 com.mongodb를 연결합니다. 클라이언트.FindIterable. 프로젝션 메서드를 find 메서드로 변경합니다. 이 예시 에서는 com.mongodb를 사용합니다. 클라이언트.model.Projections 클래스를 사용하여 프로젝션 문서를 생성합니다.

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

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

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

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

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

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

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

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

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

중첩 형식을 사용하여 임베디드 필드를 지정할 수도 있습니다. 예를 들어 { item: 1, status: 1, size: { uom: 1 } }입니다.

내장된 문서에서 특정 필드 미표시

내장된 문서에 특정 필드를 표시하지 않을 수 있습니다. 점 표기법을 사용하여 프로젝션 문서의 포함된 필드를 참조하고 0로 설정합니다.

다음 예시에서는 size 문서의 uom 필드를 제외하도록 프로젝션을 지정합니다. 다른 모든 필드는 일치하는 문서에서 반환됩니다.

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

다음 표현식을 Filter 필드에 복사합니다.
```
{ status: "A" }
```
Options를 클릭하여 추가 쿼리 옵션을 엽니다.
다음 표현식을 Project 필드에 복사합니다.
```
{ "size.uom": 0 }
```
Find를 클릭합니다.

mongoc_collection_t *collection;
bson_t *filter;
bson_t *opts;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("status", BCON_UTF8 ("A"));
opts = BCON_NEW ("projection", "{", "size.uom", BCON_INT64 (0), "}");
cursor = mongoc_collection_find_with_opts (collection, filter, opts, NULL);

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Exclude("size.uom");
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();

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

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

프로젝션 문서 를 지정하려면 com.mongodb를 연결합니다. 클라이언트.FindIterable. 프로젝션 메서드를 find 메서드로 변경합니다. 이 예시 에서는 com.mongodb를 사용합니다. 클라이언트.model.Projections 클래스를 사용하여 프로젝션 문서를 생성합니다.

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

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

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

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

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

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

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

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

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

중첩 형식을 사용하여 임베디드 필드를 지정할 수도 있습니다. 예를 들어 { size: { uom: 0 } }입니다.

배열에서 내장된 문서에 프로젝션

점 표기법을 사용하여 배열에 포함된 문서의 특정 필드를 투영할 수 있습니다.

다음 예시에서는 반환할 프로젝션을 지정합니다.

_id 필드(기본적으로 반환됨)
item 필드
status 필드
instock 배열에 포함된 문서의 qty 필드

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

다음 표현식을 Filter 필드에 복사합니다.
```
{ status: "A" }
```
Options를 클릭하여 추가 쿼리 옵션을 엽니다.
다음 표현식을 Project 필드에 복사합니다.
```
{ item: 1, status: 1, "instock.qty": 1 }
```
Find를 클릭합니다.

mongoc_collection_t *collection;
bson_t *filter;
bson_t *opts;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("status", BCON_UTF8 ("A"));
opts = BCON_NEW ("projection", "{", "item", BCON_INT64 (1),
"status", BCON_INT64 (1),
"instock.qty", BCON_INT64 (1), "}");
cursor = mongoc_collection_find_with_opts (collection, filter, opts, NULL);

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Include("instock.qty");
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();

projection := bson.D{
	{"item", 1},
	{"status", 1},
	{"instock.qty", 1},
}
cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"status", "A"},
	},
	options.Find().SetProjection(projection),
)

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

프로젝션 문서 를 지정하려면 com.mongodb를 연결합니다. 클라이언트.FindIterable. 프로젝션 메서드를 find 메서드로 변경합니다. 이 예시 에서는 com.mongodb를 사용합니다. 클라이언트.model.Projections 클래스를 사용하여 프로젝션 문서를 생성합니다.

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

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

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

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

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

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

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

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

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

반환된 배열에 프로젝트별 배열 요소 프로젝션

배열이 포함된 필드의 경우 MongoDB는 배열 조작을 위해 다음 프로젝션 연산자를 제공합니다: $elemMatch, $slice, $

다음 예시에서는 $slice 프로젝션 연산자를 사용하여 instock 배열의 마지막 요소를 반환합니다:

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

다음 표현식을 Filter 필드에 복사합니다.
```
{ status: "A" }
```
Options를 클릭하여 추가 쿼리 옵션을 엽니다.
다음 표현식을 Project 필드에 복사합니다.
```
{ item: 1, status: 1, instock: { $slice: -1 } }
```
Find를 클릭합니다.

mongoc_collection_t *collection;
bson_t *filter;
bson_t *opts;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("status", BCON_UTF8 ("A"));
opts = BCON_NEW ("projection", "{", "item", BCON_INT64 (1),
"status", BCON_INT64 (1),
"instock", "{",
"$slice", BCON_INT64 (-1),
"}", "}");
cursor = mongoc_collection_find_with_opts (collection, filter, opts, NULL);

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Slice("instock", -1);
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();

projection := bson.D{
	{"item", 1},
	{"status", 1},
	{"instock", bson.D{
		{"$slice", -1},
	}},
}
cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"status", "A"},
	},
	options.Find().SetProjection(projection),
)

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

프로젝션 문서 를 지정하려면 com.mongodb를 연결합니다. 클라이언트.FindIterable. 프로젝션 메서드를 find 메서드로 변경합니다. 이 예시 에서는 com.mongodb를 사용합니다. 클라이언트.model.Projections 클래스를 사용하여 프로젝션 문서를 생성합니다.

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

프로젝션 문서 를 지정하려면 FindFlow를 연결합니다. 프로젝션() 메서드를 find() 메서드로 변경합니다. 이 예시 에서는 com.mongodb를 사용합니다. 클라이언트.model.Projections 클래스를 사용하여 프로젝션 문서를 생성합니다.

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

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

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

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

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

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

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

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

$elemMatch, $slice 및 $ 는 반환된 배열에 포함할 특정 요소를 프로젝션하는 데 사용할 수 있는 유일한 연산자입니다. 예를 들어, 배열 인덱스를 사용하여 특정 배열 요소를 프로젝션할 수 없습니다 . 예: { "instock.0": 1 } 프로젝션은 첫 번째 요소가 있는 배열을 프로젝션하지 않습니다 .

배열이 포함된 필드의 경우 MongoDB는 배열 조작을 위해 다음 프로젝션 연산자를 제공합니다: $elemMatch, $slice, $

다음 예시에서는 $slice 프로젝션 연산자를 사용하여 instock 배열의 마지막 요소를 반환합니다:

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

다음 표현식을 Filter 필드에 복사합니다.
```
{ status: "A" }
```
Options를 클릭하여 추가 쿼리 옵션을 엽니다.
다음 표현식을 Project 필드에 복사합니다.
```
{ item: 1, status: 1, instock: { $slice: -1 } }
```
Find를 클릭합니다.

mongoc_collection_t *collection;
bson_t *filter;
bson_t *opts;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("status", BCON_UTF8 ("A"));
opts = BCON_NEW ("projection", "{", "item", BCON_INT64 (1),
"status", BCON_INT64 (1),
"instock", "{",
"$slice", BCON_INT64 (-1),
"}", "}");
cursor = mongoc_collection_find_with_opts (collection, filter, opts, NULL);

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Slice("instock", -1);
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();

projection := bson.D{
	{"item", 1},
	{"status", 1},
	{"instock", bson.D{
		{"$slice", -1},
	}},
}
cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"status", "A"},
	},
	options.Find().SetProjection(projection),
)

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

프로젝션 문서 를 지정하려면 com.mongodb를 연결합니다. 클라이언트.FindIterable. 프로젝션 메서드를 find 메서드로 변경합니다. 이 예시 에서는 com.mongodb를 사용합니다. 클라이언트.model.Projections 클래스를 사용하여 프로젝션 문서를 생성합니다.

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

프로젝션 문서 를 지정하려면 FindFlow를 연결합니다. 프로젝션() 메서드를 find() 메서드로 변경합니다. 이 예시 에서는 com.mongodb를 사용합니다. 클라이언트.model.Projections 클래스를 사용하여 프로젝션 문서를 생성합니다.

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

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

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

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

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

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

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

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

배열이 포함된 필드의 경우 MongoDB는 배열 조작을 위해 다음 프로젝션 연산자를 제공합니다: $elemMatch, $slice, $

다음 예시에서는 $slice 프로젝션 연산자를 사용하여 instock 배열의 마지막 요소를 반환합니다:

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

다음 표현식을 Filter 필드에 복사합니다.
```
{ status: "A" }
```
Options를 클릭하여 추가 쿼리 옵션을 엽니다.
다음 표현식을 Project 필드에 복사합니다.
```
{ item: 1, status: 1, instock: { $slice: -1 } }
```
Find를 클릭합니다.

mongoc_collection_t *collection;
bson_t *filter;
bson_t *opts;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("status", BCON_UTF8 ("A"));
opts = BCON_NEW ("projection", "{", "item", BCON_INT64 (1),
"status", BCON_INT64 (1),
"instock", "{",
"$slice", BCON_INT64 (-1),
"}", "}");
cursor = mongoc_collection_find_with_opts (collection, filter, opts, NULL);

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Slice("instock", -1);
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();

projection := bson.D{
	{"item", 1},
	{"status", 1},
	{"instock", bson.D{
		{"$slice", -1},
	}},
}
cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"status", "A"},
	},
	options.Find().SetProjection(projection),
)

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

프로젝션 문서 를 지정하려면 com.mongodb를 연결합니다. 클라이언트.FindIterable. 프로젝션 메서드를 find 메서드로 변경합니다. 이 예시 에서는 com.mongodb를 사용합니다. 클라이언트.model.Projections 클래스를 사용하여 프로젝션 문서를 생성합니다.

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

프로젝션 문서 를 지정하려면 FindFlow를 연결합니다. 프로젝션() 메서드를 find() 메서드로 변경합니다. 이 예시 에서는 com.mongodb를 사용합니다. 클라이언트.model.Projections 클래스를 사용하여 프로젝션 문서를 생성합니다.

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

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

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

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

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

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

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

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

$elemMatch, $slice 및 $ 는 반환된 배열 에 포함할 특정 요소를 프로젝트 하는 데 사용할 수 있는 유일한 연산자입니다.

예를 들어, 다음 작업은 첫 번째 요소가 있는 배열을 프로젝트하지 않습니다.

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

배열이 포함된 필드의 경우 MongoDB는 배열 조작을 위해 다음 프로젝션 연산자를 제공합니다: $elemMatch, $slice, $

다음 예시에서는 $slice 프로젝션 연산자를 사용하여 instock 배열의 마지막 요소를 반환합니다:

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

다음 표현식을 Filter 필드에 복사합니다.
```
{ status: "A" }
```
Options를 클릭하여 추가 쿼리 옵션을 엽니다.
다음 표현식을 Project 필드에 복사합니다.
```
{ item: 1, status: 1, instock: { $slice: -1 } }
```
Find를 클릭합니다.

mongoc_collection_t *collection;
bson_t *filter;
bson_t *opts;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("status", BCON_UTF8 ("A"));
opts = BCON_NEW ("projection", "{", "item", BCON_INT64 (1),
"status", BCON_INT64 (1),
"instock", "{",
"$slice", BCON_INT64 (-1),
"}", "}");
cursor = mongoc_collection_find_with_opts (collection, filter, opts, NULL);

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Slice("instock", -1);
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();

projection := bson.D{
	{"item", 1},
	{"status", 1},
	{"instock", bson.D{
		{"$slice", -1},
	}},
}
cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"status", "A"},
	},
	options.Find().SetProjection(projection),
)

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

프로젝션 문서 를 지정하려면 com.mongodb를 연결합니다. 클라이언트.FindIterable. 프로젝션 메서드를 find 메서드로 변경합니다. 이 예시 에서는 com.mongodb를 사용합니다. 클라이언트.model.Projections 클래스를 사용하여 프로젝션 문서를 생성합니다.

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

프로젝션 문서 를 지정하려면 FindFlow를 연결합니다. 프로젝션() 메서드를 find() 메서드로 변경합니다. 이 예시 에서는 com.mongodb를 사용합니다. 클라이언트.model.Projections 클래스를 사용하여 프로젝션 문서를 생성합니다.

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

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

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

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

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

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

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

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

$elemMatch, $slice 및 $ 는 반환된 배열에 포함할 특정 요소를 프로젝션하는 데 사용할 수 있는 유일한 연산자입니다. 예를 들어, 배열 인덱스를 사용하여 특정 배열 요소를 프로젝션할 수 없습니다 . 예: include("instock.0") 프로젝션은 첫 번째 요소가 있는 배열을 프로젝션하지 않습니다 .

배열이 포함된 필드의 경우 MongoDB는 배열 조작을 위해 다음 프로젝션 연산자를 제공합니다: $elemMatch, $slice, $

다음 예시에서는 $slice 프로젝션 연산자를 사용하여 instock 배열의 마지막 요소를 반환합니다:

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

다음 표현식을 Filter 필드에 복사합니다.
```
{ status: "A" }
```
Options를 클릭하여 추가 쿼리 옵션을 엽니다.
다음 표현식을 Project 필드에 복사합니다.
```
{ item: 1, status: 1, instock: { $slice: -1 } }
```
Find를 클릭합니다.

mongoc_collection_t *collection;
bson_t *filter;
bson_t *opts;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("status", BCON_UTF8 ("A"));
opts = BCON_NEW ("projection", "{", "item", BCON_INT64 (1),
"status", BCON_INT64 (1),
"instock", "{",
"$slice", BCON_INT64 (-1),
"}", "}");
cursor = mongoc_collection_find_with_opts (collection, filter, opts, NULL);

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Slice("instock", -1);
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();

projection := bson.D{
	{"item", 1},
	{"status", 1},
	{"instock", bson.D{
		{"$slice", -1},
	}},
}
cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"status", "A"},
	},
	options.Find().SetProjection(projection),
)

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

프로젝션 문서 를 지정하려면 com.mongodb를 연결합니다. 클라이언트.FindIterable. 프로젝션 메서드를 find 메서드로 변경합니다. 이 예시 에서는 com.mongodb를 사용합니다. 클라이언트.model.Projections 클래스를 사용하여 프로젝션 문서를 생성합니다.

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

프로젝션 문서 를 지정하려면 FindFlow를 연결합니다. 프로젝션() 메서드를 find() 메서드로 변경합니다. 이 예시 에서는 com.mongodb를 사용합니다. 클라이언트.model.Projections 클래스를 사용하여 프로젝션 문서를 생성합니다.

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

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

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

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

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

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

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

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

$elemMatch, $slice 및 $ 는 반환된 배열에 포함할 특정 요소를 프로젝션하는 데 사용할 수 있는 유일한 연산자입니다. 예를 들어, 배열 인덱스를 사용하여 특정 배열 요소를 프로젝션할 수 없습니다 . 예: include("instock.0") 프로젝션은 첫 번째 요소가 있는 배열을 프로젝션하지 않습니다 .

배열이 포함된 필드의 경우 MongoDB는 배열 조작을 위해 다음 프로젝션 연산자를 제공합니다: $elemMatch, $slice, $

다음 예시에서는 $slice 프로젝션 연산자를 사용하여 instock 배열의 마지막 요소를 반환합니다:

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

다음 표현식을 Filter 필드에 복사합니다.
```
{ status: "A" }
```
Options를 클릭하여 추가 쿼리 옵션을 엽니다.
다음 표현식을 Project 필드에 복사합니다.
```
{ item: 1, status: 1, instock: { $slice: -1 } }
```
Find를 클릭합니다.

mongoc_collection_t *collection;
bson_t *filter;
bson_t *opts;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("status", BCON_UTF8 ("A"));
opts = BCON_NEW ("projection", "{", "item", BCON_INT64 (1),
"status", BCON_INT64 (1),
"instock", "{",
"$slice", BCON_INT64 (-1),
"}", "}");
cursor = mongoc_collection_find_with_opts (collection, filter, opts, NULL);

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Slice("instock", -1);
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();

projection := bson.D{
	{"item", 1},
	{"status", 1},
	{"instock", bson.D{
		{"$slice", -1},
	}},
}
cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"status", "A"},
	},
	options.Find().SetProjection(projection),
)

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

프로젝션 문서 를 지정하려면 com.mongodb를 연결합니다. 클라이언트.FindIterable. 프로젝션 메서드를 find 메서드로 변경합니다. 이 예시 에서는 com.mongodb를 사용합니다. 클라이언트.model.Projections 클래스를 사용하여 프로젝션 문서를 생성합니다.

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

프로젝션 문서 를 지정하려면 FindFlow를 연결합니다. 프로젝션() 메서드를 find() 메서드로 변경합니다. 이 예시 에서는 com.mongodb를 사용합니다. 클라이언트.model.Projections 클래스를 사용하여 프로젝션 문서를 생성합니다.

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

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

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

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

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

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

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

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

$elemMatch, $slice 및 $ 는 반환된 배열에 포함할 특정 요소를 프로젝션하는 데 사용할 수 있는 유일한 연산자입니다. 예를 들어, 배열 인덱스를 사용하여 특정 배열 요소를 프로젝션할 수 없습니다 . 예: include("instock.0") 프로젝션은 첫 번째 요소가 있는 배열을 프로젝션하지 않습니다 .

배열이 포함된 필드의 경우 MongoDB는 배열 조작을 위해 다음 프로젝션 연산자를 제공합니다: $elemMatch, $slice, $

다음 예시에서는 $slice 프로젝션 연산자를 사용하여 instock 배열의 마지막 요소를 반환합니다:

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

다음 표현식을 Filter 필드에 복사합니다.
```
{ status: "A" }
```
Options를 클릭하여 추가 쿼리 옵션을 엽니다.
다음 표현식을 Project 필드에 복사합니다.
```
{ item: 1, status: 1, instock: { $slice: -1 } }
```
Find를 클릭합니다.

mongoc_collection_t *collection;
bson_t *filter;
bson_t *opts;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("status", BCON_UTF8 ("A"));
opts = BCON_NEW ("projection", "{", "item", BCON_INT64 (1),
"status", BCON_INT64 (1),
"instock", "{",
"$slice", BCON_INT64 (-1),
"}", "}");
cursor = mongoc_collection_find_with_opts (collection, filter, opts, NULL);

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Slice("instock", -1);
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();

projection := bson.D{
	{"item", 1},
	{"status", 1},
	{"instock", bson.D{
		{"$slice", -1},
	}},
}
cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"status", "A"},
	},
	options.Find().SetProjection(projection),
)

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

프로젝션 문서 를 지정하려면 com.mongodb를 연결합니다. 클라이언트.FindIterable. 프로젝션 메서드를 find 메서드로 변경합니다. 이 예시 에서는 com.mongodb를 사용합니다. 클라이언트.model.Projections 클래스를 사용하여 프로젝션 문서를 생성합니다.

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

프로젝션 문서 를 지정하려면 FindFlow를 연결합니다. 프로젝션() 메서드를 find() 메서드로 변경합니다. 이 예시 에서는 com.mongodb를 사용합니다. 클라이언트.model.Projections 클래스를 사용하여 프로젝션 문서를 생성합니다.

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

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

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

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

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

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

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

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

$elemMatch, $slice 및 $ 는 반환된 배열에 포함할 특정 요소를 프로젝션하는 데 사용할 수 있는 유일한 연산자입니다. 예를 들어, 배열 인덱스를 사용하여 특정 배열 요소를 프로젝션할 수 없습니다 . 예: include("instock.0") 프로젝션은 첫 번째 요소가 있는 배열을 프로젝션하지 않습니다 .

배열이 포함된 필드의 경우 MongoDB는 배열 조작을 위해 다음 프로젝션 연산자를 제공합니다: $elemMatch, $slice, $

다음 예시에서는 $slice 프로젝션 연산자를 사용하여 instock 배열의 마지막 요소를 반환합니다:

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

다음 표현식을 Filter 필드에 복사합니다.
```
{ status: "A" }
```
Options를 클릭하여 추가 쿼리 옵션을 엽니다.
다음 표현식을 Project 필드에 복사합니다.
```
{ item: 1, status: 1, instock: { $slice: -1 } }
```
Find를 클릭합니다.

mongoc_collection_t *collection;
bson_t *filter;
bson_t *opts;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("status", BCON_UTF8 ("A"));
opts = BCON_NEW ("projection", "{", "item", BCON_INT64 (1),
"status", BCON_INT64 (1),
"instock", "{",
"$slice", BCON_INT64 (-1),
"}", "}");
cursor = mongoc_collection_find_with_opts (collection, filter, opts, NULL);

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Slice("instock", -1);
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();

projection := bson.D{
	{"item", 1},
	{"status", 1},
	{"instock", bson.D{
		{"$slice", -1},
	}},
}
cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"status", "A"},
	},
	options.Find().SetProjection(projection),
)

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

프로젝션 문서 를 지정하려면 com.mongodb를 연결합니다. 클라이언트.FindIterable. 프로젝션 메서드를 find 메서드로 변경합니다. 이 예시 에서는 com.mongodb를 사용합니다. 클라이언트.model.Projections 클래스를 사용하여 프로젝션 문서를 생성합니다.

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

프로젝션 문서 를 지정하려면 FindFlow를 연결합니다. 프로젝션() 메서드를 find() 메서드로 변경합니다. 이 예시 에서는 com.mongodb를 사용합니다. 클라이언트.model.Projections 클래스를 사용하여 프로젝션 문서를 생성합니다.

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

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

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

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

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

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

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

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

$elemMatch, $slice 및 $ 는 반환된 배열에 포함할 특정 요소를 프로젝션하는 데 사용할 수 있는 유일한 연산자입니다. 예를 들어, 배열 인덱스를 사용하여 특정 배열 요소를 프로젝션할 수 없습니다 . 예: { "instock.0": 1 } 프로젝션은 첫 번째 요소가 있는 배열을 프로젝션하지 않습니다 .

배열이 포함된 필드의 경우 MongoDB는 배열 조작을 위해 다음 프로젝션 연산자를 제공합니다: $elemMatch, $slice, $

다음 예시에서는 $slice 프로젝션 연산자를 사용하여 instock 배열의 마지막 요소를 반환합니다:

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

다음 표현식을 Filter 필드에 복사합니다.
```
{ status: "A" }
```
Options를 클릭하여 추가 쿼리 옵션을 엽니다.
다음 표현식을 Project 필드에 복사합니다.
```
{ item: 1, status: 1, instock: { $slice: -1 } }
```
Find를 클릭합니다.

mongoc_collection_t *collection;
bson_t *filter;
bson_t *opts;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("status", BCON_UTF8 ("A"));
opts = BCON_NEW ("projection", "{", "item", BCON_INT64 (1),
"status", BCON_INT64 (1),
"instock", "{",
"$slice", BCON_INT64 (-1),
"}", "}");
cursor = mongoc_collection_find_with_opts (collection, filter, opts, NULL);

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Slice("instock", -1);
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();

projection := bson.D{
	{"item", 1},
	{"status", 1},
	{"instock", bson.D{
		{"$slice", -1},
	}},
}
cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"status", "A"},
	},
	options.Find().SetProjection(projection),
)

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

프로젝션 문서 를 지정하려면 com.mongodb를 연결합니다. 클라이언트.FindIterable. 프로젝션 메서드를 find 메서드로 변경합니다. 이 예시 에서는 com.mongodb를 사용합니다. 클라이언트.model.Projections 클래스를 사용하여 프로젝션 문서를 생성합니다.

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

프로젝션 문서 를 지정하려면 FindFlow를 연결합니다. 프로젝션() 메서드를 find() 메서드로 변경합니다. 이 예시 에서는 com.mongodb를 사용합니다. 클라이언트.model.Projections 클래스를 사용하여 프로젝션 문서를 생성합니다.

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

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

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

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

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

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

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

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

$elemMatch, $slice 및 $ 는 반환된 배열에 포함할 특정 요소를 프로젝션하는 데 사용할 수 있는 유일한 연산자입니다. 예를 들어, 배열 인덱스를 사용하여 특정 배열 요소를 프로젝션할 수 없습니다 . 예: { "instock.0" => 1 } 프로젝션은 첫 번째 요소가 있는 배열을 프로젝션하지 않습니다 .

배열이 포함된 필드의 경우 MongoDB는 배열 조작을 위해 다음 프로젝션 연산자를 제공합니다: $elemMatch, $slice, $

다음 예시에서는 $slice 프로젝션 연산자를 사용하여 instock 배열의 마지막 요소를 반환합니다:

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

다음 표현식을 Filter 필드에 복사합니다.
```
{ status: "A" }
```
Options를 클릭하여 추가 쿼리 옵션을 엽니다.
다음 표현식을 Project 필드에 복사합니다.
```
{ item: 1, status: 1, instock: { $slice: -1 } }
```
Find를 클릭합니다.

mongoc_collection_t *collection;
bson_t *filter;
bson_t *opts;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("status", BCON_UTF8 ("A"));
opts = BCON_NEW ("projection", "{", "item", BCON_INT64 (1),
"status", BCON_INT64 (1),
"instock", "{",
"$slice", BCON_INT64 (-1),
"}", "}");
cursor = mongoc_collection_find_with_opts (collection, filter, opts, NULL);

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Slice("instock", -1);
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();

projection := bson.D{
	{"item", 1},
	{"status", 1},
	{"instock", bson.D{
		{"$slice", -1},
	}},
}
cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"status", "A"},
	},
	options.Find().SetProjection(projection),
)

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

프로젝션 문서 를 지정하려면 com.mongodb를 연결합니다. 클라이언트.FindIterable. 프로젝션 메서드를 find 메서드로 변경합니다. 이 예시 에서는 com.mongodb를 사용합니다. 클라이언트.model.Projections 클래스를 사용하여 프로젝션 문서를 생성합니다.

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

프로젝션 문서 를 지정하려면 FindFlow를 연결합니다. 프로젝션() 메서드를 find() 메서드로 변경합니다. 이 예시 에서는 com.mongodb를 사용합니다. 클라이언트.model.Projections 클래스를 사용하여 프로젝션 문서를 생성합니다.

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

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

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

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

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

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

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

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

$elemMatch, $slice 및 $ 는 반환된 배열에 포함할 특정 요소를 프로젝션하는 데 사용할 수 있는 유일한 연산자입니다. 예를 들어, 배열 인덱스를 사용하여 특정 배열 요소를 프로젝션할 수 없습니다 . 예: [ "instock.0" => 1 ] 프로젝션은 첫 번째 요소가 있는 배열을 프로젝션하지 않습니다 .

배열이 포함된 필드의 경우 MongoDB는 배열 조작을 위해 다음 프로젝션 연산자를 제공합니다: $elemMatch, $slice, $

다음 예시에서는 $slice 프로젝션 연산자를 사용하여 instock 배열의 마지막 요소를 반환합니다:

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

다음 표현식을 Filter 필드에 복사합니다.
```
{ status: "A" }
```
Options를 클릭하여 추가 쿼리 옵션을 엽니다.
다음 표현식을 Project 필드에 복사합니다.
```
{ item: 1, status: 1, instock: { $slice: -1 } }
```
Find를 클릭합니다.

mongoc_collection_t *collection;
bson_t *filter;
bson_t *opts;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("status", BCON_UTF8 ("A"));
opts = BCON_NEW ("projection", "{", "item", BCON_INT64 (1),
"status", BCON_INT64 (1),
"instock", "{",
"$slice", BCON_INT64 (-1),
"}", "}");
cursor = mongoc_collection_find_with_opts (collection, filter, opts, NULL);

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Slice("instock", -1);
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();

projection := bson.D{
	{"item", 1},
	{"status", 1},
	{"instock", bson.D{
		{"$slice", -1},
	}},
}
cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"status", "A"},
	},
	options.Find().SetProjection(projection),
)

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

프로젝션 문서 를 지정하려면 com.mongodb를 연결합니다. 클라이언트.FindIterable. 프로젝션 메서드를 find 메서드로 변경합니다. 이 예시 에서는 com.mongodb를 사용합니다. 클라이언트.model.Projections 클래스를 사용하여 프로젝션 문서를 생성합니다.

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

프로젝션 문서 를 지정하려면 FindFlow를 연결합니다. 프로젝션() 메서드를 find() 메서드로 변경합니다. 이 예시 에서는 com.mongodb를 사용합니다. 클라이언트.model.Projections 클래스를 사용하여 프로젝션 문서를 생성합니다.

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

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

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

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

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

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

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

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

$elemMatch, $slice 및 $ 는 반환된 배열에 포함할 특정 요소를 프로젝션하는 데 사용할 수 있는 유일한 연산자입니다. 예를 들어, 배열 인덱스를 사용하여 특정 배열 요소를 프로젝션할 수 없습니다 . 예: { "instock.0": 1 } 프로젝션은 첫 번째 요소가 있는 배열을 프로젝션하지 않습니다 .

배열이 포함된 필드의 경우 MongoDB는 배열 조작을 위해 다음 프로젝션 연산자를 제공합니다: $elemMatch, $slice, $

다음 예시에서는 $slice 프로젝션 연산자를 사용하여 instock 배열의 마지막 요소를 반환합니다:

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

다음 표현식을 Filter 필드에 복사합니다.
```
{ status: "A" }
```
Options를 클릭하여 추가 쿼리 옵션을 엽니다.
다음 표현식을 Project 필드에 복사합니다.
```
{ item: 1, status: 1, instock: { $slice: -1 } }
```
Find를 클릭합니다.

mongoc_collection_t *collection;
bson_t *filter;
bson_t *opts;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("status", BCON_UTF8 ("A"));
opts = BCON_NEW ("projection", "{", "item", BCON_INT64 (1),
"status", BCON_INT64 (1),
"instock", "{",
"$slice", BCON_INT64 (-1),
"}", "}");
cursor = mongoc_collection_find_with_opts (collection, filter, opts, NULL);

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Slice("instock", -1);
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();

projection := bson.D{
	{"item", 1},
	{"status", 1},
	{"instock", bson.D{
		{"$slice", -1},
	}},
}
cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"status", "A"},
	},
	options.Find().SetProjection(projection),
)

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

프로젝션 문서 를 지정하려면 com.mongodb를 연결합니다. 클라이언트.FindIterable. 프로젝션 메서드를 find 메서드로 변경합니다. 이 예시 에서는 com.mongodb를 사용합니다. 클라이언트.model.Projections 클래스를 사용하여 프로젝션 문서를 생성합니다.

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

프로젝션 문서 를 지정하려면 FindFlow를 연결합니다. 프로젝션() 메서드를 find() 메서드로 변경합니다. 이 예시 에서는 com.mongodb를 사용합니다. 클라이언트.model.Projections 클래스를 사용하여 프로젝션 문서를 생성합니다.

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

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

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

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

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

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

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

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

$elemMatch, $slice 및 $ 는 반환된 배열에 포함할 특정 요소를 프로젝션하는 데 사용할 수 있는 유일한 연산자입니다. 예를 들어, 배열 인덱스를 사용하여 특정 배열 요소를 프로젝션할 수 없습니다 . 예: { "instock.0" => 1 } 프로젝션은 첫 번째 요소가 있는 배열을 프로젝션하지 않습니다 .

배열이 포함된 필드의 경우 MongoDB는 배열 조작을 위해 다음 프로젝션 연산자를 제공합니다: $elemMatch, $slice, $

다음 예시에서는 $slice 프로젝션 연산자를 사용하여 instock 배열의 마지막 요소를 반환합니다:

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

다음 표현식을 Filter 필드에 복사합니다.
```
{ status: "A" }
```
Options를 클릭하여 추가 쿼리 옵션을 엽니다.
다음 표현식을 Project 필드에 복사합니다.
```
{ item: 1, status: 1, instock: { $slice: -1 } }
```
Find를 클릭합니다.

mongoc_collection_t *collection;
bson_t *filter;
bson_t *opts;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("status", BCON_UTF8 ("A"));
opts = BCON_NEW ("projection", "{", "item", BCON_INT64 (1),
"status", BCON_INT64 (1),
"instock", "{",
"$slice", BCON_INT64 (-1),
"}", "}");
cursor = mongoc_collection_find_with_opts (collection, filter, opts, NULL);

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Slice("instock", -1);
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();

projection := bson.D{
	{"item", 1},
	{"status", 1},
	{"instock", bson.D{
		{"$slice", -1},
	}},
}
cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"status", "A"},
	},
	options.Find().SetProjection(projection),
)

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

프로젝션 문서 를 지정하려면 com.mongodb를 연결합니다. 클라이언트.FindIterable. 프로젝션 메서드를 find 메서드로 변경합니다. 이 예시 에서는 com.mongodb를 사용합니다. 클라이언트.model.Projections 클래스를 사용하여 프로젝션 문서를 생성합니다.

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

프로젝션 문서 를 지정하려면 FindFlow를 연결합니다. 프로젝션() 메서드를 find() 메서드로 변경합니다. 이 예시 에서는 com.mongodb를 사용합니다. 클라이언트.model.Projections 클래스를 사용하여 프로젝션 문서를 생성합니다.

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

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

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

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

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

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

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

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

$elemMatch, $slice 및 $ 는 반환된 배열에 포함할 특정 요소를 프로젝션하는 데 사용할 수 있는 유일한 연산자입니다. 예를 들어, 배열 인덱스를 사용하여 특정 배열 요소를 프로젝션할 수 없습니다 . 예: include("instock.0") 프로젝션은 첫 번째 요소가 있는 배열을 프로젝션하지 않습니다 .

집계 표현식으로 필드 투영

쿼리 프로젝션에서 집계 표현식을 지정할 수 있습니다. 집계 표현식을 사용하면 새 필드를 투영하고 기존 필드의 값을 수정할 수 있습니다.

예를 들어 다음 작업은 집계 표현식을 사용하여 status 필드의 값을 재정의하고 새 필드 area 및 reportNumber를 투영합니다.

참고

다음 예시에서는 MongoDB Shell 구문을 사용합니다. 집계를 사용한 프로젝션의 드라이버 예시는 드라이버 문서를 참조하세요.

db.inventory.find(
   { },
   {
      _id: 0,
      item: 1,
      status: {
         $switch: {
            branches: [
               {
                  case: { $eq: [ "$status", "A" ] },
                  then: "Available"
               },
               {
                  case: { $eq: [ "$status", "D" ] },
                  then: "Discontinued"
               },
            ],
            default: "No status found"
         }
      },
      area: {
         $concat: [
            { $toString: { $multiply: [ "$size.h", "$size.w" ] } },
            " ",
            "$size.uom"
         ]
      },
      reportNumber: { $literal: 1 }
   }
)

[
   {
      item: 'journal',
      status: 'Available',
      area: '294 cm',
      reportNumber: 1
   },
   {
      item: 'planner',
      status: 'Discontinued',
      area: '685.5 cm',
      reportNumber: 1
   },
   {
      item: 'notebook',
      status: 'Available',
      area: '93.5 in',
      reportNumber: 1
   },
   {
      item: 'paper',
      status: 'Discontinued',
      area: '93.5 in',
      reportNumber: 1
   },
   {
      item: 'postcard',
      status: 'Available',
      area: '152.5 cm',
      reportNumber: 1
   }
]

MongoDB Atlas를 사용하여 쿼리에서 반환할 프로젝트 필드

이 섹션의 예에서는 샘플 영화 데이터세트를 사용합니다. MongoDB Atlas 배포서버에 샘플 데이터세트를 로드하는 방법을 알아보려면 샘플 데이터 로드를 참조하세요.

MongoDB Atlas의 쿼리에서 반환할 필드를 프로젝트하려면 다음 단계를 따르세요.

1

MongoDB Atlas UI에서 Clusters 프로젝트의 페이지로 이동합니다.

아직 표시되지 않은 경우 탐색 표시줄의 Organizations 메뉴에서 원하는 프로젝트가 포함된 조직을 선택합니다.
아직 표시되지 않은 경우 내비게이션 바의 Projects 메뉴에서 프로젝트를 선택합니다.
아직 표시되지 않은 경우 사이드바에서 Clusters를 클릭합니다.
Clusters(클러스터) 페이지가 표시됩니다.

2

컬렉션으로 이동합니다.

샘플 데이터가 포함된 클러스터의 경우 Browse Collections 을 클릭합니다.
왼쪽 탐색 창에서 sample_mflix 데이터베이스를 선택합니다.
movies 컬렉션을 선택합니다.

3

필터 필드 지정

Filter 필드의 오른쪽에 있는 More Options 을 클릭합니다.
쿼리 필터를 지정합니다.
Filter 필드에 쿼리 필터 문서를 지정합니다. 쿼리 필터 문서는 쿼리 연산자를 사용하여 검색 조건을 지정합니다.
다음 쿼리 필터 문서를 Filter 검색 바에 복사합니다.
```
{ year: 1924 }
```

4

프로젝트할 필드 지정

쿼리 결과에서 반환할 필드를 지정합니다.

다음 프로젝트 문서를 Project 표시줄에 복사합니다.

{ title: 1, plot: 1 }

5

적용을 클릭합니다.

이 쿼리 필터는 year 필드가 1924 와 일치하는 sample_mflix.movies collection의 모든 문서에 대해 다음 필드를 반환합니다.

_id
title
plot

MongoDB Atlas는 기본적으로 _id 필드를 반환합니다. _id 필드를 생략하려면 다음 프로젝트 문서를 Project 표시줄에 복사하고 Apply 을 클릭합니다.

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

추가 고려 사항

MongoDB는 프로젝션과 관련하여 추가 제한 사항을 시행합니다. 자세한 내용은 프로젝션 제한 사항을 참조하세요.