9 tipuri de operatori Mongodb pe care trebuie să-i cunoașteți
Publicat: 2022-09-09În orice afacere, datele sunt cel mai mare atu al tău. Analizând datele, puteți lua decizii privind tendințele clienților și predicția comportamentului. Acest lucru sporește profitabilitatea afacerii și luarea deciziilor eficiente.
Fără software de bază de date, o sarcină simplă precum găsirea mediei tuturor valorilor într-un sistem plin de înregistrări ar fi plictisitoare. Din fericire, bazele de date au făcut analiza datelor mai ușoară și mai rapidă cu funcții și operatori.
Acest articol va arunca puțină lumină asupra operatorilor utilizați în software-ul bazei de date MongoDB.
Ce sunt operatorii MongoDB?
MongoDB este un software de bază de date NoSQL care gestionează informații orientate spre document.
Una dintre caracteristicile cheie ale MongoDB este viteza sa. Pentru a returna interogările mai rapid, MongoDB poate folosi operatori pentru a efectua anumite funcții.
Operatorii sunt simboluri speciale care ajută compilatorii să realizeze sarcini matematice sau logice. MongoDB oferă mai multe tipuri de operatori pentru a interacționa cu baza de date.
Tipuri de operatori MongoDB
Există nouă tipuri de operatori, fiecare numit pentru funcția sa. De exemplu, operatorii logici folosesc operații logice. Pentru a le executa, trebuie să utilizați un anumit cuvânt cheie și să urmați sintaxa. Cu toate acestea, sunt destul de ușor de urmărit!
Până la sfârșitul articolului, veți putea afla elementele de bază ale fiecărui operator și funcțiile acestuia.
Operatori logici
Operatorii logici sunt adesea folosiți pentru a filtra datele în funcție de condițiile date. Ele permit, de asemenea, evaluarea multor condiții, pe care le vom discuta mai detaliat.
Mai jos sunt câțiva operatori logici pe care îi puteți folosi:
$i
O condiție „și” efectuează o operație logică „și” pe o matrice de două sau mai multe expresii. Selectează documentele în care sunt îndeplinite toate condițiile expresiilor.
Aceasta este sintaxa standard pentru expresia $and :
{ $and: [ { <expression1> }, { <expression2> }, ... , { <expressionN> } ] } De exemplu, dacă dorim să selectăm documente în care prețul este de 10 USD și cantitatea este mai mică de 15, putem introduce următoarea interogare: db.inventory.find( { $and: [ { quantity: { $lt: 15 } }, { price: 10 } ] } )$sau
O condiție „sau” efectuează o operație logică „sau” pe o matrice de două sau mai multe expresii. Selectează documentele în care cel puțin una dintre expresii este adevărată.
Aceasta este sintaxa standard pentru expresia $or :
{ $or: [ { <expression1> }, { <expression2> }, ... , { <expressionN> } ] }.De exemplu, dacă dorim să selectăm documente în care prețul este de 10 USD sau cantitatea este mai mică de 15, putem introduce următoarea interogare:
db.inventory.find( { $or: [ { quantity: { $lt: 15 } }, { price: 10 } ] } )Nu trebuie să limităm expresia la două criterii - putem adăuga mai multe. De exemplu, interogarea de mai jos selectează acele documente în care prețul este egal cu 10 USD, cantitatea este sub 15 sau eticheta este staționară:
db.inventory.find( { $or: [ { quantity: { $lt: 15 } }, { price: 10 }, { tag: stationary }] } ) Când rulează aceste clauze, MongoDB efectuează fie o scanare de colecție, fie o scanare de index. Dacă toți indecșii acceptă clauzele, atunci MongoDB folosește indecși pentru a verifica o expresie $or . În caz contrar, folosește în schimb o scanare a colecției.
Dar dacă doriți să testați criteriile în același câmp, poate doriți să utilizați operatorul $in mai degrabă decât operatorul $or . De exemplu, dacă doriți o colecție de documente în care cantitatea este fie 10, fie 20, poate fi necesar să rulați interogarea $in mai jos:
db.inventory.find ( { quantity: { $in: [20, 50] } } ) Vom acoperi mai multe despre operatorul $in mai târziu.
$nor
Acest operator efectuează o operație logică „nor” pe o matrice folosind una sau mai multe expresii. Apoi, selectează documentele care nu reușesc expresiile de interogare. În termeni mai simpli, face opusul condiției $or .
Aceasta este sintaxa generală:
{ $nor: [ { <expression1> }, { <expression2> }, ... { <expressionN> } ] }Să luăm în considerare următoarea interogare:
db.inventory.find( { $nor: [ { price: 3.99 }, { sale: true } ] } )Această interogare selectează documentele care conțin:
- o valoare a câmpului de preț care nu este egală cu 3,99 USD și o valoare de vânzare diferită de adevărată; sau
- o valoare a câmpului de preț care nu este egală cu 3,99 USD și un câmp de vânzare gol sau absent; sau
- niciun câmp de preț și un câmp de vânzare care nu este egal cu adevărat; sau
- nici câmpul de preț, nici câmpul de vânzare nu este populat sau prezent.
$nu
Acest operator efectuează o operație logică „nu” pe o matrice pentru expresia specificată. Apoi selectează documentele care nu se potrivesc cu expresiile de interogare. Aceasta include documentele care nu conțin câmpul.
Aceasta este sintaxa generală:
{ field: { $not: { <operator-expression> } } }De exemplu, luați următoarea interogare:
db.inventory.find( { price: { $not: { $lt: 3.99 } } } )Această interogare ar selecta acele documente care conțin:
- un câmp de preț a cărui valoare este mai mare sau egală cu 3,99 USD; și
- un câmp de preț este nepopulat sau nu există.
Operatori de comparație
Operatorii de comparare pot fi utilizați pentru a compara valorile dintr-unul sau mai multe documente.
Mai jos este un exemplu de cod al unei simple colectări de inventar pentru un magazin de supermarket:
{ _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" ] }Vom folosi acest exemplu în timp ce vom detalia fiecare operator de comparație în continuare.
Egal cu ($eq)
Acest operator se potrivește cu valori care sunt egale cu valoarea dată:
{ <field>: { $eq: <value> } }De exemplu, dacă dorim să extragem un anumit document din colecția de inventar având valoarea exactă a cantității „20”, am introduce următoarea comandă:
db.inventory.find( { qty: { $eq: 20 } } )Interogarea ar returna următoarele:
{ _id: 2, item: { name: "banana", code: "123" }, qty: 20, tags: [ "B" ] }, { _id: 5, item: { name: "pears", code: "000" }, qty: 20, tags: [ [ "A", "B" ], "C" ] }Mai mare decât ($gt)
Acest operator se potrivește dacă valorile sunt mai mari decât valoarea dată:
{ field: { $gt: value } }În acest exemplu, recuperăm documentele în care cantitatea este mai mare de 15:
db.inventory.find({"qty": { $gt: 15}})Interogarea ar returna următoarele:
{ _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" ] }Mai puțin de ($lt)
Acest operator se potrivește dacă valorile sunt mai mici decât valoarea furnizată:
{ field: { $lt: value } }Să găsim documentele cu o cantitate mai mică de 25:
db.inventory.find({"qty": { $lt: 25}})Interogarea ar returna următoarele:
{ _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" ] }Mai mare sau egal cu ($gte)
Acest operator se potrivește atunci când valorile sunt mai mari sau egale cu valoarea dată:
{ field: { $gte: value } }În acest exemplu, recuperăm documentele în care cantitatea este mai mare sau egală cu 25:
db.inventory.find({"qty": { $gte: 25}})Această interogare ar returna următoarele:
{ _id: 3, item: { name: "spinach", code: "456" }, qty: 25, tags: [ "A", "B" ] } { _id: 4, item: { name: "lentils", code: "456" }, qty: 30, tags: [ "B", "A" ] }Mai mic sau egal cu ($lte)
Acest operator se potrivește numai dacă valorile sunt mai mici sau egale cu valoarea dată:
{ field: { $lte: value } }Să găsim documentele cu o cantitate mai mică sau egală cu 25.
db.inventory.find({"qty": { $lte: 25}})Ne putem aștepta ca această interogare să returneze următoarele:
{ _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" ] }În ($in)
Acest operator returnează documentele care se potrivesc cu valorile specificate:
{ field: { $in: [<value1>, <value2>, ... <valueN> ] } }Valoarea unui câmp este egală cu orice valoare din matricea specificată. Pentru a prelua documentele cu valorile „30” și „15” din colecția de inventar, de exemplu, ați proceda astfel:
db.collection.find({ "qty": { $in: [30, 15]}})Ieșirea ar fi:
{ _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" ] } Nu în ($nin)
Acest operator returnează documentele care nu se potrivesc cu valorile date. Iată sintaxa de bază a operatorului $nin :
{ field: { $nin: [ <value1>, <value2> ... <valueN> ] $nin selectează documentele în care:
- valoarea câmpului nu este în matricea specificată; sau
- domeniul nu exista.
Dacă câmpul conține matrice, va alege matrice în care nu este prezent niciun element specificat în secțiunea de valori. De exemplu, dorim să selectăm acele documente în care cantitatea nu este egală nici cu 20, nici cu 15.
În plus, se potrivește și documentele care nu au un câmp de cantitate:
db.collection.find({ "qty": { $nin: [ 20, 15 ]}}, {_id: 0})Ieșirea ar fi:
{ _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" ] }Nu este egal ($ne)
Operatorul $ne returnează documentele în care valoarea specificată nu este egală:
{ $ne: value } }De exemplu, să presupunem că vrem să selectăm toate documentele în care cantitatea nu este egală cu 20:
db.inventory.find( { qty: { $ne: 20 } } )Ieșirea ar fi:
{ _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" ] }Din rezultatul de mai sus, putem vedea că interogarea va selecta documente care nu au un câmp de cantitate.
Operatori de elemente
Operatorii de interogare a elementelor pot identifica documente folosind câmpurile documentului. Operatorii de elemente constau din $exist și $type .
$există
Acest operator se potrivește documentelor care au un câmp specificat. Acest operator are o valoare booleană care poate fi true sau false .
Dacă este specificat ca fiind true , se potrivește documentelor care conțin acel câmp, inclusiv documentelor în care valoarea câmpului este nulă. Dacă <boolean> este false , atunci interogarea returnează doar documentele care nu conțin câmpul.
Iată sintaxa standard:
{ field: { $exists: <boolean> } }Să luăm un exemplu în care avem o colecție de date pentru o matrice numită „bagofmarbles”, în care fiecare pungă conține bile de diferite culori:
{ 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 } Să presupunem că vrem o interogare care să returneze doar acele pungi în care există bilele roșii. Aceasta înseamnă că ar trebui să introducem valoarea booleană ca fiind true . Hai să aruncăm o privire:
db.bagofmarbles.find( { red: { $exists: true } } ) Rezultatele ar consta în acele documente care conțin câmpul „roșu”, chiar dacă valoarea a fost null . Totuși, nu ar consta din documentele în care câmpul „roșu” nici măcar nu a existat:
{ 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 }Dacă am vrut doar acele pungi în care bilele roșii nici măcar nu există ca câmp, putem introduce interogarea de mai jos:
db.bagofmarbles.find( { red: { $exists: false} }Rezultatele ar consta în acele documente care nu conțin câmpul „roșu”:
{ green: 2, blue: 4 } { green: 2 } { blue: 6 }$type
Acest operator potrivește documentele în funcție de tipul de câmp specificat. Acest lucru este util atunci când aveți date foarte nestructurate sau când tipurile de date nu sunt previzibile. Aceste tipuri de câmpuri sunt tipuri BSON specificate și pot fi definite fie prin numărul tipului, fie prin alias.
Aceasta este sintaxa generală pentru $type :
{ field: { $type: <BSON type> } }Să presupunem că avem o agendă de adrese care conține documentele de mai jos:
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" ] } ] }La respectarea documentelor de mai sus, codul poștal are diferite tipuri de date. Aceasta include valori lungi, duble, întregi și șir.
Dacă vrem doar acele documente care au un tip de date specificat ca cod poștal - să luăm șirul pentru această instanță - ar trebui să introducem următoarea interogare în compilator:
db.addressBook.find({ "zipCode": { $type: "string" } })Aceasta ar returna următoarele documente:
[ { "_id": 1, "address": "2100 Jupiter Spot", "zipCode": "9036325" }, { "_id": 5, "address": "1044 Venus Lane", "zipCode": [ "99883637232", "73488976234" ] } ] În plus, există un tip „număr”, care include toate valorile lungi, întregi sau duble ca o matrice care conține un element din tipurile specificate:
db.addressBook.find( { "zipCode" : { $type : "number" } } )Ieșire:
[ { "_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) } ] Dacă documentele au un tip de câmp matrice, operatorul $type returnează documentele în care cel puțin un element de matrice se potrivește cu tipul transmis operatorului.
Operatori de matrice
MongoDB constă, de asemenea, din operatori de matrice, pentru a interoga documentele care conțin matrice.
Există trei operatori primari: $all , $elemMatch și $size . Vom discuta pe fiecare în detaliu mai jos.
$toate
Operatorul $all alege documentele în care valoarea unui câmp este o matrice care conține elementele specificate:
{ : { $all: [ <value1> , <value2> ... ] } }De exemplu, să presupunem că avem o colecție de documente pentru un magazin de îmbrăcăminte, cu următoarele în inventar.
{ _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" } ] } Am dori să recuperăm orice documente (în acest caz, hainele) din inventar care sunt legate cu etichetele „la modă” și „y2k”. Interogarea de mai jos folosește operatorul $all unde valoarea câmpului etichete este o matrice ale cărei elemente includ „y2k” și „trendy”:
db.inventory.find( { tags: { $all: [ "y2k", "trendy" ] } } )Interogarea de mai sus returnează următoarele:
{ _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" } ] } Din exemplul de mai sus, găsim, de asemenea, că operatorul $all îndeplinește pur și simplu aceeași funcție ca și operația $and .
Alternativ, am putea folosi interogarea de mai jos, care ar oferi o ieșire similară celei de mai sus:
db.collection.find({ $and: [ { tags: "y2k" }, { tags: "trendy" } ] }) $elemMatch
Operatorul $elemMatch potrivește documentele care conțin un câmp matrice cu cel puțin un element care corespunde tuturor criteriilor de interogare specificate:
{ : { $elemMatch: { <query1>, <query2>, ... } } } Deși putem folosi operatori de comparare precum $lte și $gte , dacă specificăm doar o singură condiție de interogare în interiorul $elemMatch și nu folosim operatorii $not sau $ne , utilizarea $elemMatch poate fi omisă, deoarece ar fi, în esență, performanțe. aceeași funcție.
Mai sunt câteva lucruri de reținut când utilizați acest operator, în principal:
- Nu puteți specifica o expresie
$whereîntr-o operație$elemMatch. - Nu puteți specifica o expresie de interogare
$textîntr-o operație$elemMatch.
De exemplu, avem următoarele documente în colecția de rezultate ale studenților:
{ _id: 1, results: [ 92, 89, 98 ] } { _id: 2, results: [ 85, 99, 99 ] }Următoarea interogare se potrivește numai acelor documente în care matricea de rezultate conține cel puțin un element care este mai mare sau egal cu 90 și mai mic de 95:
db.studentresults.find( { results: { $elemMatch: { $gte: 90, $lt: 95 } } })Interogarea noastră returnează următorul document, deoarece elementul 92 este mai mare sau egal cu 90 și este mai mic decât 95:
{ "_id" : 1, "results" :[ 92, 89, 98 ] }$size
Operatorul $size returnează acele documente în care dimensiunea matricei se potrivește cu numărul de elemente specificat în argument:
{ field: { $size: value } }Iată un exemplu:
db.collection.find( { field: { $size: 2 } }); Aceasta ar returna toate documentele din colecția specificată, unde câmpul este o matrice cu 2 elemente: { field: [ orange, apple] } și { field: [ blue, red] } , dar nu { field: blue} sau { field: [ raspberry, lemon, grapefruit ] } .
Cu toate acestea, deși putem introduce valoarea specifică ca dimensiune, nu putem specifica intervale de valori ca dimensiune.
Operatori geospațiali
MongoDB vă permite să stocați date geospațiale sub formă de tipuri GeoJSON. GeoJSON este un format standard deschis bazat pe notația obiect JavaScript care poate reprezenta caracteristici geografice și poate suporta atribute non-spațiale. Există două tipuri de operatori geospațiali despre care vom vorbi în acest articol: specificatorii de geometrie și selectorii de interogări.
$geometrie
Acest operator menționează geometria GeoJSON pentru a fi utilizată cu următorii operatori de interogare geospațială: $geoIntersects , $geoWithin , $nearSphere și $near . $geometry folosește EPSG:4326 ca sistem de referință de coordonate implicit (CRS).
Pentru a menționa obiectele GeoJSON cu CRS implicit, puteți folosi următorul fragment pentru $geometry :
$geometry: { type: "<GeoJSON object type>", coordinates: [ <coordinates> ] } Pentru a menționa un poligon GeoJSON cu un singur inel, cu un CRS MongoDB adaptat, puteți folosi următorul fragment (puteți folosi acest lucru numai pentru $geoWithin și $geoIntersects ):
$geometry: { type: "Polygon", coordinates: [ <coordinates> ], crs: { type: "name", properties: { name: "urn:x-mongodb:crs:strictwinding:EPSG:4326" } } }$poligon
Operatorul $polygon poate fi folosit pentru a specifica un poligon pentru o interogare geospațială $geoWithin pe perechile de coordonate vechi. Această interogare va returna apoi perechi care se încadrează în limitele poligonului. Cu toate acestea, $polygon nu va solicita niciun obiect GeoJSON. Pentru a defini un poligon, trebuie să specificați o matrice de puncte de coordonate după cum urmează:
{ : { $geoWithin: { $polygon: [ [ <x1> , <y1> ], [ <x2> , <y2> ], [ <x3> , <y3> ], ... ] } } }Aici, ultimul punct este implicit legat de primul. Puteți menționa câte puncte sau părți doriți.
De exemplu, următoarea interogare va returna toate documentele care au coordonate care există în poligonul definit de [0,0], [1,5] și [3,3]:
db.places.find( { loc: { $geoWithin: { $polygon: [ [ 0 , 0 ], [ 1 , 5 ], [ 3 , 3 ] ] } } } )$geoWithin
Acest operator poate fi folosit pentru a alege documente cu date geospațiale care sunt complet conținute într-o formă specifică. Forma specificată poate fi fie un multipoligon GeoJSON, un poligon GeoJSON (fie cu mai multe inele, fie cu un singur inel) sau o formă care poate fi definită prin perechi de coordonate vechi.
Operatorul $geoWithin va folosi operatorul $geometry pentru a menționa obiectul GeoJSON.
Pentru a menționa multipoligoane sau poligoane GeoJSON prin sistemul de referință de coordonate (CRS) implicit, puteți utiliza sintaxa menționată mai jos:
{ : { $geoWithin: { $geometry: { type: <"Polygon" or "MultiPolygon"> , coordinates: [ <coordinates> ] } } } } Pentru interogările $geoWithin care menționează geometriile GeoJSON cu zone mai mari decât o singură emisferă, utilizarea CRS implicită ar duce la interogări pentru geometriile complementare.
Pentru a menționa un poligon GeoJSON cu un singur inel cu un CRS MongoDB personalizat, puteți folosi prototipul menționat mai jos în expresia $geometry :
{ : { $geoWithin: { $geometry: { type: "Polygon" , coordinates: [ <coordinates> ], crs: { type: "name", properties: { name: "urn:x-mongodb:crs:strictwinding:EPSG:4326" } } } } } }Următorul exemplu alege toate datele loc care există complet într-un poligon GeoJSON, aria poligonului fiind mai mică decât aria unei singure emisfere:
db.places.find( { loc: { $geoWithin: { $geometry: { type : "Polygon" , coordinates: [ [ [ 0, 0 ], [ 3, 6 ], [ 6, 1 ], [ 0, 0 ] ] ] } } } } )$box
Puteți utiliza $box pentru a specifica un dreptunghi pentru o interogare geospațială $geoWithin pentru a furniza documente care se află în limitele dreptunghiului, în funcție de datele lor de locație bazate pe puncte. Când utilizați $geoWithin cu $box , veți obține documente bazate pe coordonatele de interogare. În acest scenariu, $geoWithin nu va solicita nicio formă GeoJSON.
Pentru a utiliza operatorul $box , trebuie să menționați colțurile din dreapta sus și din stânga jos ale dreptunghiului într-un obiect matrice:
{ <location field> : { $geoWithin: { $box: [ [ <bottom left coordinates> ], [ <upper right coordinates> ] ] } } }Interogarea menționată mai sus va calcula distanța utilizând geometria plană (plată). Următoarea interogare va returna toate documentele care se află în casetă având puncte la: [0,0], [0,30], [30,0], [30,30]:
db.places.find ( { loc: { $geoWithin: { $box: [ [ 0,0 ], [ 30,30 ] ] } } } )$nearSphere
Puteți folosi $nearSphere pentru a menționa un punct pentru care o interogare geospațială returnează documentele de la cel mai apropiat la cel mai îndepărtat.
MongoDB folosește geometria sferică pentru a calcula distanțele pentru $nearSphere . Va avea nevoie de un index geospațial după cum urmează:
- Index 2d pentru datele de locație descrise ca perechi de coordonate vechi. Pentru a utiliza un index 2d pe punctele GeoJSON, trebuie să generați indexul în câmpul de coordonate al obiectului GeoJSON.
- Index 2dsphere pentru datele de locație descrise ca puncte GeoJSON.
Pentru a menționa un punct GeoJSON, puteți folosi următoarea sintaxă:
{ $nearSphere: { $geometry: { type : "Point", coordinates : [ <longitude>, <latitude> ] }, $minDistance: <distance in meters>, $maxDistance: <distance in meters> } } Aici, $minDistance și $maxDistance sunt opționale. $minDistance poate limita rezultatele la acele documente care se află cel puțin la distanța specificată de centru. Puteți folosi $maxDistance pentru oricare index.
Acum, luați în considerare o colecție de „locuri” care constă din documente cu un câmp de locație care are un index 2dsphere. Următorul exemplu ar returna punctele a căror locație este la cel puțin 2.000 de metri și la cel mult 6.000 de metri de punctul pe care îl alegeți, ordonate de la cel mai apropiat la cel mai îndepărtat:
db.places.find( { location: { $nearSphere: { $geometry: { type : "Point", coordinates : [ -43.9532, 50.32 ] }, $minDistance: 2000, $maxDistance: 6000 } } } )$geoIntersecte
Operatorul $geoIntersects vă permite să selectați documente ale căror date geospațiale se intersectează cu un anumit obiect GeoJSON (adică unde convergența obiectului specificat și a datelor nu este goală). Utilizează operatorul $geometry pentru a specifica obiectul GeoJSON.
Pentru a menționa multipoligoane sau poligoane GeoJSON prin sistemul de referință de coordonate (CRS) implicit, puteți utiliza următoarea sintaxă:
{ <location field>: { $geoIntersects: { $geometry: { type: "<GeoJSON object type>" , coordinates: [ <coordinates> ] } } } } Următoarea instanță va folosi $geoIntersects pentru a alege toate datele loc care se intersectează cu poligonul descris de matricea de coordonate:
db.places.find( { loc: { $geoIntersects: { $geometry: { type: "Polygon" , coordinates: [ [ [ 0, 0 ], [ 2, 6 ], [ 4, 1 ], [ 0, 0 ] ] ] } } } } )$centru
Operatorul $center menționează un cerc pentru o interogare $geoWithin care returnează perechi de coordonate vechi care se află în limitele cercului.
$center nu returnează obiecte GeoJSON. Pentru a utiliza operatorul $center , trebuie să specificați o matrice care conține:
- Raza cercului, măsurată în unitățile utilizate de sistemul de coordonate.
- Coordonatele rețelei ale punctului central al cercului.
{ <location field> : { $geoWithin: { $center: [ [ <x> , <y> ] , <radius> ] } } }Exemplul menționat mai jos va returna toate documentele care au coordonate care pot fi găsite în cadrul cercului centrat pe [2,3] și cu o rază de 40:
db.places.find( { loc: { $geoWithin: { $center: [ [2, 3], 40 ] } } } )Operatori de proiecție
Puteți folosi operatori de proiecție pentru a menționa câmpurile returnate de o operație. Operatorii de proiecție MongoDB permit ca funcția find() să fie utilizată cu argumente de filtrare a datelor. Acest lucru îi ajută pe utilizatori să extragă doar câmpurile de date obligatorii dintr-un document. Deci, vă permite să proiectați date transparente și concise fără a afecta performanța generală a bazei de date.
$elemMatch (proiecție)
Operatorul $elemMatch este responsabil pentru limitarea conținutului unui câmp din rezultatele interogării pentru a conține doar primul element care se potrivește cu condiția $elemMatch .
Iată câteva lucruri de care trebuie să ții cont înainte de a folosi $elemMatch :
- Din MongoDB 4.4, indiferent de ordinea câmpurilor din document, proiecția
$elemMatcha unui câmp existent returnează câmpul după includerea altor câmpuri existente. - Atât operatorii
$elemMatch, cât și$descriu primul element de potrivire dintr-o matrice bazată pe o condiție specificată. Operatorul$ar proiecta primul element de matrice care se potrivește din fiecare document dintr-o colecție pe baza unei anumite condiții din instrucțiunea de interogare, în timp ce operatorul de proiecție$elemMatchia un argument de condiție explicit. Acest lucru vă permite să proiectați pe baza unei condiții care nu este prezentă în interogare sau dacă trebuie să proiectați pe baza diferitelor câmpuri din documentele încorporate ale matricei.
De asemenea, ar trebui să fiți conștienți de următoarele restricții înainte de a utiliza operatorul $elemMatch pentru datele dvs.:
- Nu puteți menționa o expresie de interogare
$textîntr-un operator$elemMatch. -
db.collection.find()pe vederi nu acceptă operatorul de proiecție$elemMatch.
Următorul exemplu pe operatorul de proiecție $elemMatch presupune o colecție schools cu următoarele documente:
{ _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 }, ] } În acest caz, operațiunea find() interogează pentru toate documentele în care valoarea câmpului de cod poștal este 63110. Proiecția $elemMatch ar returna doar primul element care se potrivește din matricea students în care câmpul school are o valoare de 103:
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 (proiecție)
Operatorul de proiecție $slice poate fi folosit pentru a specifica numărul de elemente dintr-o matrice de returnat în rezultatul interogării:
db.collection.find( <query> , { <arrayField> : { $slice: <number> } } );De asemenea, poate fi exprimat astfel:
db.collection.find( <query> , { <arrayField> : { $slice: [ <number> , <number> ] } } );Pentru a demonstra același lucru, puteți crea un exemplu de colecție de tweet-uri cu următoarele documente:
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" } ] } ]) Următoarea operațiune ar folosi operatorul de proiecție $slice pe matricea tweets pentru a returna matricea cu primele două elemente. Dacă o matrice conține mai puțin de două elemente, toate elementele din matrice sunt returnate:
db.posts.find( {}, { comments: { $slice: 2 } } )Această operațiune ar returna următoarele documente:
{ "_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" } ] }$ (proiecție)
Operatorul pozițional $ limitează conținutul unui tablou pentru a returna primul element care se potrivește cu condiția de interogare a acelei matrice. Puteți utiliza $ în documentul de proiecție al metodei find() sau al metodei findOne() atunci când aveți nevoie doar de un anumit element de matrice în documentele alese.
Iată cum arată sintaxa operatorului $ :
db.collection.find( { <array>: <condition> ... }, { "<array>.$": 1 } ) db.collection.find( { <array.field>: <condition> ...}, { "<array>.$": 1 } ) În acest exemplu, colecția students este formată din următoarele documente:
{ "_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 ] } În următoarea interogare, proiecția { "grades.$": 1 } returnează numai primul element mai mare sau egal cu 89 pentru câmpul grades :
db.students.find( { semester: 2, grades: { $gte: 89 } }, { "grades.$": 1 } )Această operațiune returnează următoarele documente:
{"_id": 3, "grades": [95] }Operatori de evaluare
Puteți utiliza operatorii de evaluare MongoDB pentru a evalua structura generală a datelor sau câmpul individual din interiorul unui document.
Să ne uităm la câțiva operatori obișnuiți de evaluare MongoDB.
$mod
Puteți utiliza acest operator pentru a potrivi documentele în care valoarea unui câmp specificat este egală cu restul după ce a fost împărțită la o valoare specificată:
{ field: { $mod: [ divisor, remainder ] } }Să presupunem că aveți un tabel cu mașini aparținând diferitelor mărci pe care le dețineți în showroom-ul dvs. Următoarea interogare vă va oferi toate mărcile de mașini ale căror numere de stoc sunt în multipli de 250.
db.cars.find ( { qty: { $mod: [ 250,0 ] } } )$jsonSchema
$jsonSchema vă permite să potriviți documentele care se potrivesc cu schema JSON specificată. Implementarea de către MongoDB a schemei JSON include adăugarea cuvântului cheie bsonType , care vă permite să utilizați toate tipurile BSON în cadrul operatorului $jsonSchema .
bsonType poate accepta aceleași aliasuri de șir pe care le-ați folosi pentru operatorul de type . Iată cum ar arăta sintaxa lui $jsonSchema :
{ $jsonSchema: <JSON Schema object> }Aici, obiectul de schemă JSON este formatat pe baza schiței 4 a standardului de schemă JSON:
{ <keyword1>: <value1>, ... } Iată un exemplu pentru a demonstra cum funcționează $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" } } } } } } De asemenea, puteți utiliza $jsonSchema într-un validator de documente pentru a aplica schema specificată la operațiunile de actualizare și inserare:
db.createCollection(<collection> , { validator: { $jsonSchema: <schema> } } ) db.runCommand( { collMod: <collection>, validator:{ $jsonSchema: <schema> } } ) Rețineți că există câteva lucruri care nu sunt acceptate de operatorul $jsonSchema :
- Tipul întreg. Trebuie să utilizați tipul BSON long sau int cu cuvântul cheie bsonType.
- Cuvinte cheie necunoscute.
- Legarea proprietăților și hypermedia a schemei JSON, împreună cu utilizarea referințelor JSON și a indicatorilor JSON.
$text
Operatorul $text va căuta un text în conținutul câmpului specificat, indexat cu un index de text:
{ $text: { $search: <string>, $language: <string>, $caseSensitive: <boolean>, $diacriticSensitive: <boolean> } }În acest caz, următorul fragment de cod va trece prin tabel pentru a filtra toate mașinile care au textul „Porsche” în ele:
db.cars.find( { $text: { $search: "Porsche" } } )$regex
Operatorul $regex oferă abilități de expresie regulată pentru a modela șirurile de potrivire în interogări. MongoDB folosește expresii regulate care sunt compatibile cu Perl:
{<field> : /pattern/ <options>}Următorul exemplu ar ajuta la filtrarea tuturor mașinilor care au șirul „$78900” prezent în ele:
db.cars.find( { price: { $regex: /$78900/ } } )$expr
Operatorul $expr vă permite să utilizați expresii de agregare în limbajul de interogare:
{ $expr: { <expression> } } You can also use $expr to build query expressions that compare fields from the same document in a $match stage. 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
$wherequery operator to top-level documents. The$wherequery operator won't function in a nested document, like in a$elemMatchquery. - Generally, you should use
$whereonly 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$whereindependently 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> , ... ] } } Valoarea câmpului ar trebui să fie fie o instanță BinData, fie numerică pentru $bitsAllSet pentru a se potrivi cu documentul curent.
În următorul caz, folosim o colecție cu următoarele documente:
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" }) Interogarea menționată mai jos va folosi operatorul $bitsAllSet pentru a testa dacă câmpul a are biți setați la poziția 1 și la poziția 5, unde bitul cel mai puțin semnificativ ar fi în poziția 0:
db.collection.find( { a: { $bitsAllSet: [ 1, 5 ] } }Această interogare ar corespunde următoarelor documente:
{ "_id" : 1, "a" : 54, "binaryValueofA" : "00110110" } { "_id" : 4, "a" : BinData(0,"Zg=="), "binaryValueofA" : "01100110" }$bitsAllClear
Operatorul $bitsAllClear va potrivi documentele în care toate pozițiile biților furnizate de interogare sunt clare sau 0 :
{ <field> : { $bitsAllClear: <numeric bitmask> } } { <field> : { $bitsAllClear: < BinData bitmask> } } { <field> : { $bitsAllClear: [ <position1> , <position2> , ... ] } } Vom folosi exemplul folosit pentru $bitsAllSet aici pentru a demonstra utilizarea $bitsAllClear . Următoarea interogare ar folosi acest operator pentru a verifica dacă câmpul a are biții clari la pozițiile 1 și 5:
db.collection.find( { a: { $bitsAllClear: [ 1, 5 ] } } )Această interogare ar corespunde următoarelor documente:
{ "_id" : 2, "a" : 20, "binaryValueofA" : "00010100" } { "_id" : 3, "a" : 20, "binaryValueofA" : "00010100" }Meta operatori
Există diferiți modificatori de interogare care vă permit să modificați comportamentul sau rezultatul unei interogări în MongoDB. Interfețele driverului ar putea oferi metode de cursor care să le încapsuleze pentru utilizarea dvs.
$hint
MongoDB a depreciat $hint începând cu v3.2. Dar, acest operator ar putea fi în continuare disponibil pentru driverele MongoDB precum Go, Java, Scala, Ruby, Swift etc. Poate forța optimizatorul de interogări să utilizeze un index specific pentru a îndeplini interogarea, care poate fi apoi menționat fie prin document, fie prin nume de index.
De asemenea, puteți utiliza operatorul $hint pentru a testa strategiile de indexare și performanța interogărilor. De exemplu, luați următoarea operație:
db.users.find().hint( { age: 1 } ) Această operațiune ar returna toate documentele din colecția numite users , utilizând indexul din câmpul de age .
De asemenea, puteți menționa un indiciu utilizând oricare dintre următoarele forme:
db.users.find()._addSpecial( "$hint", { age : 1 } ) db.users.find( { $query: {}, $hint: { age : 1 } } ) Dacă există un filtru de index pentru forma de interogare, MongoDB ar ignora pur și simplu $hint .
$comentare
Operatorul $comment vă permite să atașați un comentariu la o interogare în orice context în care poate apărea $query . Deoarece comentariile se propagă în jurnalul de profil, adăugarea unui comentariu poate facilita interpretarea și urmărirea profilului dvs.
Puteți folosi $comment într-unul din trei moduri:
db.collection.find( { <query> } )._addSpecial( "$comment", <comment> ) db.collection.find( { <query> } ).comment( <comment> ) db.collection.find( { $query: { <query> }, $comment: <comment> } ) Dacă doriți să atașați comentarii la expresiile de interogare în alte contexte, cum ar fi cu db.collection.update() , folosiți operatorul de interogare $comment în loc de meta-operatorul.
$max
Puteți menționa o $max pentru a specifica limita superioară exclusivă pentru un anumit index pentru a constrânge rezultatele find() . Acest operator va specifica limita superioară pentru toate cheile dintr-o anumită ordine în index.
Mongosh vă oferă următoarea metodă max() wrapper:
db.collection.find( { <query> } ).max( { field1: <max value> , ... fieldN: <max valueN> } ) De asemenea, puteți menționa $max cu următoarele două forme:
db.collection.find( { <query> } )._addSpecial( "$max", { field1: <max value1> , ... fieldN: <max valueN> } ) db.collection.find( { $query: { <query> }, $max: { field1: <max value1> , ... fieldN: <max valueN> } } ) De exemplu, dacă doriți să specificați limita superioară exclusivă, țineți cont de următoarele operații pe o colecție numită colecție care conține un index { age: 1 } :
db.collection.find( { <query> } ).max( { age: 100 } ).hint( { age: 1 } ) Această operațiune va limita interogarea la acele documente în care vârsta câmpului este mai mică de 100 și forțează un plan de interogare care va scana indexul { age: 1 } de la minKey la 100.
$explica
Acest operator vă va oferi informații despre planul de interogare. Returnează un document care descrie indecșii și procesele utilizate pentru a returna interogarea. Acest lucru poate fi util atunci când încercați să optimizați o interogare.
Puteți menționa operatorul $explain în oricare dintre următoarele forme:
db.collection.find()._addSpecial( "$explain", 1 ) db.collection.find( { $query: {}, $explain: 1 } )Cele mai bune practici pentru operatorii MongoDB
În această secțiune, vom arunca o privire la unele dintre cele mai bune practici în timp ce folosim acești operatori MongoDB.
Încorporare și referire
Încorporarea este o extensie naturală a modelării datelor. Vă permite să evitați alăturarea aplicațiilor, ceea ce poate reduce actualizările și interogările.
Puteți încorpora date cu o relație 1:1 într-un singur document. Acestea fiind spuse, datele cu o relație many:1 în care apar „multe” obiecte împreună cu documentele lor părinte pot fi, de asemenea, buni candidați.
Stocarea acestor tipuri de date în același document pare o alegere prudentă. Cu toate acestea, încorporarea oferă performanțe mai bune pentru operațiunile de citire cu acest tip de localitate de date.
Modelele de date încorporate pot ajuta, de asemenea, dezvoltatorii să actualizeze datele asociate într-o singură operațiune de scriere. Acest lucru funcționează deoarece scrierile unui singur document sunt tranzacționale.
Ar trebui să luați în considerare utilizarea referințelor pentru următoarele scenarii:
- Când actualizați un segment de document și acesta continuă să devină mai lung, în timp ce restul documentului este static.
- Când un document este accesat, dar conține date care sunt rareori utilizate. Încorporarea ar crește doar cerințele în memorie, astfel încât referirea are mai mult sens.
- Când dimensiunea documentului depășește limita de 16 MB a documentului MongoDB. Acest lucru se poate întâmpla atunci când modelați multe relații:1 (de exemplu, angajați:departament ).
Examinați modelele de profilare și interogare
Pentru majoritatea dezvoltatorilor, primul pas în optimizarea performanței este înțelegerea tiparelor de interogare reale și așteptate. Odată ce cunoașteți suficient de bine modelele de interogare ale aplicației dvs., vă puteți crea modelul de date și puteți alege indici adecvați.
Dezvoltatorii MongoDB au acces la diverse instrumente puternice care le permit să îmbunătățească performanța. Dar asta nu înseamnă că profilurile și modelele de interogare pot fi ignorate.
De exemplu, o modalitate ușoară de a crește performanța este prin analizarea tiparelor de interogare și înțelegerea unde puteți încorpora datele. Alte modalități de a spori performanța MongoDB după identificarea tiparelor de interogare majore includ:
- Asigurați-vă că aveți indici pentru orice câmpuri pentru care interogați.
- Stocarea rezultatelor subinterogărilor frecvente pe documente pentru a reduce sarcina de citire.
- Aruncați o privire la jurnalele dvs. pentru a analiza interogările lente, apoi verificați-vă indexurile.
Examinați indexarea și modelarea datelor
În timp ce vă creați modelul de date, veți decide cum să modelați relațiile dintre date. Alegerea momentului în care să încorporați un document față de crearea unei referințe între documente separate din colecții diferite, de exemplu, este un exemplu de luare în considerare specifică aplicației.
Un avantaj major al documentelor JSON este că le permit dezvoltatorilor să modeleze datele pe baza cerințelor aplicației. Imbricarea subdocumentelor și a matricelor vă ajută să modelați relații complexe între date utilizând documente text simple.
De asemenea, puteți utiliza MongoDB pentru a modela următoarele:
- Date geospațiale
- Structuri tabulare, plate și columnare
- Perechi cheie-valoare simple
- Date din serii temporale
- Muchii și noduri ale structurilor de date grafice conectate și altele asemenea
Monitorizați fragmentarea și replicarea
Replicarea poate fi esențială pentru îmbunătățirea performanței, deoarece crește disponibilitatea datelor prin scalare orizontală. Replicarea poate duce la o performanță mai bună și mai multă securitate prin redundanță.
Monitorizarea performanței poate fi o problemă, având nevoie de resurse și timp suplimentar pentru a asigura o funcționare bună. Puteți utiliza instrumentele de monitorizare a performanței disponibile pe piață, care răspund nevoilor dumneavoastră specifice.
De exemplu, Kinsta APM poate prelua informații marcate de timp despre interogările bazei de date MySQL ale site-ului dvs. WordPress, procesele PHP, apeluri HTTP externe și multe altele. De asemenea, puteți utiliza acest instrument gratuit pentru a depana:
- Apeluri API lungi
- Solicitări URL externe lungi
- Interogări lente ale bazei de date, pentru a numi câteva.
În MongoDB, replicarea poate fi realizată prin seturi de replică care le permit dezvoltatorilor să copieze date de pe un nod sau server primar pe mai multe secundare. Acest lucru permite replicarea dvs. să execute unele interogări pe secundare, spre deosebire de cea primară, evitând conflictele și conducând la o mai bună echilibrare a încărcăturii.
Clusterele fragmentate din MongoDB sunt o altă modalitate de a îmbunătăți potențial performanța. Similar cu replicarea, sharding-ul poate fi folosit pentru a distribui seturi mari de date pe mai multe servere.
Utilizând o cheie shard, dezvoltatorii pot copia shard-uri sau bucăți de date pe mai multe servere. Aceste servere pot lucra împreună pentru a utiliza toate datele.
Sharding-ul are partea echitabilă de avantaje, inclusiv scalarea orizontală pentru scriere/citire, disponibilitate mai mare și capacitate de stocare crescută.
Determinați utilizarea memoriei
MongoDB funcționează cel mai bine atunci când setul de lucru al unei aplicații (adică date și indici accesați frecvent) se încadrează în memorie fără probleme. În timp ce alți factori sunt esențiali pentru performanță, dimensiunea RAM este cea mai importantă, de exemplu dimensionarea.
Când setul de lucru al unei aplicații se potrivește în RAM, activitatea de citire de pe disc trebuie să fie scăzută. Dar dacă setul dvs. de lucru depășește RAM sau dimensiunea serverului de instanță, activitatea de citire va începe să se declanșeze.
Dacă vedeți că se întâmplă acest lucru, este posibil să puteți rezolva problema trecând la o instanță mai mare care are mai multă memorie.
Plasați câmpuri cu valori multiple la sfârșit
Dacă indexați câteva câmpuri, iar unul dintre câmpurile pe care doriți să le interogați folosește unul dintre acești operatori „multi-valoare”, atunci ar trebui să-i puneți la sfârșitul indexului. Trebuie să ordonați indexul astfel încât câmpurile interogate pentru valori exacte să fie pe primul loc, iar operatorii „multi-valoare” să apară ultimii în index.
O excepție de la aceasta ar fi sortarea în funcție de câmpuri. Plasați-le între câmpurile „multi-valoare” și exacte pentru a reduce cantitatea de sortare în memorie necesară.
rezumat
Pentru MongoDB, viteza este numele jocului. Pentru a returna rapid interogările, MongoDB folosește operatorii pentru a executa sarcini matematice sau logice. Pur și simplu, înțelegerea operatorilor MongoDB este cheia stăpânirii MongoDB.
Acest articol a evidențiat câțiva dintre operatorii cheie MongoDB pe care îi puteți utiliza pentru datele dvs., cum ar fi operatorii de comparație, operatorii logici, metaoperatorii și operatorii de proiecție, pentru a numi câțiva. De asemenea, vă ajută să înțelegeți cum puteți utiliza operatorii MongoDB și cele mai bune practici care vă vor permite să obțineți ce e mai bun din ei.
Dintre toți operatori, pe care(i) îl folosiți cel mai des și de ce? Distribuie în comentariile de mai jos - ne-ar plăcea să auzim părerile tale!