알아야 할 9가지 유형의 Mongodb 연산자

게시 됨: 2022-09-09

모든 비즈니스에서 데이터는 가장 큰 자산입니다. 데이터를 분석하여 고객 동향 및 행동 예측에 대한 의사 결정을 내릴 수 있습니다. 이는 비즈니스 수익성과 효과적인 의사 결정을 향상시킵니다.

데이터베이스 소프트웨어가 없으면 레코드로 가득 찬 시스템에서 모든 값의 평균을 찾는 것과 같은 간단한 작업은 지루할 것입니다. 운 좋게도 데이터베이스는 함수와 연산자를 사용하여 데이터를 더 쉽고 빠르게 분석할 수 있게 해주었습니다.

이 기사에서는 MongoDB 데이터베이스 소프트웨어에서 사용되는 연산자에 대해 설명합니다.

MongoDB 연산자란 무엇입니까?

MongoDB는 문서 중심의 정보를 관리하는 NoSQL 데이터베이스 소프트웨어입니다.

MongoDB의 주요 기능 중 하나는 속도입니다. 쿼리를 더 빨리 반환하기 위해 MongoDB는 연산자를 사용하여 특정 기능을 수행할 수 있습니다.

연산자는 컴파일러가 수학적 또는 논리적 작업을 수행하는 데 도움이 되는 특수 기호입니다. MongoDB는 데이터베이스와 상호 작용할 수 있는 여러 유형의 연산자를 제공합니다.

MongoDB 연산자 유형

9가지 유형의 연산자가 있으며 각각 기능에 따라 이름이 지정됩니다. 예를 들어 논리 연산자는 논리 연산을 사용합니다. 이를 실행하려면 특정 키워드를 사용하고 구문을 따라야 합니다. 그러나 그들은 따라하기가 상당히 쉽습니다!

기사가 끝나면 각 연산자의 기본 사항과 기능을 배울 수 있습니다.

논리 연산자

논리 연산자는 주어진 조건에 따라 데이터를 필터링하는 데 자주 사용됩니다. 그것들은 또한 우리가 더 자세히 논의할 많은 조건의 평가를 허용합니다.

다음은 사용할 수 있는 몇 가지 논리 연산자입니다.

$그리고

"and" 조건은 둘 이상의 표현식 배열에 대해 논리적 "and" 연산을 수행합니다. 표현식의 모든 조건을 만족하는 문서를 선택합니다.

다음은 $and 표현식의 표준 구문입니다.

 { $and: [ { <expression1> }, { <expression2> }, ... , { <expressionN> } ] } 예를 들어 가격이 $10이고 수량이 15보다 작은 문서를 선택하려는 경우, 다음 쿼리를 입력할 수 있습니다.

 db.inventory.find( { $and: [ { quantity: { $lt: 15 } }, { price: 10 } ] } )

$또는

"or" 조건은 둘 이상의 표현식 배열에 대해 논리적 "or" 연산을 수행합니다. 표현식 중 하나 이상이 참인 문서를 선택합니다.

다음은 $or 표현식의 표준 구문입니다.

 { $or: [ { <expression1> }, { <expression2> }, ... , { <expressionN> } ] }.

예를 들어 가격이 $10이거나 수량이 15보다 작은 문서를 선택하려는 경우 다음 쿼리를 입력할 수 있습니다.

 db.inventory.find( { $or: [ { quantity: { $lt: 15 } }, { price: 10 } ] } )

표현식을 두 가지 기준으로 제한할 필요가 없습니다. 더 추가할 수 있습니다. 예를 들어, 아래 쿼리는 가격이 $10이거나, 수량이 15 미만이거나, 태그가 고정되어 있는 문서를 선택합니다.

 db.inventory.find( { $or: [ { quantity: { $lt: 15 } }, { price: 10 }, { tag: stationary }] } )

이 절을 실행할 때 MongoDB는 컬렉션 스캔 또는 인덱스 스캔을 수행합니다. 모든 인덱스가 절을 지원하면 MongoDB는 인덱스를 사용하여 $or 표현식을 확인합니다. 그렇지 않으면 대신 컬렉션 스캔을 사용합니다.

그러나 동일한 필드에서 기준을 테스트하려는 경우 $or 연산자 대신 $in 연산자를 사용할 수 있습니다. 예를 들어 수량이 10 또는 20인 문서 모음을 원하는 경우 대신 아래 $in 쿼리를 실행해야 할 수 있습니다.

 db.inventory.find ( { quantity: { $in: [20, 50] } } )

$in 연산자에 대해서는 나중에 자세히 다루겠습니다.

$도

이 연산자는 하나 이상의 표현식을 사용하여 배열에 대해 논리적 "nor" 연산을 수행합니다. 다음으로 쿼리 표현식에 실패한 문서를 선택합니다. 간단히 말해서 $or 조건의 반대를 수행합니다.

다음은 일반 구문입니다.

 { $nor: [ { <expression1> }, { <expression2> }, ... { <expressionN> } ] }

다음 쿼리를 고려해 보겠습니다.

 db.inventory.find( { $nor: [ { price: 3.99 }, { sale: true } ] } )

이 쿼리는 다음을 포함하는 문서를 선택합니다.

가격 필드 값이 $3.99가 아니고 판매 값이 true가 아닙니다. 또는
$3.99와 같지 않은 가격 필드 값 및 비어 있거나 없는 판매 필드; 또는
가격 필드가 없고 판매 필드가 true가 아닙니다. 또는
가격 필드나 판매 필드가 채워지거나 존재하지 않습니다.

$not

이 연산자는 지정된 표현식에 대해 배열에 대해 논리적 "not" 연산을 수행합니다. 그런 다음 쿼리 표현식과 일치하지 않는 문서를 선택합니다. 여기에는 필드가 포함되지 않은 문서가 포함됩니다.

다음은 일반 구문입니다.

 { field: { $not: { <operator-expression> } } }

예를 들어 다음 쿼리를 사용합니다.

 db.inventory.find( { price: { $not: { $lt: 3.99 } } } )

이 쿼리는 다음을 포함하는 문서를 선택합니다.

값이 $3.99 이상인 가격 필드; 그리고
가격 필드가 채워지지 않았거나 존재하지 않습니다.

비교 연산자

비교 연산자는 하나 이상의 문서에서 값을 비교하는 데 사용할 수 있습니다.

다음은 슈퍼마켓 상점에 대한 간단한 재고 수집의 샘플 코드입니다.

 { _id: 1, item: { name: "apple", code: "123" }, qty: 15, tags: [ "A", "B", "C" ] }, { _id: 2, item: { name: "banana", code: "123" }, qty: 20, tags: [ "B" ] }, { _id: 3, item: { name: "spinach", code: "456" }, qty: 25, tags: [ "A", "B" ] }, { _id: 4, item: { name: "lentils", code: "456" }, qty: 30, tags: [ "B", "A" ] }, { _id: 5, item: { name: "pears", code: "000" }, qty: 20, tags: [ [ "A", "B" ], "C" ] }, { _id: 6, item: { name: "strawberry", code: "123" }, tags: [ "B" ] }

다음에 각 비교 연산자를 자세히 설명하면서 이 예를 사용합니다.

같음($eq)

이 연산자는 주어진 값과 같은 값을 찾습니다:

 { <field>: { $eq: <value> } }

예를 들어 정확한 수량 값이 "20"인 인벤토리 컬렉션에서 특정 문서를 검색하려면 다음 명령을 입력합니다.

 db.inventory.find( { qty: { $eq: 20 } } )

쿼리는 다음을 반환합니다.

 { _id: 2, item: { name: "banana", code: "123" }, qty: 20, tags: [ "B" ] }, { _id: 5, item: { name: "pears", code: "000" }, qty: 20, tags: [ [ "A", "B" ], "C" ] }

($gt)보다 큼

이 연산자는 값이 지정된 값보다 큰 경우 일치합니다.

 { field: { $gt: value } }

이 예에서는 수량이 15보다 큰 문서를 검색합니다.

 db.inventory.find({"qty": { $gt: 15}})

쿼리는 다음을 반환합니다.

 { _id: 2, item: { name: "banana", code: "123" }, qty: 20, tags: [ "B" ] } { _id: 3, item: { name: "spinach", code: "456" }, qty: 25, tags: [ "A", "B" ] } { _id: 4, item: { name: "lentils", code: "456" }, qty: 30, tags: [ "B", "A" ] } { _id: 5, item: { name: "pears", code: "000" }, qty: 20, tags: [ [ "A", "B" ], "C" ] }

미만($lt)

이 연산자는 값이 제공된 값보다 작은 경우 일치합니다.

 { field: { $lt: value } }

수량이 25개 미만인 문서를 찾아보겠습니다.

 db.inventory.find({"qty": { $lt: 25}})

쿼리는 다음을 반환합니다.

 { _id: 1, item: { name: "apple", code: "123" }, qty: 15, tags: [ "A", "B", "C" ] } { _id: 2, item: { name: "banana", code: "123" }, qty: 20, tags: [ "B" ] } { _id: 5, item: { name: "pears", code: "000" }, qty: 20, tags: [ [ "A", "B" ], "C" ] }

크거나 같음($gte)

이 연산자는 값이 지정된 값보다 크거나 같을 때 일치합니다.

 { field: { $gte: value } }

이 예에서는 수량이 25보다 크거나 같은 문서를 검색합니다.

 db.inventory.find({"qty": { $gte: 25}})

이 쿼리는 다음을 반환합니다.

 { _id: 3, item: { name: "spinach", code: "456" }, qty: 25, tags: [ "A", "B" ] } { _id: 4, item: { name: "lentils", code: "456" }, qty: 30, tags: [ "B", "A" ] }

작거나 같음($lte)

이 연산자는 값이 지정된 값보다 작거나 같은 경우에만 일치합니다.

 { field: { $lte: value } }

수량이 25개 이하인 문서를 찾자.

 db.inventory.find({"qty": { $lte: 25}})

이 쿼리가 다음을 반환할 것으로 예상할 수 있습니다.

 { _id: 1, item: { name: "apple", code: "123" }, qty: 15, tags: [ "A", "B", "C" ] } { _id: 2, item: { name: "banana", code: "123" }, qty: 20, tags: [ "B" ] } { _id: 3, item: { name: "spinach", code: "456" }, qty: 25, tags: [ "A", "B" ] } { _id: 5, item: { name: "pears", code: "000" }, qty: 20, tags: [ [ "A", "B" ], "C" ] }

($in)

이 연산자는 지정된 값과 일치하는 문서를 반환합니다.

 { field: { $in: [<value1>, <value2>, ... <valueN> ] } }

필드 값은 지정된 배열의 모든 값과 같습니다. 예를 들어 인벤토리 컬렉션에서 값이 "30" 및 "15"인 문서를 검색하려면 다음을 수행합니다.

 db.collection.find({ "qty": { $in: [30, 15]}})

출력은 다음과 같습니다.

 { _id: 1, item: { name: "apple", code: "123" }, qty: 15, tags: [ "A", "B", "C" ] } { _id: 4, item: { name: "lentils", code: "456" }, qty: 30, tags: [ "B", "A" ] }

없음($9)

이 연산자는 주어진 값과 일치하지 않는 문서를 반환합니다. 다음은 $nin 연산자의 기본 구문입니다.

 { field: { $nin: [ <value1>, <value2> ... <valueN> ]

$nin 은 다음과 같은 문서를 선택합니다.

필드 값이 지정된 배열에 없습니다. 또는
필드가 존재하지 않습니다.

필드에 배열이 있는 경우 값 섹션에 지정된 요소가 없는 배열을 선택합니다. 예를 들어 수량이 20 또는 15와 같지 않은 문서를 선택하려고 합니다.

또한 수량 필드가 없는 문서와도 일치합니다.

 db.collection.find({ "qty": { $nin: [ 20, 15 ]}}, {_id: 0})

출력은 다음과 같습니다.

 { _id: 3, item: { name: "spinach", code: "456" }, qty: 25, tags: [ "A", "B" ] } { _id: 4, item: { name: "lentils", code: "456" }, qty: 30, tags: [ "B", "A" ] } { _id: 6, item: { name: "strawberry", code: "123" }, tags: [ "B" ] }

같지 않음($ne)

$ne 연산자는 지정된 값이 같지 않은 문서를 반환합니다.

 { $ne: value } }

예를 들어 수량이 20이 아닌 모든 문서를 선택하고 싶다고 가정해 보겠습니다.

 db.inventory.find( { qty: { $ne: 20 } } )

출력은 다음과 같습니다.

 { _id: 1, item: { name: "apple", code: "123" }, qty: 15, tags: [ "A", "B", "C" ] } { _id: 3, item: { name: "spinach", code: "456" }, qty: 25, tags: [ "A", "B" ] } { _id: 4, item: { name: "lentils", code: "456" }, qty: 30, tags: [ "B", "A" ] } { _id: 6, item: { name: "strawberry", code: "123" }, tags: [ "B" ] }

위의 출력에서 쿼리가 수량 필드가 없는 문서를 선택한다는 것을 알 수 있습니다.

요소 연산자

요소 쿼리 연산자는 문서의 필드를 사용하여 문서를 식별할 수 있습니다. 요소 연산자는 $exist 및 $type 으로 구성됩니다.

$ 존재

이 연산자는 지정된 필드가 있는 문서와 일치합니다. 이 연산자에는 true 또는 false 일 수 있는 부울 값이 있습니다.

true 로 지정된 경우 필드 값이 null인 문서를 포함하여 해당 필드를 포함하는 문서와 일치합니다. <boolean> 이 false 이면 쿼리는 필드를 포함하지 않는 문서만 반환합니다.

다음은 표준 구문입니다.

 { field: { $exists: <boolean> } }

"bagofmarbles"라는 배열에 대한 컬렉션 데이터가 있는 예를 들어보겠습니다. 각 가방에는 다양한 색상의 구슬이 포함되어 있습니다.

 { red: 5, green: 5, blue: null } { red: 3, green: null, blue: 8 } { red: null, green: 3, blue: 9 } { red: 1, green: 2, blue: 3 } { red: 2, blue: 5 } { red: 3, green: 2 } { red: 4 } { green: 2, blue: 4 } { green: 2 } { blue: 6 }

빨간 구슬이 있는 가방만 반환하는 쿼리를 원한다고 가정해 보겠습니다. 이는 부울 값을 true 로 입력해야 함을 의미합니다. 한 번 보자:

 db.bagofmarbles.find( { red: { $exists: true } } )

결과는 값이 null 인 경우에도 "red" 필드를 포함하는 문서로 구성됩니다. 그러나 "빨간색" 필드가 존재하지 않는 문서로 구성되지 않습니다.

 { red: 5, green: 5, blue: null } { red: 3, green: null, blue: 8 } { red: null, green: 3, blue: 9 } { red: 1, green: 2, blue: 3 } { red: 2, blue: 5 } { red: 3, green: 2 } { red: 4 }

빨간색 구슬이 필드로 존재하지 않는 가방만 원하는 경우 아래 쿼리를 입력할 수 있습니다.

 db.bagofmarbles.find( { red: { $exists: false} }

결과는 "빨간색" 필드가 포함되지 않은 문서로 구성됩니다.

 { green: 2, blue: 4 } { green: 2 } { blue: 6 }

$유형

이 연산자는 지정된 필드 유형에 따라 문서를 찾습니다. 이것은 고도로 구조화되지 않은 데이터가 있거나 데이터 유형을 예측할 수 없는 경우에 유용합니다. 이러한 필드 유형은 BSON 유형으로 지정되며 유형 번호 또는 별칭으로 정의할 수 있습니다.

다음은 $type 의 일반 구문입니다.

 { field: { $type: <BSON type> } }

아래 문서가 포함된 주소록이 있다고 가정해 보겠습니다.

 db={ addressBook: [ { "_id": 1, address: "2100 Jupiter Spot", zipCode: "9036325" }, { "_id": 2, address: "25 Moon Place", zipCode: 26237 }, { "_id": 3, address: "2324 Neptune Ring", zipCode: NumberLong(77622222) }, { "_id": 4, address: "33 Saturns Moon", zipCode: NumberInt(117) }, { "_id": 5, address: "1044 Venus Lane", zipCode: [ "99883637232", "73488976234" ] } ] }

위의 문서를 살펴보면 우편번호의 데이터 유형이 다릅니다. 여기에는 long, double, 정수 및 문자열 값이 포함됩니다.

지정된 데이터 유형을 우편번호로 가진 문서만 원하는 경우(이 경우 문자열을 사용하겠습니다) 컴파일러에 다음 쿼리를 입력해야 합니다.

 db.addressBook.find({ "zipCode": { $type: "string" } })

그러면 다음 문서가 반환됩니다.

 [ { "_id": 1, "address": "2100 Jupiter Spot", "zipCode": "9036325" }, { "_id": 5, "address": "1044 Venus Lane", "zipCode": [ "99883637232", "73488976234" ] } ]

또한 지정된 유형의 요소를 포함하는 배열로 모든 long, integer 또는 double 값을 포함하는 "숫자" 유형이 있습니다.

 db.addressBook.find( { "zipCode" : { $type : "number" } } )

산출:

 [ { "_id": 2, address: "25 Moon Place", zipCode: 26237 }, { "_id": 3, address: "2324 Neptune Ring", zipCode: NumberLong(77622222) }, { "_id": 4, address: "33 Saturns Moon", zipCode: NumberInt(117) } ]

문서에 배열 필드 유형이 있는 경우 $type 연산자는 하나 이상의 배열 요소가 연산자에 전달된 유형과 일치하는 문서를 반환합니다.

배열 연산자

MongoDB는 또한 배열을 포함하는 문서를 쿼리하기 위한 배열 연산자로 구성됩니다.

$all , $elemMatch 및 $size 의 세 가지 기본 연산자가 있습니다. 아래에서 각각에 대해 자세히 설명하겠습니다.

$all

$all 연산자는 필드 값이 지정된 요소를 포함하는 배열인 문서를 선택합니다.

 { : { $all: [ <value1> , <value2> ... ] } }

예를 들어 의류 매장에 대한 문서 모음이 있고 인벤토리 아래에 다음이 있다고 가정해 보겠습니다.

 { _id: ObjectId("5234cc89687ea597eabee675"), code: "shirt", tags: [ "sale", "shirt", "button", "y2k", "casual" ], qty: [ { size: "S", num: 10, color: "blue" }, { size: "M", num: 45, color: "blue" }, { size: "L", num: 100, color: "green" } ] }, { _id: ObjectId("5234cc8a687ea597eabee676"), code: "pant", tags: [ "y2k", "trendy", "shine" ], qty: [ { size: "6", num: 100, color: "green" }, { size: "6", num: 50, color: "blue" }, { size: "8", num: 100, color: "brown" } ] }, { _id: ObjectId("5234ccb7687ea597eabee677"), code: "pant2", tags: [ "trendy", "shine" ], qty: [ { size: "S", num: 10, color: "blue" }, { size: "M", num: 100, color: "blue" }, { size: "L", num: 100, color: "green" } ] }, { _id: ObjectId("52350353b2eff1353b349de9"), code: "shirt2", tags: [ "y2k", "trendy" ], qty: [ { size: "M", num: 100, color: "green" } ] }

"trendy" 및 "y2k" 태그와 연결된 인벤토리에서 모든 문서(이 경우 옷)를 검색하려고 합니다. 아래 쿼리는 태그 필드의 값이 "y2k" 및 "trendy"가 포함된 배열인 $all 연산자를 사용합니다.

 db.inventory.find( { tags: { $all: [ "y2k", "trendy" ] } } )

위 쿼리는 다음을 반환합니다.

 { _id: ObjectId("5234cc8a687ea597eabee676"), code: "pant", tags: [ "y2k", "trendy", "shine" ], qty: [ { size: "6", num: 100, color: "green" }, { size: "6", num: 50, color: "blue" }, { size: "8", num: 100, color: "brown" } ] } { _id: ObjectId("52350353b2eff1353b349de9"), code: "shirt2", tags: [ "y2k", "trendy" ], qty: [ { size: "M", num: 100, color: "green" } ] }

위의 예에서 $all 연산자는 단순히 $and 연산과 동일한 기능을 수행한다는 것을 알 수 있습니다.

또는 위와 유사한 출력을 제공하는 아래 쿼리를 사용할 수 있습니다.

 db.collection.find({ $and: [ { tags: "y2k" }, { tags: "trendy" } ] })

$elemMatch

$elemMatch 연산자는 지정된 모든 쿼리 기준과 일치하는 요소가 하나 이상 있는 배열 필드가 포함된 문서를 찾습니다.

 { : { $elemMatch: { <query1>, <query2>, ... } } }

$lte 및 $gte gte 와 같은 비교 연산자를 사용할 수 있지만 $elemMatch 내부에 단일 쿼리 조건만 지정하고 $not 또는 $ne 연산자를 사용하지 않는 경우 $elemMatch 활용은 본질적으로 수행되므로 생략할 수 있습니다. 같은 기능.

이 연산자를 사용하는 동안 염두에 두어야 할 몇 가지 사항이 더 있습니다. 주로 다음과 같습니다.

$elemMatch 작업에서 $where 표현식을 지정할 수 없습니다.
$elemMatch 작업에서 $text 쿼리 식을 지정할 수 없습니다.

예를 들어 학생 결과 컬렉션에 다음 문서가 있습니다.

 { _id: 1, results: [ 92, 89, 98 ] } { _id: 2, results: [ 85, 99, 99 ] }

다음 쿼리는 결과 배열에 90보다 크거나 같고 95보다 작은 요소가 하나 이상 포함된 문서만 일치시킵니다.

 db.studentresults.find( { results: { $elemMatch: { $gte: 90, $lt: 95 } } })

요소 92가 90보다 크거나 같고 95보다 작기 때문에 쿼리는 다음 문서를 반환합니다.

 { "_id" : 1, "results" :[ 92, 89, 98 ] }

$크기

$size 연산자는 배열 크기가 인수에 지정된 요소 수와 일치하는 문서를 반환합니다.

 { field: { $size: value } }

다음은 예입니다.

 db.collection.find( { field: { $size: 2 } });

이렇게 하면 필드가 { field: [ orange, apple] } 및 { field: [ blue, red] } , { field: blue} 또는 { field: [ raspberry, lemon, grapefruit ] } 가 아닌 2개의 요소가 있는 배열인 지정된 컬렉션의 모든 문서가 반환됩니다. { field: [ raspberry, lemon, grapefruit ] } .

그러나 특정 값을 크기로 입력할 수는 있지만 값의 범위를 크기로 지정할 수는 없습니다.

지리정보 연산자

MongoDB를 사용하면 GeoJSON 유형의 형태로 지리 공간 데이터를 저장할 수 있습니다. GeoJSON은 지리적 특징을 나타내고 비공간 속성을 지원할 수 있는 JavaScript 개체 표기법을 기반으로 하는 개방형 표준 형식입니다. 이 기사에서 이야기할 두 가지 유형의 지리 공간 연산자가 있습니다. 기하 정보 지정자와 쿼리 선택자입니다.

$기하학

이 연산자는 $geoIntersects , $geoWithin , $nearSphere 및 $near 지리 공간 쿼리 연산자와 함께 사용할 GeoJSON 지오메트리를 언급합니다. $geometry 는 EPSG:4326을 기본 좌표 참조 시스템(CRS)으로 활용합니다.

기본 CRS를 사용하여 GeoJSON 개체를 언급하려면 $geometry 에 대해 다음 스니펫을 활용할 수 있습니다.

 $geometry: { type: "<GeoJSON object type>", coordinates: [ <coordinates> ] }

맞춤형 MongoDB CRS가 있는 단일 링 GeoJSON 폴리곤을 언급하려면 다음 스니펫을 사용할 수 있습니다( $geoWithin 및 $geoIntersects 에만 사용할 수 있음).

 $geometry: { type: "Polygon", coordinates: [ <coordinates> ], crs: { type: "name", properties: { name: "urn:x-mongodb:crs:strictwinding:EPSG:4326" } } }

$폴리곤

$polygon 연산자는 레거시 좌표 쌍에 대한 지리 공간 $geoWithin 쿼리에 대한 다각형을 지정하는 데 사용할 수 있습니다. 그러면 이 쿼리는 폴리곤의 범위에 속하는 쌍을 반환합니다. 그러나 $polygon 은 GeoJSON 개체를 쿼리하지 않습니다. 폴리곤을 정의하려면 다음과 같이 좌표점 배열을 지정해야 합니다.

 { : { $geoWithin: { $polygon: [ [ <x1> , <y1> ], [ <x2> , <y2> ], [ <x3> , <y3> ], ... ] } } }

여기서 마지막 점은 암시적으로 첫 번째 점과 연결됩니다. 원하는 만큼 요점이나 측면을 언급할 수 있습니다.

예를 들어 다음 쿼리는 [0,0], [1,5] 및 [3,3]으로 정의된 다각형 내에 좌표가 있는 모든 문서를 반환합니다.

 db.places.find( { loc: { $geoWithin: { $polygon: [ [ 0 , 0 ], [ 1 , 5 ], [ 3 , 3 ] ] } } } )

$geoWithin

이 연산자는 특정 모양에 완전히 포함된 지리 공간 데이터가 있는 문서를 선택하는 데 사용할 수 있습니다. 지정된 모양은 GeoJSON 다중 다각형, GeoJSON 다각형(다중 고리 또는 단일 고리) 또는 레거시 좌표 쌍으로 정의할 수 있는 모양일 수 있습니다.

$geoWithin 연산자는 $geometry 연산자를 활용하여 GeoJSON 개체를 언급합니다.

기본 좌표 참조 시스템(CRS)을 통해 GeoJSON 다중 다각형 또는 다각형을 언급하려면 아래에 언급된 구문을 활용할 수 있습니다.

 { : { $geoWithin: { $geometry: { type: <"Polygon" or "MultiPolygon"> , coordinates: [ <coordinates> ] } } } }

단일 반구보다 큰 영역이 있는 GeoJSON 지오메트리를 언급하는 $geoWithin 쿼리의 경우 기본 CRS를 사용하면 보완 지오메트리에 대한 쿼리가 발생합니다.

사용자 지정 MongoDB CRS가 있는 단일 링 GeoJSON 다각형을 언급하려면 $geometry 표현식에서 아래에 언급된 프로토타입을 활용할 수 있습니다.

 { : { $geoWithin: { $geometry: { type: "Polygon" , coordinates: [ <coordinates> ], crs: { type: "name", properties: { name: "urn:x-mongodb:crs:strictwinding:EPSG:4326" } } } } } }

다음 예제는 GeoJSON 폴리곤 내에 완전히 존재하는 모든 loc 데이터를 선택합니다. 폴리곤의 면적은 단일 반구의 면적보다 작습니다.

 db.places.find( { loc: { $geoWithin: { $geometry: { type : "Polygon" , coordinates: [ [ [ 0, 0 ], [ 3, 6 ], [ 6, 1 ], [ 0, 0 ] ] ] } } } } )

$박스

$box 를 사용하여 지리 공간 $geoWithin 쿼리에 대한 직사각형을 지정하여 포인트 기반 위치 데이터에 따라 직사각형의 범위 내에 있는 문서를 제공할 수 있습니다. $ $box 와 함께 $geoWithin 을 사용하면 쿼리 좌표를 기반으로 문서를 얻을 수 있습니다. 이 시나리오에서 $geoWithin 은 GeoJSON 모양을 쿼리하지 않습니다.

$box 연산자를 활용하려면 배열 객체에서 사각형의 오른쪽 위 모서리와 왼쪽 아래 모서리를 언급해야 합니다.

 { <location field> : { $geoWithin: { $box: [ [ <bottom left coordinates> ], [ <upper right coordinates> ] ] } } }

앞서 언급한 쿼리는 평면(평면) 지오메트리를 활용하여 거리를 계산합니다. 다음 쿼리는 [0,0], [0,30], [30,0], [30,30] 지점이 있는 상자 안에 있는 모든 문서를 반환합니다.

 db.places.find ( { loc: { $geoWithin: { $box: [ [ 0,0 ], [ 30,30 ] ] } } } )

$니어스피어

$nearSphere 를 사용하여 지리 공간 쿼리가 문서를 가장 가까운 것부터 가장 먼 것 순으로 반환하는 지점을 언급할 수 있습니다.

MongoDB는 구형 기하학을 사용하여 $nearSphere 의 거리를 계산합니다. 다음과 같이 지리 공간 인덱스가 필요합니다.

레거시 좌표 쌍으로 설명되는 위치 데이터에 대한 2d 인덱스입니다. GeoJSON 포인트에서 2D 인덱스를 활용하려면 GeoJSON 개체의 좌표 필드에 인덱스를 생성해야 합니다.
GeoJSON 포인트로 기술된 위치 데이터에 대한 2dsphere 인덱스.

GeoJSON 포인트를 언급하기 위해 다음 구문을 활용할 수 있습니다.

 { $nearSphere: { $geometry: { type : "Point", coordinates : [ <longitude>, <latitude> ] }, $minDistance: <distance in meters>, $maxDistance: <distance in meters> } }

여기서 $minDistance 및 $maxDistance 는 선택 사항입니다. $minDistance 는 중심에서 최소한 지정된 거리에 있는 문서로 결과를 제한할 수 있습니다. 두 인덱스 모두에 $maxDistance 를 사용할 수 있습니다.

이제 2dsphere 인덱스가 있는 위치 필드가 있는 문서로 구성된 "장소" 모음을 고려하십시오. 다음 예는 위치가 선택한 지점에서 최소 2,000미터, 최대 6,000미터인 지점을 가장 가까운 것부터 가장 먼 것 순으로 반환합니다.

 db.places.find( { location: { $nearSphere: { $geometry: { type : "Point", coordinates : [ -43.9532, 50.32 ] }, $minDistance: 2000, $maxDistance: 6000 } } } )

$geoIntersects

$geoIntersects 연산자를 사용하면 지리 공간 데이터가 특정 GeoJSON 개체와 교차하는 문서를 선택할 수 있습니다(즉, 지정된 개체와 데이터의 수렴이 비어 있지 않은 경우). $geometry 연산자를 활용하여 GeoJSON 개체를 지정합니다.

기본 좌표 참조 시스템(CRS)을 통해 GeoJSON 다중 다각형 또는 다각형을 언급하려면 다음 구문을 사용할 수 있습니다.

 { <location field>: { $geoIntersects: { $geometry: { type: "<GeoJSON object type>" , coordinates: [ <coordinates> ] } } } }

다음 인스턴스는 $geoIntersects 를 사용하여 좌표 배열이 설명하는 폴리곤과 교차하는 모든 위치 데이터를 선택합니다.

 db.places.find( { loc: { $geoIntersects: { $geometry: { type: "Polygon" , coordinates: [ [ [ 0, 0 ], [ 2, 6 ], [ 4, 1 ], [ 0, 0 ] ] ] } } } } )

$센터

$center 연산자는 원의 범위 내에 있는 레거시 좌표 쌍을 반환하는 $geoWithin 쿼리에 대한 원을 언급합니다.

$center 는 GeoJSON 개체를 반환하지 않습니다. $center 연산자를 활용하려면 다음을 포함하는 배열을 지정해야 합니다.

좌표계에서 사용하는 단위로 측정한 원의 반지름입니다.
원 중심점의 그리드 좌표입니다.

 { <location field> : { $geoWithin: { $center: [ [ <x> , <y> ] , <radius> ] } } }

아래에 언급된 예는 [2,3]을 중심으로 하고 반경이 40인 원 내에서 찾을 수 있는 좌표를 가진 모든 문서를 반환합니다.

 db.places.find( { loc: { $geoWithin: { $center: [ [2, 3], 40 ] } } } )

투영 연산자

프로젝션 연산자를 사용하여 작업에서 반환된 필드를 언급할 수 있습니다. MongoDB 프로젝션 연산자를 사용하면 find() 함수를 데이터 필터링 인수와 함께 사용할 수 있습니다. 이를 통해 사용자는 문서에서 필요한 데이터 필드만 추출할 수 있습니다. 따라서 전체 데이터베이스 성능에 영향을 주지 않고 투명하고 간결한 데이터를 투영할 수 있습니다.

$elemMatch(프로젝션)

$elemMatch 연산자는 $elemMatch 조건과 일치하는 첫 번째 요소만 포함하도록 쿼리 결과의 필드 내용을 제한합니다.

다음은 $elemMatch 를 사용하기 전에 염두에 두어야 할 몇 가지 사항입니다.

MongoDB 4.4부터 문서의 필드 순서에 관계없이 기존 필드의 $elemMatch 프로젝션은 다른 기존 필드가 포함된 후 필드를 반환합니다.
$elemMatch 및 $ 연산자는 지정된 조건에 따라 배열에서 첫 번째로 일치하는 요소를 나타냅니다. $ 연산자는 쿼리 문의 일부 조건을 기반으로 컬렉션의 모든 문서에서 첫 번째 일치하는 배열 요소를 투영하는 반면 $elemMatch 투영 연산자는 명시적 조건 인수를 사용합니다. 이렇게 하면 쿼리에 없는 조건을 기반으로 투영하거나 배열의 포함된 문서에 있는 다양한 필드를 기반으로 투영해야 하는 경우에 사용할 수 있습니다.

데이터에 $elemMatch 연산자를 사용하기 전에 다음 제한 사항도 알고 있어야 합니다.

$elemMatch 연산자 내에서 $text 쿼리 표현식을 언급할 수 없습니다.
뷰에 대한 db.collection.find() 작업은 $elemMatch 프로젝션 연산자를 지원하지 않습니다.

$elemMatch 투영 연산자에 대한 다음 예제는 다음 문서가 있는 수집 schools 를 가정합니다.

 { _id: 1, zipcode: "63108", students: [ { name: "mark", school: 102, age: 9 }, { name: "geoff", school: 101, age: 13 }, { name: "frank", school: 104, age: 12 } ] } { _id: 2, zipcode: "63110", students: [ { name: "harry", school: 103, age: 14 }, { name: "george", school: 103, age: 7 }, ] } { _id: 3, zipcode: "63108", students: [ { name: "harry", school: 103, age: 14 }, { name: "george", school: 103, age: 7 }, ] } { _id: 4, zipcode: "63110", students: [ { name: "jim", school: 103, age: 9 }, { name: "michael", school: 103, age: 12 }, ] }

이 예에서 find() 작업은 zipcode 필드의 값이 63110인 모든 문서를 쿼리합니다. $elemMatch 프로젝션은 school 필드의 값이 103인 students 배열의 첫 번째 일치 요소만 반환합니다.

 db.schools.find( { zipcode: "63110" }, { students: { $elemMatch: { school: 103 } } } ) This is what the result would look like: { "_id" : 2, "students" : [ { "name" : "harry", "school" : 103, "age" : 14 } ] } { "_id" : 4, "students" : [ { "name" : "jim", "school" : 103, "age" : 9 } ] }

$슬라이스(프로젝션)

$slice 프로젝션 연산자를 사용하여 쿼리 결과에 반환할 배열의 요소 수를 지정할 수 있습니다.

 db.collection.find( <query> , { <arrayField> : { $slice: <number> } } );

다음과 같이 표현할 수도 있습니다.

 db.collection.find( <query> , { <arrayField> : { $slice: [ <number> , <number> ] } } );

동일한 것을 보여주기 위해 다음 문서를 사용하여 예제 트윗 모음을 만들 수 있습니다.

 db.posts.insertMany([ { _id: 1, title: "Nuts are not blueberries.", comments: [ { comment: "0. true" }, { comment: "1. blueberries aren't nuts."} ] }, { _id: 2, title: "Coffee please.", comments: [ { comment: "0. Indubitably" }, { comment: "1. Cuppa tea please" }, { comment: "2. frappucino" }, { comment: "3. Mocha latte" }, { comment: "4. whatever" } ] } ])

다음 작업은 처음 두 요소가 포함된 배열을 반환하기 위해 트윗 배열의 $slice 투영 연산자를 사용합니다. 배열에 2개 미만의 요소가 포함되어 있으면 배열의 모든 요소가 반환됩니다.

 db.posts.find( {}, { comments: { $slice: 2 } } )

이 작업은 다음 문서를 반환합니다.

 { "_id" : 1, "title" : "Nuts are not blueberries.", "comments" : [ { "comment" : "0. true" }, { "comment" : "1. blueberries aren't nuts." } ] } { "_id" : 2, "title" : "Coffee please.", "comments" : [ { "comment" : "0. Indubitably" }, { "comment" : "1. Cuppa tea please" } ] }

$(프로젝션)

위치 $ 연산자는 배열의 쿼리 조건과 일치하는 첫 번째 요소를 반환하도록 배열의 내용을 제한합니다. 선택한 문서에서 특정 배열 요소가 하나만 필요한 경우 find() 메서드 또는 findOne() 메서드의 투영 문서에서 $ 를 사용할 수 있습니다.

$ 연산자의 구문은 다음과 같습니다.

 db.collection.find( { <array>: <condition> ... }, { "<array>.$": 1 } ) db.collection.find( { <array.field>: <condition> ...}, { "<array>.$": 1 } )

이 예에서 students 컬렉션은 다음 문서로 구성됩니다.

 { "_id" : 1, "semester" : 2, "grades" : [ 75, 67, 93 ] } { "_id" : 2, "semester" : 2, "grades" : [ 60, 68, 72 ] } { "_id" : 3, "semester" : 2, "grades" : [ 95, 82, 67 ] } { "_id" : 4, "semester" : 3, "grades" : [ 89, 95, 70 ] } { "_id" : 5, "semester" : 3, "grades" : [ 68, 98, 82 ] } { "_id" : 6, "semester" : 3, "grades" : [ 65, 70, 76 ] }

다음 쿼리에서 프로젝션 { "grades.$": 1 } 는 grades 필드에 대해 89보다 크거나 같은 첫 번째 요소만 반환합니다.

 db.students.find( { semester: 2, grades: { $gte: 89 } }, { "grades.$": 1 } )

이 작업은 다음 문서를 반환합니다.

 {"_id": 3, "grades": [95] }

평가 연산자

MongoDB 평가 연산자를 활용하여 문서 내의 전체 데이터 구조 또는 개별 필드를 측정할 수 있습니다.

몇 가지 일반적인 MongoDB 평가 연산자를 살펴보겠습니다.

$mod

이 연산자를 사용하여 지정된 필드의 값이 지정된 값으로 나눈 후 나머지와 같은 문서를 일치시킬 수 있습니다.

 { field: { $mod: [ divisor, remainder ] } }

쇼룸에 소유하고 있는 다양한 브랜드의 자동차 테이블이 있다고 가정해 보겠습니다. 다음 쿼리는 재고 번호가 250의 배수인 모든 자동차 브랜드를 제공합니다.

 db.cars.find ( { qty: { $mod: [ 250,0 ] } } )

$json스키마

$jsonSchema 를 사용하면 지정된 JSON 스키마와 일치하는 문서를 일치시킬 수 있습니다. MongoDB의 JSON 스키마 구현에는 $jsonSchema 연산자 내에서 모든 BSON 유형을 사용할 수 있도록 하는 bsonType 키워드의 추가가 포함됩니다.

bsonType 은 type 연산자에 사용하는 것과 동일한 문자열 별칭을 허용할 수 있습니다. $jsonSchema 의 구문은 다음과 같습니다.

 { $jsonSchema: <JSON Schema object> }

여기에서 JSON 스키마 객체는 JSON 스키마 표준의 초안 4를 기반으로 형식이 지정됩니다.

 { <keyword1>: <value1>, ... }

다음은 $jsonSchema 작동 방식을 보여주는 예입니다.

 { $jsonSchema: { required: [ "name", "major", "gpa", "address" ], properties: { name: { bsonType: "string", description: "must be a string and is required" }, address: { bsonType: "object", required: [ "zipcode" ], properties: { "street": { bsonType: "string" }, "zipcode": { bsonType: "string" } } } } } }

문서 유효성 검사기에서 $jsonSchema 를 사용하여 업데이트 및 삽입 작업에 지정된 스키마를 적용할 수도 있습니다.

 db.createCollection(<collection> , { validator: { $jsonSchema: <schema> } } ) db.runCommand( { collMod: <collection>, validator:{ $jsonSchema: <schema> } } )

$jsonSchema 연산자에서 지원하지 않는 몇 가지 사항이 있음을 명심하십시오.

정수 유형입니다. bsonType 키워드와 함께 BSON 유형 long 또는 int를 활용해야 합니다.
알 수 없는 키워드입니다.
JSON 참조 및 JSON 포인터 사용과 함께 JSON 스키마의 속성 및 하이퍼미디어 연결.

$text

$text 연산자는 지정된 필드의 내용 내에서 텍스트 인덱스로 인덱싱된 텍스트를 찾습니다.

 { $text: { $search: <string>, $language: <string>, $caseSensitive: <boolean>, $diacriticSensitive: <boolean> } }

이 경우 다음 코드 스니펫은 "Porsche"라는 텍스트가 포함된 자동차를 필터링하기 위해 표를 살펴봅니다.

 db.cars.find( { $text: { $search: "Porsche" } } )

$정규식

$regex 연산자는 쿼리에서 일치 문자열을 패턴화하는 정규식 기능을 제공합니다. MongoDB는 Perl과 호환되는 정규식을 활용합니다.

 {<field> : /pattern/ <options>}

다음 예는 "$78900" 문자열이 있는 모든 자동차를 필터링하는 데 도움이 됩니다.

 db.cars.find( { price: { $regex: /$78900/ } } )

$expr

$expr 연산자를 사용하면 쿼리 언어 내에서 집계 표현식을 활용할 수 있습니다.

 { $expr: { <expression> } }

$expr 을 사용하여 $match 단계에서 동일한 문서의 필드를 비교하는 쿼리 표현식을 작성할 수도 있습니다. $match 단계가 $lookup 단계의 일부인 경우 $expr 은 let 변수의 도움으로 필드를 비교할 수 있습니다.

$어디

You can leverage the $where operator to either pass a string containing a full JavaScript function or a JavaScript expression to the query system. The $where operator provides greater flexibility but needs the database to process the JavaScript function or expression for every document in the collection. You can reference this document in the JavaScript function or expression by using either obj or this .

Here's an example of the syntax:

 { $where: <string|JavaScript Code> }

There are a few key considerations to keep in mind before we dive into an example while using the $where operator:

You should only use the $where query operator to top-level documents. The $where query operator won't function in a nested document, like in a $elemMatch query.
Generally, you should use $where only when you cannot express your query via another operator. If you have to use $where , make sure you include at least one other standard query operator to filter the result set. Using $where independently requires a collection scan for proper execution.

Here's an example to illustrate this:

 db.cars.find( { $where: function() { return (hex_md5(this.name)== "9a43e617b50cd379dca1bc6e2a8") } } );

비트 연산자

Bitwise operators return data based on bit position conditions. Simply put, they are used to match numeric or binary values in which any bit from a set of bit positions has a value of 1 or 0.

$bitsAllSet

This operator will match all the documents where all of the bit positions provided by the query are set (ie 1) in the field:

{ <field> : { $bitsAllSet: <numeric bitmask> } }

 { <field> : { $bitsAllSet: < BinData bitmask> } }

 { <field> : { $bitsAllSet: [ <position1> , <position2> , ... ] } }

필드 값은 현재 문서와 일치하도록 $bitsAllSet 에 대한 BinData 인스턴스 또는 숫자여야 합니다.

다음 인스턴스에서는 다음 문서와 함께 컬렉션을 활용하고 있습니다.

 db.collection.save({ _id: 1, a: 54, binaryValueofA: "00110110" }) db.collection.save({ _id: 2, a: 20, binaryValueofA: "00010100" }) db.collection.save({ _id: 3, a: 20.0, binaryValueofA: "00010100" }) db.collection.save({ _id: 4, a: BinData(0, "Zg=="), binaryValueofA: "01100110" })

아래에 언급된 쿼리는 $bitsAllSet 연산자를 사용하여 필드 a의 위치 1과 위치 5에 비트가 설정되어 있는지 테스트합니다. 여기서 최하위 비트는 위치 0에 있습니다.

 db.collection.find( { a: { $bitsAllSet: [ 1, 5 ] } }

이 쿼리는 다음 문서와 일치합니다.

 { "_id" : 1, "a" : 54, "binaryValueofA" : "00110110" } { "_id" : 4, "a" : BinData(0,"Zg=="), "binaryValueofA" : "01100110" }

$bitsAllClear

$bitsAllClear 연산자는 쿼리에서 제공한 모든 비트 위치가 clear 또는 0 인 문서와 일치합니다.

 { <field> : { $bitsAllClear: <numeric bitmask> } }

 { <field> : { $bitsAllClear: < BinData bitmask> } }

 { <field> : { $bitsAllClear: [ <position1> , <position2> , ... ] } }

여기에서 $bitsAllSet 에 사용된 예제를 사용하여 $ $bitsAllClear 의 사용법을 보여줍니다. 다음 쿼리는 이 연산자를 사용하여 필드 a의 위치 1과 5에서 비트가 지워졌는지 확인합니다.

 db.collection.find( { a: { $bitsAllClear: [ 1, 5 ] } } )

이 쿼리는 다음 문서와 일치합니다.

 { "_id" : 2, "a" : 20, "binaryValueofA" : "00010100" } { "_id" : 3, "a" : 20, "binaryValueofA" : "00010100" }

메타 연산자

MongoDB에서 쿼리의 동작이나 출력을 수정할 수 있는 다양한 쿼리 수정자가 있습니다. 드라이버 인터페이스는 사용자가 사용할 수 있도록 래핑하는 커서 메서드를 제공할 수 있습니다.

$힌트

MongoDB는 v3.2부터 $hint 를 더 이상 사용하지 않습니다. 그러나 이 연산자는 Go, Java, Scala, Ruby, Swift 등과 같은 MongoDB 드라이버에서 계속 사용할 수 있습니다. 쿼리 최적화 프로그램이 특정 인덱스를 활용하여 쿼리를 수행하도록 할 수 있습니다. 인덱스 이름.

$hint 연산자를 사용하여 인덱싱 전략과 쿼리 성능을 테스트할 수도 있습니다. 예를 들어 다음 작업을 수행합니다.

 db.users.find().hint( { age: 1 } )

이 작업은 age 필드의 인덱스를 활용하여 users 라는 컬렉션 내의 모든 문서를 반환합니다.

다음 형식 중 하나를 사용하여 힌트를 언급할 수도 있습니다.

 db.users.find()._addSpecial( "$hint", { age : 1 } ) db.users.find( { $query: {}, $hint: { age : 1 } } )

쿼리 형태에 대한 인덱스 필터가 있는 경우 MongoDB는 $hint 를 무시합니다.

$comment

$comment 연산자를 사용하면 $query 가 나타날 수 있는 모든 컨텍스트에서 쿼리에 주석을 첨부할 수 있습니다. 댓글은 프로필 로그로 전파되기 때문에 댓글을 추가하면 프로필을 더 쉽게 해석하고 추적할 수 있습니다.

다음 세 가지 방법 중 하나로 $comment 를 활용할 수 있습니다.

 db.collection.find( { <query> } )._addSpecial( "$comment", <comment> ) db.collection.find( { <query> } ).comment( <comment> ) db.collection.find( { $query: { <query> }, $comment: <comment> } )

db.collection.update() 와 같이 다른 컨텍스트에서 쿼리 표현식에 주석을 첨부하려면 메타 연산자 대신 $comment 쿼리 연산자를 활용하세요.

$최대

$max 값을 언급하여 find() 의 결과를 제한하기 위해 특정 인덱스에 대한 배타적 상한을 지정할 수 있습니다. 이 연산자는 인덱스에서 특정 순서의 모든 키에 대한 상한을 지정합니다.

Mongosh는 다음과 같은 max() 래퍼 메서드를 제공합니다.

 db.collection.find( { <query> } ).max( { field1: <max value> , ... fieldN: <max valueN> } )

다음 두 가지 형식으로 $max 를 언급할 수도 있습니다.

 db.collection.find( { <query> } )._addSpecial( "$max", { field1: <max value1> , ... fieldN: <max valueN> } ) db.collection.find( { $query: { <query> }, $max: { field1: <max value1> , ... fieldN: <max valueN> } } )

예를 들어, 배타적 상한을 지정하려면 { age: 1 } 인덱스를 포함하는 컬렉션 이름의 컬렉션에 대해 다음 작업을 염두에 두십시오.

 db.collection.find( { <query> } ).max( { age: 100 } ).hint( { age: 1 } )

이 작업은 필드 age가 100보다 작은 문서로 쿼리를 제한하고 minKey 에서 100으로 { age: 1 } 인덱스를 스캔하는 쿼리 계획을 강제 실행합니다.

$explain

이 연산자는 쿼리 계획에 대한 정보를 제공합니다. 쿼리를 반환하는 데 사용되는 인덱스와 프로세스를 설명하는 문서를 반환합니다. 이것은 쿼리를 최적화하려고 할 때 유용할 수 있습니다.

다음 형식 중 하나로 $explain 연산자를 언급할 수 있습니다.

 db.collection.find()._addSpecial( "$explain", 1 ) db.collection.find( { $query: {}, $explain: 1 } )

MongoDB 운영자를 위한 모범 사례

이 섹션에서는 이러한 MongoDB 연산자를 사용하는 동안 몇 가지 모범 사례를 살펴보겠습니다.

임베딩 및 참조

임베딩은 데이터 모델링의 자연스러운 확장입니다. 업데이트 및 쿼리를 줄일 수 있는 응용 프로그램 조인을 피할 수 있습니다.

단일 문서 내에서 1:1 관계로 데이터를 포함할 수 있습니다. 즉, "많은" 개체가 상위 문서와 함께 나타나는 다:1 관계의 데이터도 좋은 후보가 될 수 있습니다.

이러한 유형의 데이터를 동일한 문서에 저장하는 것은 신중한 선택처럼 들립니다. 그러나 임베딩은 이러한 종류의 데이터 집약성을 가진 읽기 작업에 더 나은 성능을 제공합니다.

임베디드 데이터 모델은 또한 개발자가 단일 쓰기 작업으로 관련 데이터를 업데이트하는 데 도움이 될 수 있습니다. 이것은 단일 문서 쓰기가 트랜잭션이기 때문에 작동합니다.

다음 시나리오에서는 참조 사용을 고려해야 합니다.

문서 세그먼트를 업데이트하면 계속 길어지고 나머지 문서는 정적입니다.
문서에 액세스했지만 거의 사용되지 않는 데이터가 포함된 경우. 임베딩은 인메모리 요구사항만 증가시키므로 참조하는 것이 더 합리적입니다.
문서 크기가 MongoDB의 16MB 문서 제한을 초과하는 경우. 이는 다:1 관계(예 : 직원:부서 )를 모델링할 때 발생할 수 있습니다.

프로파일링 및 쿼리 패턴 검사

대부분의 개발자에게 성능 최적화의 첫 번째 단계는 실제 및 예상 쿼리 패턴을 이해하는 것입니다. 애플리케이션의 쿼리 패턴을 충분히 알고 나면 데이터 모델을 만들고 적절한 인덱스를 선택할 수 있습니다.

MongoDB 개발자는 성능을 향상시킬 수 있는 다양한 강력한 도구에 액세스할 수 있습니다. 하지만 그렇다고 해서 쿼리 프로필과 패턴을 무시할 수 있는 것은 아닙니다.

예를 들어, 성능을 향상시키는 한 가지 쉬운 방법은 쿼리 패턴을 분석하고 데이터를 포함할 수 있는 위치를 이해하는 것입니다. 주요 쿼리 패턴을 식별한 후 MongoDB 성능을 강화하는 다른 방법은 다음과 같습니다.

쿼리하는 모든 필드에 인덱스가 있는지 확인합니다.
읽기 부하를 줄이기 위해 문서에 자주 하위 쿼리의 결과를 저장합니다.
느린 쿼리를 보기 위해 로그를 살펴본 다음 인덱스를 확인합니다.

데이터 인덱싱 및 모델링 검토

데이터 모델을 만드는 동안 데이터 간의 관계를 모델링하는 방법을 결정할 것입니다. 예를 들어 문서를 포함할 시기를 선택하는 것과 대신 다른 컬렉션에 있는 별도의 문서에서 참조를 만드는 것은 애플리케이션별 고려 사항의 한 예입니다.

JSON 문서의 주요 장점은 개발자가 애플리케이션의 요구 사항에 따라 데이터를 모델링할 수 있다는 것입니다. 하위 문서와 배열을 중첩하면 간단한 텍스트 문서를 활용하여 데이터 간의 복잡한 관계를 모델링하는 데 도움이 됩니다.

MongoDB를 사용하여 다음을 모델링할 수도 있습니다.

지리 공간 데이터
테이블, 평면 및 기둥 구조
간단한 키-값 쌍
시계열 데이터
연결된 그래프 데이터 구조의 에지 및 노드 등

샤딩 및 복제 모니터링

복제는 수평적 확장을 통해 데이터 가용성을 높이므로 성능 향상에 중추적일 수 있습니다. 복제는 이중화를 통해 성능과 보안을 향상시킬 수 있습니다.

성능 모니터링은 원활한 기능을 보장하기 위해 추가 리소스와 시간이 필요한 번거로움이 될 수 있습니다. 특정 요구 사항을 충족하는 시장에서 사용 가능한 성능 모니터링 도구를 활용할 수 있습니다.

예를 들어 Kinsta APM은 WordPress 사이트의 MySQL 데이터베이스 쿼리, PHP 프로세스, 외부 HTTP 호출 등에 대한 타임스탬프 정보를 가져올 수 있습니다. 이 무료 도구를 사용하여 디버그할 수도 있습니다.

긴 API 호출
긴 외부 URL 요청
몇 가지 예를 들면 느린 데이터베이스 쿼리입니다.

MongoDB에서 복제는 개발자가 여러 보조 노드에 걸쳐 기본 노드 또는 서버에서 데이터를 복사할 수 있도록 하는 복제 세트를 통해 달성할 수 있습니다. 이렇게 하면 복제에서 기본이 아닌 보조에서 일부 쿼리를 실행할 수 있으므로 경합을 피하고 로드 밸런싱을 개선할 수 있습니다.

MongoDB의 샤딩된 클러스터는 잠재적으로 성능을 향상시키는 또 다른 방법입니다. 복제와 유사하게 샤딩을 사용하여 여러 서버에 대규모 데이터 세트를 배포할 수 있습니다.

개발자는 분할 키를 활용하여 여러 서버에 분할 또는 데이터 조각을 복사할 수 있습니다. 이러한 서버는 함께 작동하여 모든 데이터를 사용할 수 있습니다.

샤딩은 쓰기/읽기를 위한 수평적 확장, 더 높은 가용성 및 증가된 저장 용량을 포함하여 상당한 이점을 가지고 있습니다.

메모리 사용 결정

MongoDB는 애플리케이션의 작업 집합(예: 자주 액세스하는 데이터 및 인덱스)이 문제 없이 메모리에 들어갈 때 가장 잘 수행됩니다. 다른 요소가 성능에 중추적인 역할을 하지만 RAM 크기는 인스턴스 크기 조정에 가장 중요합니다.

응용 프로그램의 작업 집합이 RAM에 맞는 경우 디스크의 읽기 활동이 낮아야 합니다. 그러나 작업 세트가 인스턴스 서버의 RAM 또는 크기를 초과하면 읽기 활동이 시작됩니다.

이 문제가 발생하면 더 많은 메모리가 있는 더 큰 인스턴스로 이동하여 문제를 해결할 수 있습니다.

끝에 다중 값 필드 배치

몇 개의 필드를 인덱싱하고 쿼리하려는 필드 중 하나가 이러한 "다중 값" 연산자 중 하나를 사용하는 경우 인덱스 끝에 넣어야 합니다. 정확한 값에 대해 쿼리된 필드가 먼저 표시되고 "다중 값" 연산자가 색인에서 마지막에 표시되도록 색인을 정렬해야 합니다.

이에 대한 예외는 필드를 기준으로 정렬하는 것입니다. 이를 "다중 값" 필드와 정확한 필드 사이에 배치하여 필요한 메모리 내 정렬의 양을 줄이십시오.

요약

MongoDB의 경우 속도는 게임의 이름입니다. 쿼리를 빠르게 반환하기 위해 MongoDB는 연산자를 활용하여 수학적 또는 논리적 작업을 실행합니다. 간단히 말해서, MongoDB 연산자를 이해하는 것이 MongoDB를 마스터하는 열쇠입니다.

이 기사에서는 비교 연산자, 논리 연산자, 메타 연산자, 프로젝션 연산자 등 데이터에 사용할 수 있는 몇 가지 주요 MongoDB 연산자를 강조했습니다. 또한 MongoDB 연산자를 사용하는 방법과 최상의 결과를 얻을 수 있는 모범 사례를 이해하는 데 도움이 됩니다.

모든 연산자 중 가장 자주 사용하는 연산자는 무엇이며 그 이유는 무엇입니까? 아래 의견을 공유하세요. 여러분의 생각을 듣고 싶습니다!