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

이 페이지의 내용

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

지정된 필드 및 _id 필드만 반환
_id 필드 억제
제외된 필드를 제외한 모든 필드 반환
포함된 문서에서 특정 필드 반환
포함된 문서에서 특정 필드 미표시
배열에서 포함된 문서에 프로젝션
반환된 배열에 프로젝트별 배열 요소 프로젝션
집계 표현식으로 필드 투영
추가 고려 사항

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

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

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

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

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

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

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

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

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

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

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

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

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

팁

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

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

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

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

이 페이지에서는 Collection.find() 메서드를 사용하여 프로젝션을 사용하는 쿼리 작업의 예를 제공합니다. 메서드를 호출합니다.

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

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

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

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

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

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

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

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

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

이 페이지에서는 collection.find() 메서드를 사용하여 프로젝션을 사용하는 쿼리 작업의 예를 제공합니다. MongoDB 스칼라 드라이버 의 메서드 .

이 페이지의 예제에서는 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에서 문서를 삽입하는 방법은 문서 삽입하기를 참조하세요.

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

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.client.MongoCollection.find 메서드는 일치하는 문서의 모든 필드를 반환합니다.

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

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

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

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

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

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

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

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

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

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

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

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를 클릭합니다.

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.client.FindIterable.projection 메서드를 메서드로 find 변경합니다. 이 예제에서는 com.mongodb.client.model.Projections 클래스를 사용하여 프로젝션 문서를 생성합니다.

findIterable = 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를 클릭합니다.

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

findIterable = 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를 클릭합니다.

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

findIterable = 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를 클릭합니다.

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

findIterable = 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를 클릭합니다.

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

findIterable = 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를 클릭합니다.

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

findIterable = 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를 클릭합니다.

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

findIterable = 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를 클릭합니다.

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

findIterable = 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를 클릭합니다.

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

findIterable = 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를 클릭합니다.

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

findIterable = 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를 클릭합니다.

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

findIterable = 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를 클릭합니다.

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

findIterable = 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를 클릭합니다.

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

findIterable = 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를 클릭합니다.

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

findIterable = 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를 클릭합니다.

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

findIterable = 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를 클릭합니다.

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

findIterable = 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를 클릭합니다.

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

findIterable = 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를 클릭합니다.

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

findIterable = 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)))

집계 표현식으로 필드 투영

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

예를 들어 다음 작업은 집계 표현식을 사용하여 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는 프로젝션과 관련하여 추가 제한 사항을 시행합니다. 자세한 내용은 프로젝션 제한 사항을 참조하세요.

팁

다음도 참조하세요.

돌아가기

내장된 문서 배열

Null 또는 누락된 필드

팁

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

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

필드 표시 안 _id 함

참고

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

참고

포함된 문서에서 특정 필드 반환

포함된 문서에서 특정 필드 미표시

배열에서 포함된 문서에 프로젝션

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

집계 표현식으로 필드 투영

참고

추가 고려 사항

팁

다음도 참조하세요.

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

필드 표시 안 `_id` 함