知っておくべき9種類のMongodbオペレーター

どのようなビジネスにおいても、データは最大の資産です。 データを分析することで、顧客の傾向や行動予測に関する意思決定を行うことができます。 これにより、ビジネスの収益性と効果的な意思決定が向上します。

データベース ソフトウェアがなければ、レコードでいっぱいのシステム内のすべての値の平均を求めるような単純な作業は面倒です。 幸いなことに、データベースでは、関数と演算子を使用してデータを簡単かつ迅速に分析できるようになりました。

この記事では、MongoDB データベース ソフトウェアで使用される演算子について説明します。

MongoDB オペレーターとは

MongoDB は、ドキュメント指向の情報を管理する NoSQL データベース ソフトウェアです。

MongoDB の重要な機能の 1 つは、その速度です。 クエリをより速く返すために、MongoDB は演算子を使用して特定の機能を実行する場合があります。

演算子は、コンパイラが数学的または論理的なタスクを実行するのに役立つ特別な記号です。 MongoDB は、データベースと対話するためのいくつかのタイプのオペレーターを提供します。

MongoDB オペレーターの種類

9 種類の演算子があり、それぞれがその機能にちなんで名付けられています。 たとえば、論理演算子は論理演算を使用します。 それらを実行するには、特定のキーワードを使用し、構文に従う必要があります。 ただし、従うのはかなり簡単です。

この記事の終わりまでに、各演算子とその機能の基本を学習できるようになります。

論理演算子

論理演算子は、特定の条件に基づいてデータをフィルター処理するためによく使用されます。 また、多くの条件を評価することもできます。これについては、後で詳しく説明します。

以下は、使用できるいくつかの論理演算子です。

$and

「and」条件は、2 つ以上の式の配列に対して論理「and」演算を実行します。 式の条件をすべて満たす文書を選択します。

$and式の標準構文は次のとおりです。

 { $and: [ { <expression1> }, { <expression2> }, ... , { <expressionN> } ] }たとえば、価格が $10 で数量が 15 未満のドキュメントを選択する場合、次のクエリを入力できます。

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

$または

「or」条件は、2 つ以上の式の配列に対して論理「or」演算を実行します。 式の少なくとも 1 つが true であるドキュメントを選択します。

$or式の標準構文は次のとおりです。

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

たとえば、価格が 10 ドルまたは数量が 15 未満のドキュメントを選択する場合は、次のクエリを入力できます。

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

式を 2 つの基準に限定する必要はありません。さらに追加できます。 たとえば、次のクエリは、価格が 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

この演算子は、1 つ以上の式を使用して、配列に対して論理 "nor" 演算を実行します。 次に、クエリ式に失敗するドキュメントを選択します。 簡単に言うと、 $or条件の反対のことを行います。

一般的な構文は次のとおりです。

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

次のクエリを考えてみましょう。

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

このクエリは、以下を含むドキュメントを選択します。

• 価格フィールドの値が $3.99 と等しくなく、セールの値が true と等しくない。 また
• 価格フィールドの値が $3.99 でなく、セール フィールドが空または存在しない。 また
• price フィールドがなく、sale フィールドが true に等しくない。 また
• 価格フィールドも販売フィールドも入力されていないか、存在していません。

$ない

この演算子は、指定された式の配列に対して論理「否定」演算を実行します。 次に、クエリ式に一致しないドキュメントを選択します。 これには、フィールドを含まないドキュメントが含まれます。

一般的な構文は次のとおりです。

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

たとえば、次のクエリを使用します。

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

このクエリは、以下を含むドキュメントを選択します。

• 値が $3.99 以上の価格フィールド。 と
• 価格フィールドが入力されていないか、存在しません。

比較演算子

比較演算子を使用して、1 つ以上のドキュメントの値を比較できます。

以下は、スーパーマーケット店の単純な在庫収集のサンプル コードです。

 { _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" ] }

($nin) にありません

この演算子は、指定された値に一致しないドキュメントを返します。 $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」さえ存在しないドキュメントでは構成されません。

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

結果は、フィールド「red」を含まないドキュメントで構成されます。

 { 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、integer、および string 値が含まれます。

zipcode として指定されたデータ型を持つドキュメントのみが必要な場合 (この例では string を使用します)、次のクエリをコンパイラに入力する必要があります。

 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 値を含む「number」型があります。

 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演算子は、少なくとも 1 つの配列要素が演算子に渡された型と一致するドキュメントを返します。

配列演算子

MongoDB は、配列を含むドキュメントをクエリするための配列演算子でも構成されています。

主な演算子は$all 、 $elemMatch 、 $sizeの 3 つです。 以下でそれぞれについて詳しく説明します。

$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」にリンクされている在庫からドキュメント (この場合は衣服) を取得したいと考えています。 以下のクエリは$all演算子を使用しています。タグ フィールドの値は、要素に「y2k」と「trendy」が含まれる配列です。

 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演算子は、指定されたすべてのクエリ条件に一致する要素が少なくとも 1 つある配列フィールドを含むドキュメントと一致します。

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

$lteや$gteなどの比較演算子を使用できますが、 $elemMatch内で単一のクエリ条件のみを指定し、 $notまたは$ne演算子を使用していない場合、 $elemMatchの使用は省略できます。同じ機能。

この演算子を使用する際には、さらにいくつかの注意事項があります。主に次のとおりです。

• $elemMatch操作で$where式を指定することはできません。
• $elemMatch操作で$textクエリ式を指定することはできません。

たとえば、生徒の結果コレクションには次のドキュメントがあります。

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

次のクエリは、結果配列に 90 以上で 95 未満の要素が少なくとも 1 つ含まれるドキュメントのみに一致します。

 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] }の 2 つの要素を持つ配列ですが、 { field: blue}または{ field: [ raspberry, lemon, grapefruit ] }ではありません{ field: [ raspberry, lemon, grapefruit ] } .

ただし、サイズとして特定の値を入力することはできますが、サイズとして値の範囲を指定することはできません。

地理空間演算子

MongoDB では、地理空間データを GeoJSON 型の形式で保存できます。 GeoJSON は、地理的特徴を表し、非空間属性をサポートできる JavaScript オブジェクト表記に基づくオープン標準形式です。 この記事で説明する地理空間演算子には、ジオメトリ指定子とクエリ セレクターの 2 種類があります。

$geometry

この演算子は、地理空間クエリ演算子$geoIntersects 、 $geoWithin 、 $nearSphere 、および$nearで使用する GeoJSON ジオメトリに言及します。 $geometryは、デフォルトの座標参照系 (CRS) として EPSG:4326 を利用します。

デフォルトの 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> ] } } } }

1 つの半球より大きい領域を持つ 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 データを選択します。ポリゴンの面積は、1 つの半球の面積よりも小さくなります。

 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

$nearSphereを使用して、地理空間クエリが最も近いドキュメントから最も遠いドキュメントを返すポイントを指定できます。

MongoDB は、球面ジオメトリを使用して$nearSphereの距離を計算します。 次のような地理空間インデックスが必要です。

1. 従来の座標ペアとして記述された位置データの 2 次元インデックス。 GeoJSON ポイントの 2d インデックスを利用するには、GeoJSON オブジェクトの座標フィールドにインデックスを生成する必要があります。
2. 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

$center演算子は、円の範囲内にある従来の座標ペアを返す$geoWithinクエリの円に言及します。

$centerは GeoJSON オブジェクトを返しません。 $center演算子を利用するには、以下を含む配列を指定する必要があります。

1. 座標系で使用される単位で測定された円の半径。
2. 円の中心点のグリッド座標。

 { <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 (投影)

$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 つの要素を含む配列を返します。 配列に含まれる要素が 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" } ] }

$ (投影)

位置$演算子は、配列の内容を制限して、その配列のクエリ条件に一致する最初の要素を返します。 選択したドキュメントで特定の配列要素が 1 つだけ必要な場合は、 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 スキーマの実装には、 bsonTypeキーワードが追加されています。これにより、 $jsonSchemaオペレーター内ですべての BSON タイプを使用できます。

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オペレーターでサポートされていないものがいくつかあることに注意してください。

1. 整数型。 bsonType キーワードで BSON タイプ long または int を活用する必要があります。
2. 不明なキーワード。
3. プロパティと JSON スキーマのハイパーメディアのリンク、および JSON 参照と JSON ポインターの使用。

$テキスト

$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 変数を使用してフィールドを比較できます。

$where

$where演算子を利用して、完全な JavaScript 関数を含む文字列または JavaScript 式をクエリ システムに渡すことができます。 $where演算子はより高い柔軟性を提供しますが、データベースがコレクション内のすべてのドキュメントの JavaScript 関数または式を処理する必要があります。 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演算子は、クエリによって提供されるすべてのビット位置がクリアまたは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演算子を使用すると、 $queryが表示される可能性のある任意のコンテキストでクエリにコメントを添付できます。 コメントはプロファイル ログに反映されるため、コメントを追加すると、プロファイルの解釈と追跡が容易になります。

$commentは、次の 3 つの方法のいずれかで活用できます。

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

次の 2 つの形式で$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 }を含む collection という名前のコレクションに対する次の操作に注意してください。

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

この操作は、クエリをフィールド age が 100 未満のドキュメントに限定し、 { age: 1 }インデックスをminKeyから 100 までスキャンするクエリ プランを強制します。

$説明する

この演算子は、クエリ プランに関する情報を提供します。 クエリを返すために使用されるインデックスとプロセスを説明するドキュメントを返します。 これは、クエリを最適化しようとするときに役立ちます。

次のいずれかの形式で$explain演算子を指定できます。

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

MongoDB オペレーターのベスト プラクティス

このセクションでは、これらの MongoDB オペレーターを使用する際のベスト プラクティスをいくつか見ていきます。

埋め込みと参照

埋め込みは、データ モデリングの自然な拡張です。 アプリケーションの結合を回避できるため、更新とクエリを減らすことができます。

1 つのドキュメント内に 1 対 1 の関係でデータを埋め込むことができます。 とはいえ、「多くの」オブジェクトがその親ドキュメントとともに表示される多対 1 の関係を持つデータも、適切な候補になる可能性があります。

これらのタイプのデータを同じドキュメントに格納することは、賢明な選択のように思えます。 ただし、埋め込みは、この種のデータ局所性を使用した読み取り操作のパフォーマンスを向上させます。

埋め込みデータ モデルは、開発者が 1 回の書き込み操作で関連データを更新するのにも役立ちます。 これは、単一のドキュメントの書き込みがトランザクションであるため機能します。

次のシナリオでは、参照の使用を検討する必要があります。

• ドキュメント セグメントを更新すると、ドキュメントの残りの部分は静的であるにもかかわらず、長くなり続けます。
• ドキュメントがアクセスされたが、めったに使用されないデータが含まれている場合。 埋め込みはメモリ内の要件を増やすだけなので、参照はより理にかなっています。
• ドキュメント サイズが MongoDB の 16MB ドキュメント制限を超えた場合。 これは、多対 1 の関係 (たとえば、 employees:department ) をモデル化するときに発生する可能性があります。

プロファイリングとクエリ パターンの調査

ほとんどの開発者にとって、パフォーマンスを最適化するための最初のステップは、実際のクエリ パターンと予想されるクエリ パターンを理解することです。 アプリケーションのクエリ パターンを十分に理解したら、データ モデルを作成し、適切なインデックスを選択できます。

MongoDB 開発者は、パフォーマンスを向上させるさまざまな強力なツールにアクセスできます。 しかし、それはクエリ プロファイルとパターンを無視できるという意味ではありません。

たとえば、パフォーマンスを向上させる簡単な方法の 1 つは、クエリ パターンを分析し、どこにデータを埋め込むことができるかを理解することです。 主要なクエリ パターンを特定した後に MongoDB のパフォーマンスを向上させるその他の方法には、次のようなものがあります。

• クエリを実行するすべてのフィールドにインデックスがあることを確認します。
• ドキュメントに対する頻繁なサブクエリの結果を保存して、読み取り負荷を軽減します。
• ログを見て遅いクエリを確認し、次にインデックスを確認します。

データのインデックス作成とモデリングの確認

データ モデルを作成するときに、データ間の関係をモデル化する方法を決定します。 たとえば、ドキュメントを埋め込むタイミングと、異なるコレクション内の個別のドキュメント間で参照を作成するタイミングの選択は、アプリケーション固有の考慮事項の例です。

JSON ドキュメントの主な利点は、開発者がアプリケーションの要件に基づいてデータをモデル化できることです。 サブドキュメントと配列をネストすると、単純なテキスト ドキュメントを活用して、データ間の複雑な関係をモデル化するのに役立ちます。

MongoDB を使用して、以下をモデル化することもできます。

• 地理空間データ
• 表形式、フラット、および柱状の構造
• 単純なキーと値のペア
• 時系列データ
• 接続されたグラフ データ構造などのエッジとノード

シャーディングとレプリケーションを監視する

水平方向のスケーリングによってデータの可用性が向上するため、レプリケーションはパフォーマンスの向上に極めて重要です。 レプリケーションは、冗長性によってパフォーマンスの向上とセキュリティの向上につながります。

パフォーマンスの監視は、円滑な機能を確保するために追加のリソースと時間を必要とする面倒な場合があります。 特定のニーズに対応する市場で入手可能なパフォーマンス監視ツールを活用できます。

たとえば、Kinsta APM は、WordPress サイトの MySQL データベース クエリ、PHP プロセス、外部 HTTP 呼び出しなどに関するタイムスタンプ付きの情報を取得できます。 この無料ツールを使用してデバッグすることもできます。

• 長い API 呼び出し
• 長い外部 URL リクエスト
• いくつか例を挙げると、遅いデータベース クエリ。

MongoDB では、開発者がプライマリ ノードまたはサーバーから複数のセカンダリにまたがってデータをコピーできるレプリカ セットを介してレプリケーションを実現できます。 これにより、レプリケーションでプライマリではなくセカンダリでいくつかのクエリを実行できるようになり、競合が回避され、負荷分散が向上します。

MongoDB のシャード クラスターは、パフォーマンスを向上させる可能性のあるもう 1 つの方法です。 レプリケーションと同様に、シャーディングを使用して大規模なデータ セットを複数のサーバーに分散できます。

シャード キーを利用することで、開発者はシャードまたはデータの一部を複数のサーバーにコピーできます。 これらのサーバーは連携してすべてのデータを使用できます。

シャーディングには、書き込み/読み取りの水平スケーリング、可用性の向上、ストレージ容量の増加など、かなりの利点があります。

メモリ使用量の決定

MongoDB は、アプリケーションのワーキング セット (つまり、頻繁にアクセスされるデータとインデックス) が問題なくメモリに収まる場合に最高のパフォーマンスを発揮します。 パフォーマンスには他の要素も重要ですが、インスタンスのサイジングでは RAM サイズが最も重要です。

アプリケーションのワーキング セットが RAM に収まる場合、ディスクからの読み取りアクティビティは低くする必要があります。 ただし、ワーキング セットがインスタンス サーバーの RAM またはサイズを超えると、読み取りアクティビティが急増し始めます。

これが発生している場合は、より多くのメモリを備えたより大きなインスタンスに移動することで、問題を解決できる可能性があります。

複数値フィールドを最後に配置する

いくつかのフィールドにインデックスを付けており、クエリを実行するフィールドの 1 つがそれらの「複数値」演算子の 1 つを使用している場合は、それらをインデックスの最後に配置する必要があります。 正確な値のクエリ フィールドが最初に来て、「複数値」演算子がインデックスの最後に表示されるように、インデックスを並べ替える必要があります。

これに対する例外は、フィールドに対するソートです。 これらを「複数値」フィールドと正確なフィールドの間に配置して、必要なメモリ内ソートの量を削減します。

概要

MongoDB の場合、速度はゲームの名前です。 クエリをすばやく返すために、MongoDB は演算子を利用して数学または論理タスクを実行します。 簡単に言えば、MongoDB オペレーターを理解することが、MongoDB をマスターするための鍵です。

この記事では、比較演算子、論理演算子、メタ演算子、射影演算子など、データに対して使用できる主要な MongoDB 演算子のいくつかを取り上げました。 また、MongoDB オペレーターの使用方法と、それらを最大限に活用するためのベスト プラクティスを理解するのにも役立ちます。

すべての演算子の中で、最も頻繁に使用する演算子はどれですか?その理由は? 以下のコメントで共有してください — ご意見をお待ちしております!