Bilmeniz Gereken 9 Mongodb Operatörü Türü

Herhangi bir işte, veriler en büyük varlığınızdır. Verileri analiz ederek müşteri eğilimleri ve davranış tahmini hakkında kararlar verebilirsiniz. Bu, iş karlılığını ve etkili karar vermeyi artırır.

Veritabanı yazılımı olmadan, kayıtlarla dolu bir sistemdeki tüm değerlerin ortalamasını bulmak gibi basit bir iş sıkıcı olurdu. Neyse ki, veritabanları, işlevler ve operatörlerle verileri analiz etmeyi daha kolay ve daha hızlı hale getirdi.

Bu makale, MongoDB veritabanı yazılımında kullanılan operatörlere biraz ışık tutacaktır.

MongoDB Operatörleri Nelerdir?

MongoDB, belge odaklı bilgileri yöneten bir NoSQL veritabanı yazılımıdır.

MongoDB'nin temel özelliklerinden biri hızıdır. Sorguları daha hızlı döndürmek için MongoDB, belirli işlevleri gerçekleştirmek için operatörleri kullanabilir.

Operatörler, derleyicilerin matematiksel veya mantıksal görevleri gerçekleştirmesine yardımcı olan özel sembollerdir. MongoDB, veritabanıyla etkileşime geçmek için çeşitli operatör türleri sunar.

MongoDB Operatör Tipleri

Her biri işlevine göre adlandırılan dokuz tür operatör vardır. Örneğin, mantıksal operatörler mantıksal işlemleri kullanır. Bunları yürütmek için belirli bir anahtar kelime kullanmanız ve sözdizimini izlemeniz gerekir. Ancak, takip etmeleri oldukça kolaydır!

Makalenin sonunda, her operatörün ve işlevlerinin temellerini öğrenebileceksiniz.

Mantıksal operatörler

Mantıksal operatörler genellikle verileri verilen koşullara göre filtrelemek için kullanılır. Ayrıca, daha ayrıntılı olarak tartışacağımız birçok koşulun değerlendirilmesine izin verirler.

Aşağıda, kullanabileceğiniz birkaç mantıksal operatör bulunmaktadır:

$ve

Bir "ve" koşulu, iki veya daha fazla ifadeden oluşan bir dizi üzerinde mantıksal bir "ve" işlemi gerçekleştirir. İfadelerin tüm koşullarının sağlandığı belgeleri seçer.

Bu, $and ifadesinin standart sözdizimidir:

 { $and: [ { <expression1> }, { <expression2> }, ... , { <expressionN> } ] } Örneğin, fiyatı 10$ olan ve miktarı 15'ten az olan belgeleri seçmek istiyorsak, aşağıdaki sorguyu girebiliriz:

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

$veya

Bir "veya" koşulu, iki veya daha fazla ifadeden oluşan bir dizi üzerinde mantıksal bir "veya" işlemi gerçekleştirir. İfadelerden en az birinin doğru olduğu belgeleri seçer.

Bu, $or ifadesinin standart sözdizimidir:

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

Örneğin, fiyatı 10 ABD doları olan veya miktarı 15'ten az olan belgeleri seçmek istersek, aşağıdaki sorguyu girebiliriz:

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

İfadeyi iki kriterle sınırlamak zorunda değiliz - daha fazlasını ekleyebiliriz. Örneğin, aşağıdaki sorgu, fiyatın 10$'a eşit olduğu, miktarın 15'in altında olduğu veya etiketin sabit olduğu belgeleri seçer:

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

Bu maddeleri çalıştırırken, MongoDB ya bir koleksiyon taraması ya da bir indeks taraması gerçekleştirir. Tüm dizinler yan tümceleri destekliyorsa, MongoDB bir $or ifadesini kontrol etmek için dizinleri kullanır. Aksi takdirde, bunun yerine bir koleksiyon taraması kullanır.

Ancak aynı alanda kriterleri test etmek istiyorsanız, $or operatörü yerine $in operatörünü kullanmak isteyebilirsiniz. Örneğin, miktarın 10 veya 20 olduğu bir belge koleksiyonu istiyorsanız, bunun yerine aşağıdaki $in sorgusunu çalıştırmanız gerekebilir:

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

$in operatörüne daha sonra değineceğiz.

$ ne de

Bu operatör, bir veya daha fazla ifade kullanarak bir dizi üzerinde mantıksal bir "nor" işlemi gerçekleştirir. Ardından, sorgu ifadelerinde başarısız olan belgeleri seçer. Daha basit bir ifadeyle, $or koşulunun tersini yapar.

Bu genel sözdizimidir:

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

Aşağıdaki sorguyu ele alalım:

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

Bu sorgu, aşağıdakileri içeren belgeleri seçer:

• 3,99 ABD Dolarına eşit olmayan bir fiyat alanı değeri ve doğruya eşit olmayan bir satış değeri; veya
• 3,99 ABD Dolarına eşit olmayan bir fiyat alanı değeri ve boş veya eksik bir satış alanı; veya
• fiyat alanı yok ve satış alanı true değerine eşit değil; veya
• ne fiyat alanı ne de satış alanı dolduruldu veya mevcut değil.

$değil

Bu operatör, belirtilen ifade için bir dizi üzerinde mantıksal bir "değil" işlemi gerçekleştirir. Ardından sorgu ifadeleriyle eşleşmeyen belgeleri seçer. Bu, alanı içermeyen belgeleri içerir.

Bu genel sözdizimidir:

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

Örneğin, aşağıdaki sorguyu alın:

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

Bu sorgu, aşağıdakileri içeren belgeleri seçer:

• değeri 3,99 ABD Dolarına eşit veya daha büyük olan bir fiyat alanı; ve
• bir fiyat alanı doldurulmamış veya mevcut değil.

Karşılaştırma Operatörleri

Karşılaştırma operatörleri, bir veya daha fazla belgedeki değerleri karşılaştırmak için kullanılabilir.

Aşağıda bir süpermarket mağazası için basit bir envanter koleksiyonunun örnek kodu verilmiştir:

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

Sonraki her karşılaştırma operatörünü detaylandırırken bu örneği kullanacağız.

($eq) eşittir

Bu operatör, verilen değere eşit olan değerlerle eşleşir:

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

Örneğin, envanter koleksiyonundan tam miktar değeri “20” olan belirli bir belgeyi almak istersek, aşağıdaki komutu gireriz:

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

Sorgu aşağıdakileri döndürür:

 { _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) değerinden büyük

Bu operatör, değerler verilen değerden büyükse eşleşir:

 { field: { $gt: value } }

Bu örnekte, miktarın 15'ten büyük olduğu belgeleri alıyoruz:

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

Sorgu aşağıdakileri döndürür:

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

Daha az ($lt)

Bu operatör, değerler sağlanan değerden küçükse eşleşir:

 { field: { $lt: value } }

Miktarı 25'ten az olan belgeleri bulalım:

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

Sorgu aşağıdakileri döndürür:

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

Büyük veya eşit ($gte)

Bu operatör, değerler verilen değerden büyük veya ona eşit olduğunda eşleşir:

 { field: { $gte: value } }

Bu örnekte, miktarın 25'e eşit veya daha büyük olduğu belgeleri alıyoruz:

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

Bu sorgu aşağıdakileri döndürür:

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

Daha az veya eşit ($lte)

Bu operatör, yalnızca değerler verilen değere eşit veya daha küçükse eşleşir:

 { field: { $lte: value } }

Miktarı 25'e eşit veya altında olan belgeleri bulalım.

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

Bu sorgunun aşağıdakileri döndürmesini bekleyebiliriz:

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

içinde ($inç)

Bu operatör, belirtilen değerlerle eşleşen belgeleri döndürür:

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

Bir alanın değeri, belirtilen dizideki herhangi bir değere eşittir. Örneğin, envanter koleksiyonunda "30" ve "15" değerlerine sahip belgeleri almak için şunu yapardınız:

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

Çıktı şöyle olurdu:

 { _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) içinde değil

Bu operatör, verilen değerlerle eşleşmeyen belgeleri döndürür. $nin operatörünün temel sözdizimi şöyledir:

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

$nin aşağıdaki belgeleri seçer:

• alan değeri belirtilen dizide değil; veya
• alan yok.

Alan dizileri içeriyorsa, değer bölümünde belirtilen hiçbir öğenin bulunmadığı dizileri seçecektir. Örneğin, miktarın 20 veya 15'e eşit olmadığı belgeleri seçmek istiyoruz.

Ayrıca, miktar alanı olmayan belgelerle de eşleşir:

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

Çıktı şöyle olurdu:

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

Eşit Değil ($ne)

$ne operatörü, belirtilen değerin eşit olmadığı belgeleri döndürür:

 { $ne: value } }

Örneğin, miktarın 20'ye eşit olmadığı tüm belgeleri seçmek istediğimizi varsayalım:

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

Çıktı şöyle olurdu:

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

Yukarıdaki çıktıdan, sorgunun miktar alanı olmayan belgeleri seçeceğini görebiliriz.

Eleman Operatörleri

Öğe sorgu operatörleri, belgenin alanlarını kullanarak belgeleri tanımlayabilir. Eleman operatörleri $exist ve $type 'dan oluşur.

$var

Bu operatör, belirli bir alana sahip belgelerle eşleşir. Bu operatör, true veya false olabilen bir boole değerine sahiptir.

true olarak belirtilirse, alan değerinin boş olduğu belgeler de dahil olmak üzere, o alanı içeren belgelerle eşleşir. <boolean> false ise, sorgu yalnızca alanı içermeyen belgeleri döndürür.

İşte standart sözdizimi:

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

Her torbanın farklı renklerde bilyeler içerdiği “bagofmarbles” adlı bir dizi için bir koleksiyon verisine sahip olduğumuz bir örneği ele alalım:

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

Sadece kırmızı bilyelerin bulunduğu torbaları döndürecek bir sorgu istediğimizi varsayalım. Bu, boole değerini true olarak girmemiz gerektiği anlamına gelir. Hadi bir bakalım:

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

Sonuçlar, değer null olsa bile "kırmızı" alanını içeren belgelerden oluşacaktır. Ancak, “kırmızı” alanının bile olmadığı belgelerden oluşmazdı:

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

Sadece kırmızı bilyelerin bile olmadığı poşetleri alan olarak isteseydik, aşağıdaki sorguyu girebiliriz:

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

Sonuçlar, "kırmızı" alanını içermeyen belgelerden oluşacaktır:

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

$tür

Bu operatör, belgeleri belirtilen alan türüne göre eşleştirir. Bu, yüksek düzeyde yapılandırılmamış verileriniz olduğunda veya veri türleri tahmin edilebilir olmadığında kullanışlıdır. Bu alan türleri, belirtilen BSON türleridir ve tür numarası veya diğer adıyla tanımlanabilir.

Bu, $type için genel sözdizimidir:

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

Diyelim ki aşağıdaki belgeleri içeren bir adres defterimiz var:

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

Yukarıdaki belgelere bakıldığında, posta kodunun farklı veri türleri vardır. Bu, uzun, çift, tamsayı ve dize değerlerini içerir.

Yalnızca posta kodu olarak belirli bir veri türüne sahip belgeleri istiyorsak - bu örnek için dize alalım - derleyiciye aşağıdaki sorguyu girmemiz gerekir:

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

Bu, aşağıdaki belgeleri döndürür:

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

Ek olarak, belirtilen türlerin bir öğesini içeren bir dizi olarak tüm uzun, tamsayı veya çift değerleri içeren bir "sayı" türü vardır:

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

Çıktı:

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

Belgelerin bir dizi alanı türü varsa, $type operatörü, en az bir dizi öğesinin operatöre iletilen türle eşleştiği belgeleri döndürür.

Dizi Operatörleri

MongoDB ayrıca dizileri içeren belgeleri sorgulamak için dizi operatörlerinden oluşur.

Üç ana operatör vardır: $all , $elemMatch ve $size . Her birini aşağıda ayrıntılı olarak tartışacağız.

$hepsi

$all operatörü, bir alanın değerinin belirtilen öğeleri içeren bir dizi olduğu belgeleri seçer:

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

Örneğin, bir giyim mağazası için aşağıdakiler envanter altında olan bir belge koleksiyonumuz olduğunu varsayalım.

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

Envanterden "trendy" ve "y2k" etiketleriyle bağlantılı tüm belgeleri (bu durumda giysiler) almak isteriz. Aşağıdaki sorgu, $all operatörünü kullanır; burada etiketler alanının değeri, öğeleri "y2k" ve "trendy"yi içeren bir dizidir:

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

Yukarıdaki sorgu aşağıdakileri döndürür:

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

Yukarıdaki örnekte, $all operatörünün, $and işlemiyle aynı işlevi yerine getirdiğini de görüyoruz.

Alternatif olarak, yukarıdakine benzer bir çıktı verecek olan aşağıdaki sorguyu kullanabiliriz:

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

$elemMaç

$elemMatch operatörü, belirtilen tüm sorgu ölçütleriyle eşleşen en az bir öğeye sahip bir dizi alanı içeren belgelerle eşleşir:

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

$lte ve $gte gibi karşılaştırma operatörlerini kullanabilmemize rağmen, $elemMatch içinde yalnızca tek bir sorgu koşulu belirtirsek ve $not veya $ne operatörlerini kullanmıyorsak, $elemMatch kullanımı, esasen performans göstereceğinden ihmal edilebilir. aynı işlev.

Bu operatörü kullanırken akılda tutulması gereken birkaç şey daha vardır, özellikle:

• Bir $elemMatch $where ifadesi belirtemezsiniz.
• Bir $elemMatch bir $text sorgu ifadesi belirtemezsiniz.

Örneğin, öğrenci sonuçları koleksiyonunda aşağıdaki belgelere sahibiz:

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

Aşağıdaki sorgu yalnızca, sonuç dizisinin hem 90'dan büyük hem de 90'a eşit ve 95'ten küçük en az bir öğe içerdiği belgelerle eşleşir:

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

92 öğesi 90'dan büyük veya 90'a eşit ve 95'ten küçük olduğundan sorgumuz aşağıdaki belgeyi döndürür:

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

$boyut

$size operatörü, dizinin boyutunun bağımsız değişkende belirtilen öğe sayısıyla eşleştiği belgeleri döndürür:

 { field: { $size: value } }

İşte bir örnek:

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

Bu, belirtilen koleksiyondaki tüm belgeleri döndürür, burada alan 2 öğeli bir dizidir: { field: [ orange, apple] } ve { field: [ blue, red] } , ancak { field: blue} veya { field: [ raspberry, lemon, grapefruit ] } değil { field: [ raspberry, lemon, grapefruit ] } .

Ancak, boyut olarak belirli bir değeri girebilirken, boyut olarak değer aralıklarını belirtemeyiz.

Jeo-uzaysal Operatörler

MongoDB, coğrafi verileri GeoJSON türleri biçiminde depolamanıza olanak tanır. GeoJSON, coğrafi özellikleri temsil edebilen ve uzamsal olmayan nitelikleri destekleyebilen JavaScript nesne gösterimine dayalı açık standart bir biçimdir. Bu makalede bahsedeceğimiz iki tür jeo-uzamsal operatör vardır: geometri belirteçleri ve sorgu seçicileri.

$geometri

Bu operatör, aşağıdaki jeo-uzamsal sorgu operatörleriyle kullanım için GeoJSON geometrisinden bahseder: $geoIntersects , $geoWithin , $nearSphere ve $near . $geometry , varsayılan koordinat referans sistemi (CRS) olarak EPSG:4326'dan yararlanır.

GeoJSON nesnelerinden varsayılan CRS ile bahsetmek için, $geometry için aşağıdaki snippet'ten yararlanabilirsiniz:

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

Uyarlanmış bir MongoDB CRS ile tek halkalı bir GeoJSON poligonundan bahsetmek için aşağıdaki pasajı kullanabilirsiniz (bunu yalnızca $geoWithin ve $geoIntersects için kullanabilirsiniz):

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

$poligon

$polygon operatörü, eski koordinat çiftlerinde bir jeo-uzamsal $geoWithin sorgusu için bir çokgen belirtmek için kullanılabilir. Bu sorgu daha sonra çokgenin sınırları içinde kalan çiftleri döndürür. Ancak, $polygon herhangi bir GeoJSON nesnesi için sorgulama yapmaz. Bir çokgen tanımlamak için aşağıdaki gibi bir dizi koordinat noktası belirtmeniz gerekir:

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

Burada, son nokta dolaylı olarak birinciye bağlıdır. İstediğiniz kadar nokta veya taraf belirtebilirsiniz.

Örneğin, aşağıdaki sorgu, [0,0], [1,5] ve [3,3] tarafından tanımlanan çokgen içinde koordinatları olan tüm belgeleri döndürür:

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

$geoİçinde

Bu operatör, tamamen belirli bir şekilde bulunan jeo-uzamsal verilere sahip belgeleri seçmek için kullanılabilir. Belirtilen şekil, bir GeoJSON çokgeni, bir GeoJSON çokgeni (çok halkalı veya tek halkalı) veya eski koordinat çiftleriyle tanımlanabilen bir şekil olabilir.

$geoWithin operatörü, GeoJSON nesnesinden bahsetmek için $geometry operatöründen yararlanır.

GeoJSON çokgenlerinden veya çokgenlerinden varsayılan Koordinat Referans Sistemi (CRS) aracılığıyla bahsetmek için aşağıda belirtilen sözdizimini kullanabilirsiniz:

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

Alanları tek bir yarım küreden daha büyük olan GeoJSON geometrilerinden bahseden $geoWithin sorguları için, varsayılan CRS'nin kullanılması tamamlayıcı geometriler için sorgulara yol açacaktır.

Özel bir MongoDB CRS ile tek halkalı bir GeoJSON poligonundan bahsetmek için, $geometry ifadesinde aşağıda belirtilen prototipten yararlanabilirsiniz:

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

Aşağıdaki örnek, tamamen bir GeoJSON poligonu içinde bulunan tüm loc verilerini seçer, poligonun alanı tek bir yarım kürenin alanından küçüktür:

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

$kutu

Nokta tabanlı konum verilerine göre dikdörtgenin sınırları içinde olan belgeleri sağlamak üzere bir jeo-uzamsal $geoWithin sorgusu için bir dikdörtgen belirtmek için $box kullanabilirsiniz. $geoWithin $box box ile kullandığınızda, sorgu koordinatlarına dayalı belgeler alırsınız. Bu senaryoda, $geoWithin hiçbir GeoJSON şeklini sorgulamaz.

$box operatöründen yararlanmak için bir dizi nesnesindeki dikdörtgenin sağ üst ve sol alt köşelerinden bahsetmeniz gerekir:

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

Yukarıda bahsedilen sorgu, düzlemsel (düz) geometriyi kullanarak mesafeyi hesaplayacaktır. Aşağıdaki sorgu, [0,0], [0,30], [30,0], [30,30] noktalarına sahip kutunun içindeki tüm belgeleri döndürür:

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

$nearSphere

Bir jeo-uzamsal sorgunun belgeleri en yakından en uzağa döndürdüğü bir noktayı belirtmek için $nearSphere kullanabilirsiniz.

MongoDB, $nearSphere için mesafeleri hesaplamak için küresel geometri kullanır. Aşağıdaki gibi bir jeo-uzamsal indekse ihtiyaç duyacaktır:

1. Eski koordinat çiftleri olarak tanımlanan konum verileri için 2d dizin. GeoJSON noktalarında bir 2d dizini kullanmak için, GeoJSON nesnesinin koordinatlar alanında dizini oluşturmanız gerekir.
2. GeoJSON noktaları olarak tanımlanan konum verileri için 2dsphere dizini.

Bir GeoJSON noktasından bahsetmek için aşağıdaki söz diziminden yararlanabilirsiniz:

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

Burada $minDistance ve $maxDistance isteğe bağlıdır. $minDistance , sonuçları en azından merkezden belirtilen mesafede olan belgelerle sınırlayabilir. Her iki dizin için de $maxDistance kullanabilirsiniz.

Şimdi, 2dsphere dizinine sahip bir konum alanına sahip belgelerden oluşan bir "yerler" koleksiyonunu düşünün. Aşağıdaki örnek, konumu seçtiğiniz noktadan en az 2.000 metre ve en fazla 6.000 metre olan noktaları en yakından en uzağa doğru sıralayarak döndürür:

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

$geoIntersects

$geoIntersects operatörü, jeo-uzamsal verileri belirli bir GeoJSON nesnesiyle kesişen (yani, belirtilen nesnenin ve verilerin yakınsamasının boş olmadığı) belgeleri seçmenize olanak tanır. GeoJSON nesnesini belirtmek için $geometry operatörünü kullanır.

GeoJSON çokgenlerinden veya çokgenlerinden varsayılan koordinat referans sistemi (CRS) aracılığıyla bahsetmek için aşağıdaki sözdizimini kullanabilirsiniz:

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

Aşağıdaki örnek, koordinatlar dizisi tarafından tanımlanan çokgenle kesişen tüm loc verilerini seçmek için $geoIntersects kullanır:

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

$merkez

$center operatörü, dairenin sınırları içindeki eski koordinat çiftlerini döndüren bir $geoWithin sorgusu için bir daireden bahseder.

$center , GeoJSON nesnelerini döndürmez. $center operatöründen yararlanmak için aşağıdakileri içeren bir dizi belirtmeniz gerekir:

1. Koordinat sistemi tarafından kullanılan birimlerde ölçülen dairenin yarıçapı.
2. Dairenin merkez noktasının ızgara koordinatları.

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

Aşağıda belirtilen örnek, [2,3] merkezli ve 40 yarıçaplı daire içinde bulunabilen koordinatlara sahip tüm belgeleri döndürür:

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

Projeksiyon Operatörleri

Bir işlemin döndürdüğü alanlardan bahsetmek için projeksiyon operatörlerini kullanabilirsiniz. MongoDB projeksiyon operatörleri, find() işlevinin veri filtreleme argümanlarıyla kullanılmasına izin verir. Bu, kullanıcıların bir belgeden yalnızca gerekli veri alanlarını çıkarmasına yardımcı olur. Böylece, genel veritabanı performansını etkilemeden şeffaf ve özlü verileri yansıtmanıza olanak tanır.

$elemMatch (projeksiyon)

$elemMatch operatörü, sorgu sonuçlarındaki bir alanın içeriğini yalnızca $elemMatch koşuluyla eşleşen ilk öğeyi içerecek şekilde sınırlamaktan sorumludur.

$elemMatch kullanmadan önce aklınızda bulundurmanız gereken birkaç şey:

• MongoDB 4.4'ten, belgedeki alanların sıralamasından bağımsız olarak, mevcut bir alanın $elemMatch projeksiyonu, diğer mevcut alanların dahil edilmesinin ardından alanı döndürür.
• Hem $elemMatch hem de $ operatörleri, belirtilen bir koşula dayalı olarak bir dizideki ilk eşleşen öğeyi gösterir. $ operatörü, sorgu ifadesindeki bazı koşullara dayalı olarak bir koleksiyondaki her belgeden ilk eşleşen dizi öğesini yansıtırken, $elemMatch projeksiyon operatörü açık bir koşul argümanı alır. Bu, sorguda bulunmayan bir koşula dayalı olarak veya dizinin gömülü belgelerindeki çeşitli alanlara dayalı olarak yansıtma yapmanız gerekiyorsa projelendirmenizi sağlar.

Verilerinizde $elemMatch operatörünü kullanmadan önce aşağıdaki kısıtlamaların da farkında olmalısınız:

• Bir $elemMatch operatörü içinde bir $text sorgu ifadesinden bahsedemezsiniz.
• db.collection.find() işlemleri $elemMatch projeksiyon operatörünü desteklemez.

$elemMatch projeksiyon operatörüyle ilgili aşağıdaki örnek, schools aşağıdaki belgelere sahip olduğunu varsayar:

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

Bu örnekte, find() işlemi posta kodu alanının değerinin 63110 olduğu tüm belgeleri sorgular. $elemMatch projeksiyonu, school alanının 103 değerine sahip olduğu students dizisinin yalnızca ilk eşleşen öğesini döndürür:

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

$dilim (projeksiyon)

$slice projeksiyon operatörü, bir dizideki sorgu sonucunda döndürülecek öğelerin sayısını belirtmek için kullanılabilir:

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

Bu şekilde de ifade edilebilir:

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

Aynı şeyi göstermek için, aşağıdaki belgelerle örnek bir tweet koleksiyonu oluşturabilirsiniz:

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

Aşağıdaki işlem, diziyi ilk iki öğesiyle döndürmek için tweets dizisindeki $slice projeksiyon operatörünü kullanır. Bir dizi ikiden az eleman içeriyorsa, dizideki tüm elemanlar döndürülür:

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

Bu işlem aşağıdaki belgeleri döndürür:

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

$ (projeksiyon)

Konumsal $ operatörü, bir dizinin içeriğini, o dizinin sorgu koşuluyla eşleşen ilk öğeyi döndürecek şekilde sınırlar. $ öğesini, seçilen belgelerde yalnızca belirli bir dizi öğesine ihtiyaç duyduğunuzda find() yönteminin veya findOne() yönteminin projeksiyon belgesinde kullanabilirsiniz.

$ operatörünün sözdizimi şöyle görünür:

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

Bu örnekte, students koleksiyonu aşağıdaki belgelerden oluşur:

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

Aşağıdaki sorguda, { "grades.$": 1 } projeksiyonu, grades alanı için yalnızca 89'a eşit veya daha büyük olan ilk öğeyi döndürür:

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

Bu işlem aşağıdaki belgeleri döndürür:

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

Değerlendirme Operatörleri

Bir belgenin içindeki genel veri yapısını veya tek tek alanı ölçmek için MongoDB değerlendirme operatörlerinden yararlanabilirsiniz.

Bazı yaygın MongoDB değerlendirme operatörlerine bakalım.

$mod

Bu operatörü, belirli bir alanın değerinin belirli bir değere bölündükten sonra kalana eşit olduğu belgeleri eşleştirmek için kullanabilirsiniz:

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

Diyelim ki showroomunuzda sahibi olduğunuz farklı markalara ait bir araba tablonuz var. Aşağıdaki sorgu size stok numaraları 250'nin katları olan tüm araba markalarını verecektir.

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

$jsonŞema

$jsonSchema , belirtilen JSON şemasıyla eşleşen belgeleri eşleştirmenize olanak tanır. MongoDB'nin JSON şeması uygulaması, $jsonSchema operatörü içinde tüm BSON türlerini kullanmanıza izin veren bsonType anahtar sözcüğünün eklenmesini içerir.

bsonType , type operatörü için kullanacağınız aynı dize takma adlarını kabul edebilir. $jsonSchema sözdizimi şöyle görünür:

 { $jsonSchema: <JSON Schema object> }

Burada, JSON şema nesnesi, JSON şema standardının taslağı 4'e göre biçimlendirilir:

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

$jsonSchema nasıl çalıştığını gösteren bir örnek:

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

Ayrıca, güncelleme ve ekleme işlemlerinde belirtilen şemayı zorlamak için bir belge doğrulayıcıda $jsonSchema kullanabilirsiniz:

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

$jsonSchema operatörü tarafından desteklenmeyen birkaç şey olduğunu unutmayın:

1. Tamsayı türü. BSON type long veya int'yi bsonType anahtar sözcüğüyle kullanmanız gerekir.
2. Bilinmeyen anahtar kelimeler.
3. JSON referanslarının ve JSON işaretçilerinin kullanımıyla birlikte JSON şemasının özellikleri ve hiper ortamını bağlama.

$metin

$text operatörü, belirtilen alanın içeriğinde bir metin indeksi ile indekslenmiş bir metin arar:

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

Bu durumda, aşağıdaki kod parçacığı, içinde "Porsche" yazısı bulunan arabaları filtrelemek için tabloyu gözden geçirecektir:

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

$normal ifade

$regex operatörü, sorgulardaki eşleşme dizelerini modellemek için düzenli ifade yetenekleri sunar. MongoDB, Perl ile uyumlu düzenli ifadelerden yararlanır:

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

Aşağıdaki örnek, içinde "78900$" dizesi bulunan tüm arabaların filtrelenmesine yardımcı olacaktır:

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

$ifade

$expr operatörü, sorgu dilindeki toplama ifadelerinden yararlanmanıza olanak tanır:

 { $expr: { <expression> } }

Aynı belgedeki alanları bir $match aşamasında karşılaştıran sorgu ifadeleri oluşturmak için $expr de kullanabilirsiniz. If the $match stage happens to be the part of a $lookup stage, $expr can compare fields with the help of let variables.

$where

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

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> , ... ] } }

Alan değeri, geçerli belgeyle eşleşmesi için $bitsAllSet için bir BinData örneği veya sayısal olmalıdır.

Aşağıdaki örnekte, aşağıdaki belgelere sahip bir koleksiyondan yararlanıyoruz:

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

Aşağıda belirtilen sorgu, en az anlamlı bitin 0 konumunda olacağı, a alanının 1 ve 5 konumunda ayarlanmış bitlere sahip olup olmadığını test etmek için $bitsAllSet operatörünü kullanır:

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

Bu sorgu aşağıdaki belgelerle eşleşir:

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

$bitsAllClear

$bitsAllClear operatörü, sorgu tarafından sağlanan tüm bit konumlarının clear veya 0 olduğu belgelerle eşleşir:

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

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

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

$bitsAllClear kullanımını göstermek için burada $bitsAllSet için kullanılan örneği $bitsAllClear . Aşağıdaki sorgu, a alanının 1 ve 5 konumlarında bitlerin temiz olup olmadığını kontrol etmek için bu operatörü kullanır:

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

Bu sorgu aşağıdaki belgelerle eşleşir:

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

Meta Operatörler

MongoDB'de bir sorgunun davranışını veya çıktısını değiştirmenize izin veren çeşitli sorgu değiştiricileri vardır. Sürücü arabirimleri, bunları kullanımınız için saran imleç yöntemleri sağlayabilir.

$ipucu

MongoDB, v3.2'den bu yana $hint kullanımdan kaldırdı. Ancak, bu operatör Go, Java, Scala, Ruby, Swift, vb. gibi MongoDB sürücüleri için hala kullanılabilir olabilir. Sorgu iyileştiriciyi, sorguyu yerine getirmek için belirli bir dizini kullanmaya zorlayabilir, bu daha sonra belge tarafından veya tarafından belirtilebilir. dizin adı.

Dizin oluşturma stratejilerini test etmek ve performansı sorgulamak için $hint operatörünü de kullanabilirsiniz. Örneğin, aşağıdaki işlemi yapın:

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

Bu işlem, age alanındaki dizinden yararlanarak users adlı koleksiyondaki tüm belgeleri döndürür.

Aşağıdaki formlardan birini kullanarak da bir ipucundan bahsedebilirsiniz:

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

Sorgu şekli için bir dizin filtresi varsa, MongoDB $hint öğesini yok sayar.

$yorum

$comment operatörü, $query görünebileceği herhangi bir bağlamda bir sorguya yorum eklemenize izin verir. Yorumlar profil günlüğüne yayıldığından, yorum eklemek, profilinizi yorumlamayı ve izlemeyi kolaylaştırabilir.

$comment üç yoldan biriyle kullanabilirsiniz:

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

db.collection.update() gibi diğer bağlamlardaki sorgu ifadelerine yorum eklemek istiyorsanız, meta operatör yerine $comment sorgu operatöründen yararlanın.

maksimum $

find() sonuçlarını sınırlamak için belirli bir dizine özel üst sınırı belirtmek için bir $max değerinden bahsedebilirsiniz. Bu operatör, dizindeki belirli bir sıradaki tüm anahtarlar için üst sınırı belirleyecektir.

Mongosh size aşağıdaki max() sarmalayıcı yöntemini verir:

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

$max aşağıdaki iki formla da belirtebilirsiniz:

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

Örneğin, özel üst sınırı belirtmek istiyorsanız, { age: 1 } dizinini içeren koleksiyon adlı bir koleksiyon üzerinde aşağıdaki işlemleri unutmayın:

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

Bu işlem, sorguyu alan yaşının 100'den küçük olduğu belgelerle sınırlandıracak ve { age: 1 } dizinini minKey 100'e tarayacak bir sorgu planını zorlayacaktır.

$açıkla

Bu operatör size sorgu planı hakkında bilgi verecektir. Sorguyu döndürmek için kullanılan dizinleri ve işlemleri açıklayan bir belge döndürür. Bu, bir sorguyu optimize etmeye çalışırken yararlı olabilir.

$explain operatöründen aşağıdaki formlardan birinde bahsedebilirsiniz:

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

MongoDB Operatörleri için En İyi Uygulamalar

Bu bölümde, bu MongoDB operatörlerini kullanırken en iyi uygulamalardan bazılarına göz atacağız.

Gömme ve Referanslama

Gömme, veri modellemenin doğal bir uzantısıdır. Güncellemeleri ve sorguları azaltabilecek uygulama birleştirmelerinden kaçınmanıza olanak tanır.

1:1 ilişkisi olan verileri tek bir belgeye gömebilirsiniz. Bununla birlikte, "birçok" nesnenin üst belgeleriyle birlikte göründüğü çok:1 ilişkisine sahip veriler de iyi adaylar olabilir.

Bu tür verileri aynı belgede saklamak ihtiyatlı bir seçim gibi görünüyor. Ancak, katıştırma, bu tür veri konumuyla okuma işlemleri için daha iyi performans sağlar.

Gömülü veri modelleri, geliştiricilerin ilişkili verileri tek bir yazma işleminde güncellemelerine de yardımcı olabilir. Bu işe yarar çünkü tek belge yazma işlemleri işlemseldir.

Aşağıdaki senaryolar için referans kullanmayı düşünmelisiniz:

• Bir belge segmentini güncellediğinizde ve belgenin geri kalanı statikken uzamaya devam ettiğinde.
• Bir belgeye erişildiğinde ancak nadiren kullanılan veriler içerdiğinde. Gömme yalnızca bellek içi gereksinimleri artırır, bu nedenle referans vermek daha mantıklıdır.
• Belge boyutu MongoDB'nin 16MB belge sınırını aştığında. Bu, birçok:1 ilişkiyi modellerken olabilir (örneğin, çalışanlar:departman ).

Profil Oluşturma ve Sorgu Kalıplarını İnceleme

Çoğu geliştirici için performansı optimize etmenin ilk adımı, gerçek ve beklenen sorgu modellerini anlamaktır. Uygulamanızın sorgu modellerini yeterince iyi öğrendikten sonra, veri modelinizi oluşturabilir ve uygun dizinleri seçebilirsiniz.

MongoDB geliştiricileri, performansı artırmalarına izin veren çeşitli güçlü araçlara erişebilir. Ancak bu, sorgu profillerinin ve kalıplarının göz ardı edilebileceği anlamına gelmez.

Örneğin, performansı artırmanın kolay bir yolu, sorgu kalıplarınızı analiz etmek ve verileri nereye gömebileceğinizi anlamaktır. Başlıca sorgu kalıplarınızı belirledikten sonra MongoDB performansını artırmanın diğer yolları şunlardır:

• Sorguladığınız tüm alanlarda dizinleriniz olduğundan emin olun.
• Okuma yükünü azaltmak için sık yapılan alt sorguların sonuçlarını belgelerde saklamak.
• Yavaş sorgulara bakmak için günlüklerinize bir göz atın, ardından dizinlerinizi kontrol edin.

Veri İndeksleme ve Modellemeyi Gözden Geçirin

Veri modelinizi oluştururken, veriler arasındaki ilişkileri nasıl modelleyeceğinize karar vereceksiniz. Örneğin, bunun yerine farklı koleksiyonlardaki ayrı belgeler arasında bir referans oluşturmak yerine bir belgeyi ne zaman gömeceğinizi seçmek uygulamaya özel değerlendirmeye bir örnektir.

JSON belgelerinin önemli bir avantajı, geliştiricilerin verileri uygulamanın gereksinimlerine göre modellemesine izin vermeleridir. İç içe geçmiş alt belgeler ve diziler, basit metin belgelerinden yararlanarak veriler arasındaki karmaşık ilişkileri modellemenize yardımcı olur.

Aşağıdakileri modellemek için MongoDB'yi de kullanabilirsiniz:

• coğrafi veri
• Tabular, düz ve sütunlu yapılar
• Basit anahtar/değer çiftleri
• Zaman serisi verileri
• Bağlı grafik veri yapılarının ve benzerlerinin kenarları ve düğümleri

Parçalama ve Çoğaltmayı İzleme

Çoğaltma, yatay ölçeklendirme yoluyla veri kullanılabilirliğini artırdığı için performansı artırmak için çok önemli olabilir. Çoğaltma, yedeklilik yoluyla daha iyi performans ve daha fazla güvenlik sağlayabilir.

Performans izleme, sorunsuz çalışmayı sağlamak için ek kaynaklara ve zamana ihtiyaç duyan bir güçlük olabilir. Spesifik ihtiyaçlarınızı karşılayan, piyasada bulunan performans izleme araçlarından yararlanabilirsiniz.

Örneğin, Kinsta APM, WordPress sitenizin MySQL veritabanı sorguları, PHP işlemleri, harici HTTP çağrıları ve çok daha fazlası hakkında zaman damgalı bilgileri alabilir. Hata ayıklamak için bu ücretsiz aracı da kullanabilirsiniz:

• Uzun API çağrıları
• Uzun harici URL istekleri
• Birkaç isim vermek için yavaş veritabanı sorguları.

MongoDB'de çoğaltma, geliştiricilerin birincil bir düğümden veya sunucudan birden çok ikincil öğeye veri kopyalamasına olanak tanıyan çoğaltma kümeleri aracılığıyla gerçekleştirilebilir. Bu, çoğaltmanızın birincil yerine ikincil sorgularda bazı sorguları çalıştırmasını sağlayarak çekişmeyi önler ve daha iyi yük dengelemeye yol açar.

MongoDB'deki parçalanmış kümeler, performansı potansiyel olarak iyileştirmenin başka bir yoludur. Çoğaltmaya benzer şekilde, parçalama, büyük veri kümelerini birden çok sunucu arasında dağıtmak için kullanılabilir.

Geliştiriciler, bir parça anahtarından yararlanarak birden çok sunucu arasında parçaları veya veri parçalarını kopyalayabilir. Bu sunucular tüm verileri kullanmak için birlikte çalışabilir.

Parçalama, yazma/okuma için yatay ölçekleme, daha yüksek kullanılabilirlik ve artırılmış depolama kapasitesi gibi avantajlardan adil bir paya sahiptir.

Bellek Kullanımını Belirleyin

MongoDB en iyi performansı, bir uygulamanın çalışma grubu (yani, sık erişilen veriler ve dizinler) belleğe sorunsuz bir şekilde sığdığında gösterir. Performans için diğer faktörler çok önemli olsa da, örnek boyutlandırma için en önemli olan RAM boyutudur.

Bir uygulamanın çalışma seti RAM'e sığdığında, diskten okuma etkinliğinin düşük olması gerekir. Ancak çalışma setiniz, instance sunucusunun veya boyutunun RAM'ini aşarsa, okuma etkinliği hızlanmaya başlayacaktır.

Bunun olduğunu görürseniz, daha fazla belleğe sahip daha büyük bir örneğe geçerek sorunu çözebilirsiniz.

Çok Değerli Alanları Sona Yerleştirin

Birkaç alanı indeksliyorsanız ve sorgulamak istediğiniz alanlardan biri bu “çok değerli” operatörlerden birini kullanıyorsa, onları indeksin sonuna koymalısınız. Dizini, tam değerler için sorgulanan alanların önce gelmesi ve “çok değerli” operatörlerin dizinde en son görünmesi için sıralamanız gerekir.

Bunun bir istisnası, alanlara göre sıralama olacaktır. Bunları, gereken bellek içi sıralama miktarını azaltmak için "çoklu değer" ve tam alanlar arasına yerleştirin.

Özet

MongoDB için oyunun adı hızdır. Sorguları hızlı bir şekilde döndürmek için MongoDB, matematiksel veya mantıksal görevleri yürütmek için operatörlerden yararlanır. Basitçe söylemek gerekirse, MongoDB operatörlerini anlamak, MongoDB'de uzmanlaşmanın anahtarıdır.

Bu makalede, karşılaştırma operatörleri, mantıksal operatörler, meta operatörler ve projeksiyon operatörleri gibi verilerinizde kullanabileceğiniz bazı önemli MongoDB operatörleri vurgulanmıştır. Ayrıca MongoDB operatörlerini nasıl kullanabileceğinizi ve bunlardan en iyi şekilde yararlanmanızı sağlayacak en iyi uygulamaları anlamanıza yardımcı olur.

Tüm operatörler arasında en sık hangisini/operatörleri kullanıyorsunuz ve neden? Aşağıdaki yorumları paylaşın - düşüncelerinizi duymak isteriz!