Docs Menu

/

MongoDB 매뉴얼

/

/

내장된 또는 중첩된 문서에 대한 쿼리

이 페이지의 내용

점 표기법이 있는 중첩 필드 쿼리

포함/중첩 문서 일치
MongoDB Atlas로 내장된 문서 쿼리하기
추가 쿼리 튜토리얼

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

프로그래밍 언어의 드라이버입니다.
MongoDB Atlas UI. 자세한 내용은 MongoDB Atlas로 내장된 문서 쿼리하기에서 확인 가능합니다.
MongoDB Compass

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

이 페이지에서는 mongosh의 db.collection.find() 메서드를 사용하여 포함/중첩 문서에 대한 쿼리 작업의 예시를 제공합니다.

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

이 페이지는 MongoDB Compass를 사용해 임베디드/중첩된 문서 배열에서 쿼리 작업을 실행하는 예시를 제공합니다.

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

이 페이지는 MongoDB C# 드라이버에서 MongoCollection.Find() 메서드를 사용해 내장된/중첩된 문서에서 쿼리 작업을 실행하는 예시를 설명합니다.

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

이 페이지에서는 Collection.Find 를 사용하여 포함된/중첩된 문서에 대한 쿼리 작업의 예를 제공합니다. MongoDB 고 (Go) 드라이버 의 함수 .

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

이 페이지에서는 MongoDB Java Reactive Streams 드라이버의 com.mongodb.reactivestreams.client.MongoCollection.find 메서드를 사용하여 내장/중첩된 문서 배열에 대한 쿼리 작업의 예시를 보여줍니다.

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

이 페이지는 Java Synchronous 드라이버에서 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 드라이버에서 Mongo::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", qty: 25, size: { h: 14, w: 21, uom: "cm" }, status: "A" },
   { item: "notebook", qty: 50, size: { h: 8.5, w: 11, uom: "in" }, status: "A" },
   { item: "paper", qty: 100, size: { h: 8.5, w: 11, uom: "in" }, status: "D" },
   { item: "planner", qty: 75, size: { h: 22.85, w: 30, uom: "cm" }, status: "D" },
   { item: "postcard", qty: 45, size: { h: 10, w: 15.25, uom: "cm" }, status: "A" }
]);

[
    { "item": "journal", "qty": 25, "size": { "h": 14, "w": 21, "uom": "cm" }, "status": "A" },
    { "item": "notebook", "qty": 50, "size": { "h": 8.5, "w": 11, "uom": "in" }, "status": "A" },
    { "item": "paper", "qty": 100, "size": { "h": 8.5, "w": 11, "uom": "in" }, "status": "D" },
    { "item": "planner", "qty": 75, "size": { "h": 22.85, "w": 30, "uom": "cm" }, "status": "D" },
    { "item": "postcard", "qty": 45, "size": { "h": 10, "w": 15.25, "uom": "cm" }, "status": "A" }
]

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

var documents = new[]
{
    new BsonDocument
    {
        { "item", "journal" },
        { "qty", 25 },
        { "size", new BsonDocument { { "h", 14 }, { "w", 21 }, { "uom", "cm" } } },
        { "status", "A" }
    },
    new BsonDocument
    {
        { "item", "notebook" },
        { "qty", 50 },
        { "size", new BsonDocument { { "h", 8.5 }, { "w", 11 }, { "uom", "in" } } },
        { "status", "A" }
    },
    new BsonDocument
    {
        { "item", "paper" },
        { "qty", 100 },
        { "size", new BsonDocument { { "h", 8.5 }, { "w", 11 }, { "uom", "in" } } },
        { "status", "D" }
    },
    new BsonDocument
    {
        { "item", "planner" },
        { "qty", 75 },
        { "size", new BsonDocument { { "h", 22.85 }, { "w", 30 }, { "uom", "cm" } } },
        { "status", "D" }
    },
    new BsonDocument
    {
        { "item", "postcard" },
        { "qty", 45 },
        { "size", new BsonDocument { { "h", 10 }, { "w", 15.25 }, { "uom", "cm" } } },
        { "status", "A" } },
};
collection.InsertMany(documents);

docs := []interface{}{
	bson.D{
		{"item", "journal"},
		{"qty", 25},
		{"size", bson.D{
			{"h", 14},
			{"w", 21},
			{"uom", "cm"},
		}},
		{"status", "A"},
	},
	bson.D{
		{"item", "notebook"},
		{"qty", 50},
		{"size", bson.D{
			{"h", 8.5},
			{"w", 11},
			{"uom", "in"},
		}},
		{"status", "A"},
	},
	bson.D{
		{"item", "paper"},
		{"qty", 100},
		{"size", bson.D{
			{"h", 8.5},
			{"w", 11},
			{"uom", "in"},
		}},
		{"status", "D"},
	},
	bson.D{
		{"item", "planner"},
		{"qty", 75},
		{"size", bson.D{
			{"h", 22.85},
			{"w", 30},
			{"uom", "cm"},
		}},
		{"status", "D"},
	},
	bson.D{
		{"item", "postcard"},
		{"qty", 45},
		{"size", bson.D{
			{"h", 10},
			{"w", 15.25},
			{"uom", "cm"},
		}},
		{"status", "A"},
	},
}
result, err := coll.InsertMany(context.TODO(), docs)

Publisher<Success> insertManyPublisher = collection.insertMany(asList(
        Document.parse("{ item: 'journal', qty: 25, size: { h: 14, w: 21, uom: 'cm' }, status: 'A' }"),
        Document.parse("{ item: 'notebook', qty: 50, size: { h: 8.5, w: 11, uom: 'in' }, status: 'A' }"),
        Document.parse("{ item: 'paper', qty: 100, size: { h: 8.5, w: 11, uom: 'in' }, status: 'D' }"),
        Document.parse("{ item: 'planner', qty: 75, size: { h: 22.85, w: 30, uom: 'cm' }, status: 'D' }"),
        Document.parse("{ item: 'postcard', qty: 45, size: { h: 10, w: 15.25, uom: 'cm' }, status: 'A' }")
));

collection.insertMany(asList(
        Document.parse("{ item: 'journal', qty: 25, size: { h: 14, w: 21, uom: 'cm' }, status: 'A' }"),
        Document.parse("{ item: 'notebook', qty: 50, size: { h: 8.5, w: 11, uom: 'in' }, status: 'A' }"),
        Document.parse("{ item: 'paper', qty: 100, size: { h: 8.5, w: 11, uom: 'in' }, status: 'D' }"),
        Document.parse("{ item: 'planner', qty: 75, size: { h: 22.85, w: 30, uom: 'cm' }, status: 'D' }"),
        Document.parse("{ item: 'postcard', qty: 45, size: { h: 10, w: 15.25, uom: 'cm' }, status: 'A' }")
));

# Subdocument key order matters in a few of these examples so we have
# to use bson.son.SON instead of a Python dict.
from bson.son import SON
await db.inventory.insert_many(
    [
        {
            "item": "journal",
            "qty": 25,
            "size": SON([("h", 14), ("w", 21), ("uom", "cm")]),
            "status": "A",
        },
        {
            "item": "notebook",
            "qty": 50,
            "size": SON([("h", 8.5), ("w", 11), ("uom", "in")]),
            "status": "A",
        },
        {
            "item": "paper",
            "qty": 100,
            "size": SON([("h", 8.5), ("w", 11), ("uom", "in")]),
            "status": "D",
        },
        {
            "item": "planner",
            "qty": 75,
            "size": SON([("h", 22.85), ("w", 30), ("uom", "cm")]),
            "status": "D",
        },
        {
            "item": "postcard",
            "qty": 45,
            "size": SON([("h", 10), ("w", 15.25), ("uom", "cm")]),
            "status": "A",
        },
    ]
)

await db.collection('inventory').insertMany([
  {
    item: 'journal',
    qty: 25,
    size: { h: 14, w: 21, uom: 'cm' },
    status: 'A'
  },
  {
    item: 'notebook',
    qty: 50,
    size: { h: 8.5, w: 11, uom: 'in' },
    status: 'A'
  },
  {
    item: 'paper',
    qty: 100,
    size: { h: 8.5, w: 11, uom: 'in' },
    status: 'D'
  },
  {
    item: 'planner',
    qty: 75,
    size: { h: 22.85, w: 30, uom: 'cm' },
    status: 'D'
  },
  {
    item: 'postcard',
    qty: 45,
    size: { h: 10, w: 15.25, uom: 'cm' },
    status: 'A'
  }
]);

# Subdocument key order matters in this example so we have
# to use Tie::IxHash instead of a regular, unordered Perl hash.
$db->coll("inventory")->insert_many(
    [
        {
            item   => "journal",
            qty    => 25,
            size   => Tie::IxHash->new( h => 14, w => 21, uom => "cm" ),
            status => "A"
        },
        {
            item   => "notebook",
            qty    => 50,
            size   => Tie::IxHash->new( h => 8.5, w => 11, uom => "in" ),
            status => "A"
        },
        {
            item   => "paper",
            qty    => 100,
            size   => Tie::IxHash->new( h => 8.5, w => 11, uom => "in" ),
            status => "D"
        },
        {
            item   => "planner",
            qty    => 75,
            size   => Tie::IxHash->new( h => 22.85, w => 30, uom => "cm" ),
            status => "D"
        },
        {
            item   => "postcard",
            qty    => 45,
            size   => Tie::IxHash->new( h => 10, w => 15.25, uom => "cm" ),
            status => "A"
        }
    ]
);

$insertManyResult = $db->inventory->insertMany([
    [
        'item' => 'journal',
        'qty' => 25,
        'size' => ['h' => 14, 'w' => 21, 'uom' => 'cm'],
        'status' => 'A',
    ],
    [
        'item' => 'notebook',
        'qty' => 50,
        'size' => ['h' => 8.5, 'w' => 11, 'uom' => 'in'],
        'status' => 'A',
    ],
    [
        'item' => 'paper',
        'qty' => 100,
        'size' => ['h' => 8.5, 'w' => 11, 'uom' => 'in'],
        'status' => 'D',
    ],
    [
        'item' => 'planner',
        'qty' => 75,
        'size' => ['h' => 22.85, 'w' => 30, 'uom' => 'cm'],
        'status' => 'D',
    ],
    [
        'item' => 'postcard',
        'qty' => 45,
        'size' => ['h' => 10, 'w' => 15.25, 'uom' => 'cm'],
        'status' => 'A',
    ],
]);

# Subdocument key order matters in a few of these examples so we have
# to use bson.son.SON instead of a Python dict.
from bson.son import SON
db.inventory.insert_many(
    [
        {
            "item": "journal",
            "qty": 25,
            "size": SON([("h", 14), ("w", 21), ("uom", "cm")]),
            "status": "A",
        },
        {
            "item": "notebook",
            "qty": 50,
            "size": SON([("h", 8.5), ("w", 11), ("uom", "in")]),
            "status": "A",
        },
        {
            "item": "paper",
            "qty": 100,
            "size": SON([("h", 8.5), ("w", 11), ("uom", "in")]),
            "status": "D",
        },
        {
            "item": "planner",
            "qty": 75,
            "size": SON([("h", 22.85), ("w", 30), ("uom", "cm")]),
            "status": "D",
        },
        {
            "item": "postcard",
            "qty": 45,
            "size": SON([("h", 10), ("w", 15.25), ("uom", "cm")]),
            "status": "A",
        },
    ]
)

client[:inventory].insert_many([
                                { item: 'journal',
                                  qty: 25,
                                  size: { h: 14, w: 21, uom: 'cm' },
                                  status: 'A' },
                                { item: 'notebook',
                                  qty: 50,
                                  size: { h: 8.5, w: 11, uom: 'in' },
                                  status: 'A' },
                                { item: 'paper',
                                  qty: 100,
                                  size: { h: 8.5, w: 11, uom: 'in' },
                                  status: 'D' },
                                { item: 'planner',
                                  qty: 75,
                                  size: { h: 22.85, w: 30, uom: 'cm' },
                                  status: 'D' },
                                { item: 'postcard',
                                  qty: 45,
                                  size: { h: 10, w: 15.25, uom: 'cm' },
                                  status: 'A' }
                               ])

collection.insertMany(Seq(
  Document("""{ item: "journal", qty: 25, size: { h: 14, w: 21, uom: "cm" }, status: "A" }"""),
  Document("""{ item: "notebook", qty: 50, size: { h: 8.5, w: 11, uom: "in" }, status: "A" }"""),
  Document("""{ item: "paper", qty: 100, size: { h: 8.5, w: 11, uom: "in" }, status: "D" }"""),
  Document("""{ item: "planner", qty: 75, size: { h: 22.85, w: 30, uom: "cm" }, status: "D" }"""),
  Document("""{ item: "postcard", qty: 45, size: { h: 10, w: 15.25, uom: "cm" }, status: "A" }""")
)).execute()

점 표기법이 있는 중첩 필드 쿼리

포함된/중첩된 문서의 필드에 쿼리 조건을 지정하려면 점 표기법("field.nestedField")을 사용합니다.

참고

점 표기법을 사용하여 쿼리하는 경우 필드와 중첩 필드는 따옴표 안에 포함되어야 합니다.

중첩된 필드에 동등성 매치 지정

다음 예시에서는 size 필드에 중첩된 uom 필드가 "in"와 동등한 모든 문서를 선택합니다.

db.inventory.find( { "size.uom": "in" } )

다음 필터를 Compass 쿼리 표시줄에 복사하고 Find를 클릭합니다.

{ "size.uom": "in" }

var filter = Builders<BsonDocument>.Filter.Eq("size.uom", "in");
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{{"size.uom", "in"}},
)

findPublisher = collection.find(eq("size.uom", "in"));

findIterable = collection.find(eq("size.uom", "in"));

cursor = db.inventory.find({"size.uom": "in"})

const cursor = db.collection('inventory').find({
  'size.uom': 'in'
});

$cursor = $db->coll("inventory")->find( { "size.uom" => "in" } );

$cursor = $db->inventory->find(['size.uom' => 'in']);

cursor = db.inventory.find({"size.uom": "in"})

client[:inventory].find('size.uom' => 'in')

findObservable = collection.find(equal("size.uom", "in"))

쿼리 연산자를 사용하여 일치 지정

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

MongoDB는 동등 필터 외에도 필터 조건을 지정하기 위한 다양한 쿼리 연산자를 제공합니다. FilterDefinitionBuilder 메서드를 사용하여 필터 문서를 만듭니다. 예시:

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));

MongoDB는 동등 조건 외에도 필터 조건을 지정하기 위한 다양한 쿼리 연산자를 제공합니다. com.mongodb.client.model.Filters 헬퍼 메서드를 사용하여 필터 문서를 쉽게 만들 수 있습니다. 예시:

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

MongoDB는 동등 조건 외에도 필터 조건을 지정하기 위한 다양한 쿼리 연산자를 제공합니다. com.mongodb.client.model.Filters 헬퍼 메서드를 사용하여 필터 문서를 쉽게 만들 수 있습니다. 예시:

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1> => { <operator1> => <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

[ <field1> => [ <operator1> => <value1> ], ... ]

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1> => { <operator1> => <value1> }, ... }

MongoDB는 동등 조건 외에도 필터 조건을 지정하기 위한 다양한 쿼리 연산자를 제공합니다. com.mongodb.client.model.Filters_ 헬퍼 메서드를 사용하여 필터 문서를 쉽게 만들 수 있습니다. 예시:

and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))

다음 쿼리는 size 필드에 포함된 h 필드에서 '보다 작음'(less than) 연산자($lt)를 사용합니다.

db.inventory.find( { "size.h": { $lt: 15 } } )

다음 필터를 Compass 쿼리 표시줄에 복사하고 Find를 클릭합니다.

{ "size.h": { $lt: 15 } }

var filter = Builders<BsonDocument>.Filter.Lt("size.h", 15);
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"size.h", bson.D{
			{"$lt", 15},
		}},
	})

findPublisher = collection.find(lt("size.h", 15));

findIterable = collection.find(lt("size.h", 15));

cursor = db.inventory.find({"size.h": {"$lt": 15}})

const cursor = db.collection('inventory').find({
  'size.h': { $lt: 15 }
});

$cursor = $db->coll("inventory")->find( { "size.h" => { '$lt' => 15 } } );

$cursor = $db->inventory->find(['size.h' => ['$lt' => 15]]);

cursor = db.inventory.find({"size.h": {"$lt": 15}})

client[:inventory].find('size.h' => { '$lt' =>  15 })

findObservable = collection.find(lt("size.h", 15))

`AND` 조건 지정

다음 쿼리는 중첩된 필드 h가 15보다 작고, 중첩된 필드 uom이 "in"와 같으며, status 필드가 "D"인 모든 문서를 선택합니다.

db.inventory.find( { "size.h": { $lt: 15 }, "size.uom": "in", status: "D" } )

다음 필터를 Compass 쿼리 표시줄에 복사하고 Find를 클릭합니다.

{ "size.h": { $lt: 15 }, "size.uom": "in", status: "D" }

여러 중첩 필드 쿼리

var builder = Builders<BsonDocument>.Filter;
var filter = builder.And(builder.Lt("size.h", 15), builder.Eq("size.uom", "in"), builder.Eq("status", "D"));
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"size.h", bson.D{
			{"$lt", 15},
		}},
		{"size.uom", "in"},
		{"status", "D"},
	})

findPublisher = collection.find(and(
        lt("size.h", 15),
        eq("size.uom", "in"),
        eq("status", "D")
));

findIterable = collection.find(and(
        lt("size.h", 15),
        eq("size.uom", "in"),
        eq("status", "D")
));

cursor = db.inventory.find({"size.h": {"$lt": 15}, "size.uom": "in", "status": "D"})

const cursor = db.collection('inventory').find({
  'size.h': { $lt: 15 },
  'size.uom': 'in',
  status: 'D'
});

$cursor = $db->coll("inventory")->find(
    { "size.h" => { '$lt' => 15 }, "size.uom" => "in", status => "D" }
);

$cursor = $db->inventory->find([
    'size.h' => ['$lt' => 15],
    'size.uom' => 'in',
    'status' => 'D',
]);

cursor = db.inventory.find({"size.h": {"$lt": 15}, "size.uom": "in", "status": "D"})

client[:inventory].find('size.h'   => { '$lt' => 15 },
                        'size.uom' => 'in',
                        'status'   => 'D')

findObservable = collection.find(and(
  lt("size.h", 15),
  equal("size.uom", "in"),
  equal("status", "D")
))

포함/중첩 문서 일치

포함된/중첩된 문서인 필드에 동일성 조건을 지정하려면 쿼리 필터 문서 { <field>: <value> }를 사용하세요. 여기서 <value>은 일치하는 문서입니다.

포함된/중첩된 문서인 필드에 동일성 조건을 지정하려면 쿼리 필터 문서 { <field>: <value> }를 사용하세요. 여기서 <value>은 일치하는 문서입니다.

포함/중첩 문서인 필드에 동등 조건을 지정하려면 Eq 메서드를 사용하여 필터를 구성합니다.

Builders<BsonDocument>.Filter.Eq(<field>, <value>)

<value> 일치시킬 문서입니다.

임베디드/중첩 문서인 필드에 동등성 조건을 지정하려면 필터 문서인 eq( <field1>, <value>)을(를) 사용하세요. 여기서 <value>은(는) 일치하는 문서입니다.

임베디드/중첩 문서인 필드에 동등성 조건을 지정하려면 필터 문서인 eq( <field1>, <value>)을(를) 사용하세요. 여기서 <value>은(는) 일치하는 문서입니다.

포함된/중첩된 문서인 필드에 동일성 조건을 지정하려면 쿼리 필터 문서 { <field>: <value> }를 사용하세요. 여기서 <value>은 일치하는 문서입니다.

포함된/중첩된 문서인 필드에 동일성 조건을 지정하려면 쿼리 필터 문서 { <field>: <value> }를 사용하세요. 여기서 <value>은 일치하는 문서입니다.

포함된/중첩된 문서인 필드에 동일성 조건을 지정하려면 쿼리 필터 문서 { <field> => <value> }를 사용하세요. 여기서 <value>은 일치하는 문서입니다.

포함된/중첩된 문서인 필드에 동일성 조건을 지정하려면 쿼리 필터 문서 [ <field> => <value> ]를 사용하세요. 여기서 <value>은 일치하는 문서입니다.

포함된/중첩된 문서인 필드에 동일성 조건을 지정하려면 쿼리 필터 문서 { <field>: <value> }를 사용하세요. 여기서 <value>은 일치하는 문서입니다.

포함된/중첩된 문서인 필드에 동일성 조건을 지정하려면 쿼리 필터 문서 { <field> => <value> }를 사용하세요. 여기서 <value>은 일치하는 문서입니다.

임베디드/중첩 문서인 필드에 동등성 조건을 지정하려면 필터 문서인 equal( <field1>, <value> )을(를) 사용하세요. 여기서 <value>은(는) 일치하는 문서입니다.

예를 들어, 다음 쿼리는 size 필드가 { h: 14, w: 21, uom: "cm" } 문서와 동일한 모든 문서를 선택합니다.

db.inventory.find( { size: { h: 14, w: 21, uom: "cm" } } )

다음 필터를 Compass 쿼리 표시줄에 복사하고 Find를 클릭합니다.

{ size: { h: 14, w: 21, uom: "cm" } }

내장 필드 쿼리

var filter = Builders<BsonDocument>.Filter.Eq("size", new BsonDocument { { "h", 14 }, { "w", 21 }, { "uom", "cm" } });
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"size", bson.D{
			{"h", 14},
			{"w", 21},
			{"uom", "cm"},
		}},
	})

FindPublisher<Document> findPublisher = collection.find(eq("size", Document.parse("{ h: 14, w: 21, uom: 'cm' }")));

FindIterable<Document> findIterable = collection.find(eq("size", Document.parse("{ h: 14, w: 21, uom: 'cm' }")));

cursor = db.inventory.find({"size": SON([("h", 14), ("w", 21), ("uom", "cm")])})

const cursor = db.collection('inventory').find({
  size: { h: 14, w: 21, uom: 'cm' }
});

# Subdocument key order matters in this example so we have
# to use Tie::IxHash instead of a regular, unordered Perl hash.
$cursor = $db->coll("inventory")->find(
    { size => Tie::IxHash->new( h => 14, w => 21, uom => "cm" ) }
);

$cursor = $db->inventory->find(['size' => ['h' => 14, 'w' => 21, 'uom' => 'cm']]);

cursor = db.inventory.find({"size": SON([("h", 14), ("w", 21), ("uom", "cm")])})

client[:inventory].find(size: { h: 14, w: 21, uom: 'cm' })

var findObservable = collection.find(equal("size", Document("h" -> 14, "w" -> 21, "uom" -> "cm")))

경고

MongoDB는 내장된 문서에 대한 비교를 권장하지 않습니다. 이 작업에는 필드 순서를 포함하여 지정된 <value> 문서와 정확하게 일치해야 하기 때문입니다.

예를 들어 다음 쿼리는 inventory 컬렉션의 어떤 문서와도 일치하지 않습니다.

db.inventory.find(  { size: { w: 21, h: 14, uom: "cm" } }  )

내장 필드 쿼리

var filter = Builders<BsonDocument>.Filter.Eq("size", new BsonDocument { { "w", 21 }, { "h", 14 }, { "uom", "cm" } });
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"size", bson.D{
			{"w", 21},
			{"h", 14},
			{"uom", "cm"},
		}},
	})

findPublisher = collection.find(eq("size", Document.parse("{ w: 21, h: 14, uom: 'cm' }")));

findIterable = collection.find(eq("size", Document.parse("{ w: 21, h: 14, uom: 'cm' }")));

cursor = db.inventory.find({"size": SON([("w", 21), ("h", 14), ("uom", "cm")])})

const cursor = db.collection('inventory').find({
  size: { w: 21, h: 14, uom: 'cm' }
});

# Subdocument key order matters in this example so we have
# to use Tie::IxHash instead of a regular, unordered Perl hash.
$cursor = $db->coll("inventory")->find(
    { size => Tie::IxHash->new( w => 21, h => 14, uom => "cm" ) }
);

$cursor = $db->inventory->find(['size' => ['w' => 21, 'h' => 14, 'uom' => 'cm']]);

cursor = db.inventory.find({"size": SON([("w", 21), ("h", 14), ("uom", "cm")])})

client[:inventory].find(size: { h: 21, w: 14, uom: 'cm' })

findObservable = collection.find(equal("size", Document("w" -> 21, "h" -> 14, "uom" -> "cm")))

내장된 문서에 대한 비교를 사용하는 쿼리는 쿼리를 표현하기 위해 정렬된 데이터 구조를 사용하지 않는 드라이버와 함께 사용될 때 예측할 수 없는 동작을 초래할 수 있습니다.

MongoDB Atlas로 내장된 문서 쿼리하기

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

다음 단계를 수행하여 MongoDBDB Atlas에서 내장된 문서를 쿼리할 수 있습니다.

1

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

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

2

컬렉션으로 이동합니다.

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

3

쿼리 필터 문서 지정

Filter 필드에 쿼리 필터 문서를 지정합니다. 쿼리 필터 문서는 쿼리 연산자를 사용하여 검색 조건을 지정합니다.

다음 쿼리 필터 문서를 Filter 검색 바에 복사합니다.

{ "awards.wins": 1 }

4

클릭 Apply

이 쿼리 필터는 sample_mflix.movies 컬렉션에서 awards 필드의 내장된 문서 중 { wins: 1 }에 해당하는 모든 문서를 반환합니다.

추가 쿼리 튜토리얼

추가 쿼리 예시는 아래에서 확인 가능합니다.

돌아가기

쿼리

다음

배열

언어 선택

이 페이지의 내용

점 표기법이 있는 중첩 필드 쿼리
포함/중첩 문서 일치
MongoDB Atlas로 내장된 문서 쿼리하기
추가 쿼리 튜토리얼