Docs Menu
Docs Home
/
MongoDB 매뉴얼
/
CRUD 작업
/
쿼리

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

이 페이지의 내용

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

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

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

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

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

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

이 페이지의 예시에서는 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 컬렉션을 만듭니다:

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

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가 표시됩니다. 클라이언트.MongoCollection.find 메서드는 일치하는 문서의 모든 필드를 반환합니다.

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

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

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

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

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

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

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

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

  1. 다음 표현식을 Filter 필드에 복사합니다.

    { status: "A" }

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

  1. 다음 표현식을 Filter 필드에 복사합니다.

    { status: "A" }

  2. Options를 클릭하여 추가 쿼리 옵션을 엽니다.

  3. 다음 표현식을 Project 필드에 복사합니다.

    { item: 1, status: 1 }

  4. 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를 연결합니다. 클라이언트.FindIterable. 프로젝션 메서드를 find 메서드로 변경합니다. 이 예시 에서는 com.mongodb를 사용합니다. 클라이언트.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 } )

  1. 다음 표현식을 Filter 필드에 복사합니다.

    { status: "A" }

  2. Options를 클릭하여 추가 쿼리 옵션을 엽니다.

  3. 다음 표현식을 Project 필드에 복사합니다.

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

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

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

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

  1. 다음 표현식을 Filter 필드에 복사합니다.

    { status: "A" }

  2. Options를 클릭하여 추가 쿼리 옵션을 엽니다.

  3. 다음 표현식을 Project 필드에 복사합니다.

    { status: 0, instock: 0 }

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

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

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

  1. 다음 표현식을 Filter 필드에 복사합니다.

    { status: "A" }

  2. Options를 클릭하여 추가 쿼리 옵션을 엽니다.

  3. 다음 표현식을 Project 필드에 복사합니다.

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

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

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

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

  1. 다음 표현식을 Filter 필드에 복사합니다.

    { status: "A" }

  2. Options를 클릭하여 추가 쿼리 옵션을 엽니다.

  3. 다음 표현식을 Project 필드에 복사합니다.

    { "size.uom": 0 }

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

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

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

  1. 다음 표현식을 Filter 필드에 복사합니다.

    { status: "A" }

  2. Options를 클릭하여 추가 쿼리 옵션을 엽니다.

  3. 다음 표현식을 Project 필드에 복사합니다.

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

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

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

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

  1. 다음 표현식을 Filter 필드에 복사합니다.

    { status: "A" }

  2. Options를 클릭하여 추가 쿼리 옵션을 엽니다.

  3. 다음 표현식을 Project 필드에 복사합니다.

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

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

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

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

  1. 다음 표현식을 Filter 필드에 복사합니다.

    { status: "A" }

  2. Options를 클릭하여 추가 쿼리 옵션을 엽니다.

  3. 다음 표현식을 Project 필드에 복사합니다.

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

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

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

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

  1. 다음 표현식을 Filter 필드에 복사합니다.

    { status: "A" }

  2. Options를 클릭하여 추가 쿼리 옵션을 엽니다.

  3. 다음 표현식을 Project 필드에 복사합니다.

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

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

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

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

  1. 다음 표현식을 Filter 필드에 복사합니다.

    { status: "A" }

  2. Options를 클릭하여 추가 쿼리 옵션을 엽니다.

  3. 다음 표현식을 Project 필드에 복사합니다.

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

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

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

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

  1. 다음 표현식을 Filter 필드에 복사합니다.

    { status: "A" }

  2. Options를 클릭하여 추가 쿼리 옵션을 엽니다.

  3. 다음 표현식을 Project 필드에 복사합니다.

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

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

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

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

  1. 다음 표현식을 Filter 필드에 복사합니다.

    { status: "A" }

  2. Options를 클릭하여 추가 쿼리 옵션을 엽니다.

  3. 다음 표현식을 Project 필드에 복사합니다.

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

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

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

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

  1. 다음 표현식을 Filter 필드에 복사합니다.

    { status: "A" }

  2. Options를 클릭하여 추가 쿼리 옵션을 엽니다.

  3. 다음 표현식을 Project 필드에 복사합니다.

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

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

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

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

  1. 다음 표현식을 Filter 필드에 복사합니다.

    { status: "A" }

  2. Options를 클릭하여 추가 쿼리 옵션을 엽니다.

  3. 다음 표현식을 Project 필드에 복사합니다.

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

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

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

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

  1. 다음 표현식을 Filter 필드에 복사합니다.

    { status: "A" }

  2. Options를 클릭하여 추가 쿼리 옵션을 엽니다.

  3. 다음 표현식을 Project 필드에 복사합니다.

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

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

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

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

  1. 다음 표현식을 Filter 필드에 복사합니다.

    { status: "A" }

  2. Options를 클릭하여 추가 쿼리 옵션을 엽니다.

  3. 다음 표현식을 Project 필드에 복사합니다.

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

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

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

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

  1. 다음 표현식을 Filter 필드에 복사합니다.

    { status: "A" }

  2. Options를 클릭하여 추가 쿼리 옵션을 엽니다.

  3. 다음 표현식을 Project 필드에 복사합니다.

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

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

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

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

  1. 다음 표현식을 Filter 필드에 복사합니다.

    { status: "A" }

  2. Options를 클릭하여 추가 쿼리 옵션을 엽니다.

  3. 다음 표현식을 Project 필드에 복사합니다.

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

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

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

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") 프로젝션은 첫 번째 요소가 있는 배열을 프로젝션하지 않습니다.

집계 표현식으로 필드 투영

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

예를 들어 다음 작업은 집계 표현식을 사용하여 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 또는 누락된 필드