9 tipi di operatori Mongodb che devi conoscere

In qualsiasi azienda, i dati sono la tua risorsa più grande. Analizzando i dati, puoi prendere decisioni sulle tendenze dei clienti e sulla previsione del comportamento. Ciò aumenta la redditività aziendale e un processo decisionale efficace.

Senza un software di database, un compito semplice come trovare la media di tutti i valori in un sistema pieno di record sarebbe noioso. Fortunatamente, i database hanno reso l'analisi dei dati più semplice e veloce con funzioni e operatori.

Questo articolo farà luce sugli operatori utilizzati nel software di database MongoDB.

Cosa sono gli operatori MongoDB?

MongoDB è un software di database NoSQL che gestisce le informazioni orientate ai documenti.

Una delle caratteristiche chiave di MongoDB è la sua velocità. Per restituire le query più velocemente, MongoDB può utilizzare gli operatori per eseguire funzioni specifiche.

Gli operatori sono simboli speciali che aiutano i compilatori a eseguire compiti matematici o logici. MongoDB offre diversi tipi di operatori per interagire con il database.

Tipi di operatori MongoDB

Esistono nove tipi di operatori, ciascuno denominato per la sua funzione. Ad esempio, gli operatori logici utilizzano operazioni logiche. Per eseguirli, è necessario utilizzare una parola chiave specifica e seguire la sintassi. Tuttavia, sono abbastanza facili da seguire!

Entro la fine dell'articolo, sarai in grado di apprendere le basi di ciascun operatore e le sue funzioni.

Operatori logici

Gli operatori logici vengono spesso utilizzati per filtrare i dati in base alle condizioni date. Consentono anche la valutazione di molte condizioni, di cui parleremo più in dettaglio.

Di seguito sono riportati alcuni operatori logici che puoi utilizzare:

$ e

Una condizione "e" esegue un'operazione logica "e" su una matrice di due o più espressioni. Seleziona i documenti in cui sono soddisfatte tutte le condizioni delle espressioni.

Questa è la sintassi standard per l'espressione $and :

 { $and: [ { <expression1> }, { <expression2> }, ... , { <expressionN> } ] } Ad esempio, se vogliamo selezionare documenti in cui il prezzo è $ 10 e la quantità è inferiore a 15, possiamo inserire la seguente query:

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

$ o

Una condizione "or" esegue un'operazione logica "or" su una matrice di due o più espressioni. Seleziona i documenti in cui almeno una delle espressioni è vera.

Questa è la sintassi standard per l'espressione $or :

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

Ad esempio, se vogliamo selezionare documenti in cui il prezzo è $ 10 o la quantità è inferiore a 15, possiamo inserire la seguente query:

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

Non dobbiamo limitare l'espressione a due criteri: possiamo aggiungerne altri. Ad esempio, la query seguente seleziona quei documenti in cui il prezzo è pari a $ 10, la quantità è inferiore a 15 o il tag è fermo:

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

Quando si eseguono queste clausole, MongoDB esegue una scansione della raccolta o una scansione dell'indice. Se tutti gli indici supportano le clausole, MongoDB utilizza gli indici per controllare un'espressione $or . In caso contrario, utilizza invece una scansione della raccolta.

Ma se vuoi testare i criteri nello stesso campo, potresti voler usare l'operatore $in piuttosto che l'operatore $or . Ad esempio, se desideri una raccolta di documenti in cui la quantità è 10 o 20, potresti dover eseguire invece la query $in seguito:

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

Tratteremo di più sull'operatore $in seguito.

$ né

Questo operatore esegue un'operazione logica "nor" su un array utilizzando una o più espressioni. Successivamente, seleziona i documenti che non superano le espressioni di query. In termini più semplici, fa l'opposto della condizione $or .

Questa è la sintassi generale:

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

Consideriamo la seguente domanda:

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

Questa query seleziona i documenti che contengono:

• un valore del campo del prezzo diverso da $ 3,99 e un valore di vendita diverso da true; o
• un valore del campo del prezzo non uguale a $ 3,99 e un campo di vendita vuoto o assente; o
• nessun campo prezzo e un campo vendita diverso da true; o
• né campo prezzo né campo vendita compilato o presente.

$non

Questo operatore esegue un'operazione logica "non" su una matrice per l'espressione specificata. Seleziona quindi i documenti che non corrispondono alle espressioni di query. Ciò include i documenti che non contengono il campo.

Questa è la sintassi generale:

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

Ad esempio, prendi la seguente query:

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

Questa query selezionerebbe quei documenti che contengono:

• un campo prezzo il cui valore è maggiore o uguale a $ 3,99; e
• un campo prezzo non è popolato o non esiste.

Operatori di confronto

Gli operatori di confronto possono essere utilizzati per confrontare i valori in uno o più documenti.

Di seguito è riportato un codice di esempio di una semplice raccolta di inventario per un supermercato:

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

Utilizzeremo questo esempio mentre descriviamo successivamente ogni operatore di confronto.

Uguale a ($ eq)

Questo operatore confronta valori che sono uguali al valore dato:

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

Ad esempio, se vogliamo recuperare un documento specifico dalla raccolta di inventario con il valore esatto della quantità "20", dovremo inserire il seguente comando:

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

La query restituirebbe quanto segue:

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

Maggiore di ($gt)

Questo operatore corrisponde se i valori sono maggiori del valore dato:

 { field: { $gt: value } }

In questo esempio, recuperiamo i documenti in cui la quantità è maggiore di 15:

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

La query restituirebbe quanto segue:

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

Meno di ($lt)

Questo operatore corrisponde se i valori sono inferiori al valore fornito:

 { field: { $lt: value } }

Troviamo i documenti con una quantità inferiore a 25:

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

La query restituirebbe quanto segue:

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

Maggiore o uguale a ($gte)

Questo operatore corrisponde quando i valori sono maggiori o uguali al valore dato:

 { field: { $gte: value } }

In questo esempio, recuperiamo i documenti in cui la quantità è maggiore o uguale a 25:

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

Questa query restituirebbe quanto segue:

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

Minore o uguale a ($lte)

Questo operatore corrisponde solo se i valori sono minori o uguali al valore dato:

 { field: { $lte: value } }

Troviamo i documenti con una quantità minore o uguale a 25.

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

Possiamo aspettarci che questa query restituisca quanto segue:

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

In ($ in)

Questo operatore restituisce i documenti che corrispondono ai valori specificati:

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

Il valore di un campo è uguale a qualsiasi valore nella matrice specificata. Per recuperare i documenti con valori "30" e "15" nella raccolta dell'inventario, ad esempio, dovresti fare questo:

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

L'output sarebbe:

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

Non in ($ nove)

Questo operatore restituisce i documenti che non corrispondono ai valori specificati. Ecco la sintassi di base dell'operatore $nin :

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

$nin seleziona i documenti in cui:

• il valore del campo non è nella matrice specificata; o
• il campo non esiste.

Se il campo contiene matrici, selezionerà le matrici in cui non è presente alcun elemento specificato nella sezione del valore. Ad esempio, vogliamo selezionare quei documenti in cui la quantità non è uguale a 20 o 15.

Inoltre, abbina anche i documenti che non hanno un campo quantità:

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

L'output sarebbe:

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

Non uguale ($ne)

L'operatore $ne restituisce i documenti in cui il valore specificato non è uguale:

 { $ne: value } }

Ad esempio, supponiamo di voler selezionare tutti i documenti in cui la quantità non è uguale a 20:

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

L'output sarebbe:

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

Dall'output sopra, possiamo vedere che la query selezionerà i documenti che non hanno un campo di quantità.

Operatori di elementi

Gli operatori di query dell'elemento possono identificare i documenti utilizzando i campi del documento. Gli operatori degli elementi sono costituiti da $exist e $type .

$esiste

Questo operatore abbina i documenti che hanno un campo specificato. Questo operatore ha un valore booleano che può essere true o false .

Se specificato come true , corrisponde ai documenti che contengono quel campo, inclusi i documenti in cui il valore del campo è null. Se <boolean> è false , la query restituisce solo i documenti che non contengono il campo.

Ecco la sintassi standard:

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

Facciamo un esempio in cui abbiamo una raccolta di dati per un array chiamato "bagofmarbles", in cui ogni borsa contiene biglie di diversi colori:

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

Diciamo che vogliamo una query che restituisca solo quei sacchetti in cui esistono le biglie rosse. Ciò significa che dovremmo inserire il valore booleano come true . Diamo un'occhiata:

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

I risultati sarebbero costituiti da quei documenti che contengono il campo "rosso", anche se il valore fosse null . Tuttavia, non sarebbe costituito dai documenti in cui il campo "rosso" non esisteva nemmeno:

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

Se volessimo solo quei sacchetti in cui le biglie rosse non esistono nemmeno come campo, possiamo inserire la query seguente:

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

I risultati consisterebbero in quei documenti che non contengono il campo “rosso”:

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

$ tipo

Questo operatore abbina i documenti in base al tipo di campo specificato. Ciò è utile quando si dispone di dati altamente non strutturati o quando i tipi di dati non sono prevedibili. Questi tipi di campo sono tipi BSON specificati e possono essere definiti dal numero del tipo o dall'alias.

Questa è la sintassi generale per $type :

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

Supponiamo di avere una rubrica contenente i seguenti documenti:

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

Osservando i documenti di cui sopra, il codice postale ha diversi tipi di dati. Ciò include valori long, double, interi e string.

Se vogliamo solo quei documenti che hanno un tipo di dati specificato come codice postale - prendiamo una stringa per questa istanza - dovremmo inserire la seguente query nel compilatore:

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

Ciò restituirebbe i seguenti documenti:

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

Inoltre, esiste un tipo "numero", che include tutti i valori long, interi o double come matrice contenente un elemento dei tipi specificati:

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

Produzione:

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

Se i documenti hanno un tipo di campo matrice, l'operatore $type restituisce i documenti in cui almeno un elemento della matrice corrisponde al tipo passato all'operatore.

Operatori di array

MongoDB comprende anche operatori di array, per interrogare documenti contenenti array.

Esistono tre operatori principali: $all , $elemMatch e $size . Discuteremo ciascuno in dettaglio di seguito.

$tutti

L'operatore $all sceglie i documenti in cui il valore di un campo è un array contenente gli elementi specificati:

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

Ad esempio, supponiamo di avere una raccolta di documenti per un negozio di abbigliamento, con quanto segue in inventario.

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

Vorremmo recuperare tutti i documenti (in questo caso, i vestiti) dall'inventario che sono collegati con i tag "trendy" e "y2k". La query seguente utilizza l'operatore $all in cui il valore del campo dei tag è un array i cui elementi includono "y2k" e "trendy":

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

La query precedente restituisce quanto segue:

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

Dall'esempio sopra, troviamo anche che l'operatore $all esegue semplicemente la stessa funzione dell'operazione $and .

In alternativa, potremmo utilizzare la query seguente che darebbe un output simile a quello sopra:

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

$elemMatch

L'operatore $elemMatch abbina i documenti che contengono un campo matrice con almeno un elemento che corrisponde a tutti i criteri di query specificati:

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

Sebbene possiamo utilizzare operatori di confronto come $lte e $gte , se specifichiamo solo una singola condizione di query all'interno $elemMatch e non stiamo utilizzando gli operatori $not o $ne , l'utilizzo $elemMatch può essere omesso poiché essenzialmente sarebbe performante la stessa funzione.

Ci sono alcune altre cose da tenere a mente durante l'utilizzo di questo operatore, principalmente:

• Non è possibile specificare un'espressione $where in un'operazione $elemMatch .
• Non è possibile specificare un'espressione di query $text in un'operazione $elemMatch .

Ad esempio, abbiamo i seguenti documenti nella raccolta dei risultati degli studenti:

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

La query seguente corrisponde solo a quei documenti in cui la matrice dei risultati contiene almeno un elemento che è sia maggiore o uguale a 90 che minore di 95:

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

La nostra query restituisce il seguente documento, poiché l'elemento 92 è sia maggiore che uguale a 90 ed è minore di 95:

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

$ taglia

L'operatore $size restituisce quei documenti in cui la dimensione dell'array corrisponde al numero di elementi specificato nell'argomento:

 { field: { $size: value } }

Ecco un esempio:

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

Ciò restituirebbe tutti i documenti nella raccolta specificata in cui il campo è un array con 2 elementi: { field: [ orange, apple] } e { field: [ blue, red] } , ma non { field: blue} o { field: [ raspberry, lemon, grapefruit ] } .

Tuttavia, mentre possiamo inserire il valore specifico come dimensione, non possiamo specificare intervalli di valori come dimensione.

Operatori geospaziali

MongoDB ti consente di archiviare dati geospaziali sotto forma di tipi GeoJSON. GeoJSON è un formato standard aperto basato sulla notazione dell'oggetto JavaScript che può rappresentare caratteristiche geografiche e supportare attributi non spaziali. Esistono due tipi di operatori geospaziali di cui parleremo in questo articolo: identificatori di geometria e selettori di query.

$ geometria

Questo operatore menziona la geometria GeoJSON da utilizzare con i seguenti operatori di query geospaziali: $geoIntersects , $geoWithin , $nearSphere e $near . $geometry sfrutta EPSG:4326 come sistema di riferimento di coordinate (CRS) predefinito.

Per menzionare gli oggetti GeoJSON con il CRS predefinito, puoi sfruttare il seguente snippet per $geometry :

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

Per citare un poligono GeoJSON ad anello singolo con un CRS MongoDB personalizzato, puoi utilizzare il seguente snippet (puoi usarlo solo per $geoWithin e $geoIntersects ):

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

$ poligono

L'operatore $polygon può essere utilizzato per specificare un poligono per una query geospaziale $geoWithin su coppie di coordinate legacy. Questa query restituirà quindi coppie che rientrano nei confini del poligono. Tuttavia, $polygon non eseguirà query per alcun oggetto GeoJSON. Per definire un poligono, è necessario specificare una matrice di punti di coordinate come segue:

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

Qui l'ultimo punto è implicitamente connesso al primo. Puoi citare tutti i punti o lati che vuoi.

Ad esempio, la query seguente restituirà tutti i documenti che hanno coordinate esistenti all'interno del poligono definito da [0,0], [1,5] e [3,3]:

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

$geoWithin

Questo operatore può essere utilizzato per scegliere documenti con dati geospaziali completamente contenuti in una forma specifica. La forma specificata può essere un multipoligono GeoJSON, un poligono GeoJSON (a più anelli o ad anello singolo) o una forma che può essere definita da coppie di coordinate legacy.

L'operatore $geoWithin sfrutterà l'operatore $geometry per menzionare l'oggetto GeoJSON.

Per menzionare i multipoligoni o i poligoni GeoJSON tramite il sistema di riferimento di coordinate (CRS) predefinito, puoi utilizzare la sintassi menzionata di seguito:

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

Per le query $geoWithin che menzionano le geometrie GeoJSON con aree più grandi di un singolo emisfero, l'uso del CRS predefinito porterebbe a query per le geometrie complementari.

Per citare un poligono GeoJSON ad anello singolo con un CRS MongoDB personalizzato, puoi sfruttare il prototipo menzionato di seguito nell'espressione $geometry :

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

L'esempio seguente raccoglie tutti i dati loc che esistono completamente all'interno di un poligono GeoJSON, l'area del poligono essendo inferiore all'area di un singolo emisfero:

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

$ scatola

È possibile utilizzare $box per specificare un rettangolo per una query geospaziale $geoWithin per fornire documenti che si trovano entro i confini del rettangolo, in base ai dati di posizione basati su punti. Quando usi $geoWithin con $box , otterrai documenti basati sulle coordinate della query. In questo scenario, $geoWithin non eseguirà query per nessuna forma GeoJSON.

Per sfruttare l'operatore $box , devi menzionare gli angoli in alto a destra e in basso a sinistra del rettangolo in un oggetto array:

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

La suddetta query calcolerà la distanza utilizzando la geometria planare (piatta). La seguente query restituirà tutti i documenti che si trovano all'interno della casella con punti a: [0,0], [0,30], [30,0], [30,30]:

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

$ vicino a Sfera

Puoi usare $nearSphere per menzionare un punto per il quale una query geospaziale restituisce i documenti dal più vicino al più lontano.

MongoDB utilizza la geometria sferica per calcolare le distanze per $nearSphere . Avrà bisogno di un indice geospaziale come segue:

1. Indice 2d per i dati sulla posizione descritti come coppie di coordinate legacy. Per sfruttare un indice 2d sui punti GeoJSON, è necessario generare l'indice nel campo delle coordinate dell'oggetto GeoJSON.
2. Indice 2dsphere per i dati sulla posizione descritti come punti GeoJSON.

Per citare un punto GeoJSON, puoi sfruttare la seguente sintassi:

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

Qui, $minDistance e $maxDistance sono opzionali. $minDistance può limitare i risultati a quei documenti che si trovano almeno alla distanza specificata dal centro. Puoi usare $maxDistance per entrambi gli indici.

Consideriamo ora una raccolta di "luoghi" costituita da documenti con un campo posizione che ha un indice 2dsphere. L'esempio seguente restituisce i punti la cui posizione è di almeno 2.000 metri e al massimo 6.000 metri dal punto scelto, ordinati dal più vicino al più lontano:

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

$geoIntersects

L'operatore $geoIntersects consente di selezionare documenti i cui dati geospaziali si intersecano con un particolare oggetto GeoJSON (ovvero in cui la convergenza dell'oggetto specificato e dei dati non è vuota). Sfrutta l'operatore $geometry per specificare l'oggetto GeoJSON.

Per menzionare i multipoligoni o i poligoni GeoJSON tramite il sistema di riferimento delle coordinate (CRS) predefinito, puoi utilizzare la seguente sintassi:

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

L'istanza seguente utilizzerà $geoIntersects per raccogliere tutti i dati di localizzazione che si intersecano con il poligono descritto dall'array di coordinate:

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

$centro

L'operatore $center menziona un cerchio per una query $geoWithin che restituisce coppie di coordinate legacy che si trovano all'interno dei confini del cerchio.

$center non restituisce oggetti GeoJSON. Per sfruttare l'operatore $center , è necessario specificare un array che contenga:

1. Il raggio del cerchio, misurato nelle unità utilizzate dal sistema di coordinate.
2. Le coordinate della griglia del punto centrale del cerchio.

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

L'esempio riportato di seguito restituirà tutti i documenti che hanno coordinate che possono essere trovate all'interno del cerchio centrato su [2,3] e con raggio 40:

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

Operatori di proiezione

È possibile utilizzare gli operatori di proiezione per menzionare i campi restituiti da un'operazione. Gli operatori di proiezione MongoDB consentono di utilizzare la funzione find() con gli argomenti di filtraggio dei dati. Questo aiuta gli utenti a estrarre solo i campi di dati richiesti da un documento. Quindi, ti consente di proiettare dati trasparenti e concisi senza influire sulle prestazioni complessive del database.

$elemMatch (proiezione)

L'operatore $elemMatch è responsabile della limitazione del contenuto di un campo dai risultati della query in modo che contenga solo il primo elemento che corrisponde alla condizione $elemMatch .

Ecco alcune cose che devi tenere a mente prima di usare $elemMatch :

• Da MongoDB 4.4, indipendentemente dall'ordine dei campi nel documento, la proiezione $elemMatch di un campo esistente restituisce il campo dopo l'inclusione di altri campi esistenti.
• Entrambi gli operatori $elemMatch e $ descrivono il primo elemento corrispondente da una matrice in base a una condizione specificata. L'operatore $ proietterebbe il primo elemento dell'array corrispondente da ogni documento in una raccolta in base a una condizione dell'istruzione della query, mentre l'operatore di proiezione $elemMatch accetta un argomento di condizione esplicito. Ciò consente di proiettare in base a una condizione non presente nella query o se è necessario proiettare in base a vari campi nei documenti incorporati dell'array.

Dovresti anche essere a conoscenza delle seguenti restrizioni prima di utilizzare l'operatore $elemMatch sui tuoi dati:

• Non puoi menzionare un'espressione di query $text all'interno di un operatore $elemMatch .
• Le operazioni db.collection.find() sulle viste non supportano l'operatore di proiezione $elemMatch .

L'esempio seguente sull'operatore di proiezione $elemMatch presuppone una raccolta di schools con i seguenti documenti:

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

In questo caso, l'operazione find() esegue una query per tutti i documenti in cui il valore del campo codice postale è 63110. La proiezione $elemMatch restituirebbe solo il primo elemento corrispondente dell'array students in cui il campo school ha un valore di 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 } ] }

$fetta (proiezione)

L'operatore di proiezione $slice può essere utilizzato per specificare il numero di elementi in una matrice da restituire nel risultato della query:

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

Si può anche esprimere in questo modo:

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

Per dimostrare lo stesso, puoi creare una raccolta di esempio di tweet con i seguenti documenti:

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

L'operazione seguente utilizzerà l'operatore di proiezione $slice sull'array tweets per restituire l'array con i suoi primi due elementi. Se una matrice contiene meno di due elementi, vengono restituiti tutti gli elementi della matrice:

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

Tale operazione restituirebbe i seguenti documenti:

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

$ (proiezione)

L'operatore posizionale $ limita il contenuto di una matrice per restituire il primo elemento che corrisponde alla condizione della query di tale matrice. È possibile utilizzare $ nel documento di proiezione del metodo find() o del metodo findOne() quando si richiede solo un particolare elemento dell'array nei documenti scelti.

Ecco come appare la sintassi per l'operatore $ :

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

In questo esempio, la collezione degli students è composta dai seguenti documenti:

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

Nella query seguente, la proiezione { "grades.$": 1 } restituisce solo il primo elemento maggiore o uguale a 89 per il campo grades :

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

Questa operazione restituisce i seguenti documenti:

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

Operatori di valutazione

Puoi sfruttare gli operatori di valutazione di MongoDB per misurare la struttura dei dati complessiva o il singolo campo all'interno di un documento.

Diamo un'occhiata ad alcuni comuni operatori di valutazione di MongoDB.

$ mod

È possibile utilizzare questo operatore per abbinare i documenti in cui il valore di un campo specificato è uguale al resto dopo essere stato diviso per un valore specificato:

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

Supponiamo che tu abbia un tavolo di auto appartenenti a diversi marchi che possiedi nel tuo showroom. La seguente query ti darebbe tutte le marche di auto i cui numeri di stock sono multipli di 250.

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

$jsonSchema

$jsonSchema ti consente di abbinare i documenti che corrispondono allo schema JSON specificato. L'implementazione dello schema JSON da parte di MongoDB include l'aggiunta della parola chiave bsonType , che consente di utilizzare tutti i tipi BSON all'interno dell'operatore $jsonSchema .

bsonType può accettare gli stessi alias di stringa che useresti per l'operatore di type . Ecco come sarebbe la sintassi di $jsonSchema :

 { $jsonSchema: <JSON Schema object> }

Qui, l'oggetto dello schema JSON è formattato in base alla bozza 4 dello standard dello schema JSON:

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

Ecco un esempio per dimostrare come funziona $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" } } } } } }

Puoi anche utilizzare $jsonSchema in un validatore di documenti per applicare lo schema specificato alle operazioni di aggiornamento e inserimento:

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

Tieni presente che ci sono diverse cose non supportate dall'operatore $jsonSchema :

1. Il tipo intero. Devi sfruttare il tipo BSON long o int con la parola chiave bsonType.
2. Parole chiave sconosciute.
3. Collegamento delle proprietà e dell'ipermedia dello schema JSON, insieme all'uso di riferimenti JSON e puntatori JSON.

$testo

L'operatore $text cercherà un testo all'interno del contenuto del campo specificato, indicizzato con un indice di testo:

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

In questo caso, il seguente frammento di codice passerà al setaccio la tabella per filtrare tutte le auto che contengono il testo "Porsche":

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

$regex

L'operatore $regex offre capacità di espressione regolare per creare modelli di stringhe di corrispondenza nelle query. MongoDB sfrutta le espressioni regolari compatibili con Perl:

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

L'esempio seguente aiuterebbe a filtrare tutte le auto che hanno la stringa "$78900" presente al loro interno:

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

$espr

L'operatore $expr consente di sfruttare le espressioni di aggregazione all'interno del linguaggio di query:

 { $expr: { <expression> } }

Puoi anche utilizzare $expr per creare espressioni di query che confrontano i campi dello stesso documento in una fase di $match . 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> , ... ] } }

Il valore del campo deve essere un'istanza BinData o un valore numerico per $bitsAllSet in modo che corrisponda al documento corrente.

Nel seguente caso, stiamo sfruttando una raccolta con i seguenti documenti:

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

La query menzionata di seguito utilizzerà l'operatore $bitsAllSet per verificare se il campo a ha bit impostati in posizione 1 e posizione 5, dove il bit meno significativo sarebbe in posizione 0:

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

Questa query corrisponderebbe ai seguenti documenti:

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

$bitsAllCancella

L'operatore $bitsAllClear documenti in cui tutte le posizioni dei bit fornite dalla query sono chiare o 0 :

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

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

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

Useremo l'esempio usato per $bitsAllSet qui per dimostrare l'uso di $bitsAllClear . La query seguente utilizzerà questo operatore per verificare se il campo a ha i bit azzerati nelle posizioni 1 e 5:

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

Questa query corrisponderebbe ai seguenti documenti:

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

Meta operatori

Esistono vari modificatori di query che consentono di modificare il comportamento o l'output di una query in MongoDB. Le interfacce del driver potrebbero fornire metodi del cursore che le avvolgono per l'uso.

$suggerimento

MongoDB ha deprecato $hint dalla v3.2. Tuttavia, questo operatore potrebbe essere ancora disponibile per i driver MongoDB come Go, Java, Scala, Ruby, Swift, ecc. Può forzare l'ottimizzatore di query a sfruttare un indice specifico per soddisfare la query, che può quindi essere menzionata dal documento o da nome dell'indice.

Puoi anche utilizzare l'operatore $hint per testare le strategie di indicizzazione e le prestazioni delle query. Ad esempio, esegui la seguente operazione:

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

Questa operazione restituirebbe tutti i documenti all'interno della collezione chiamati users sfruttando l'indice sul campo age .

Puoi anche menzionare un suggerimento utilizzando uno dei seguenti moduli:

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

Se esiste un filtro di indice per la forma della query, MongoDB ignorerebbe semplicemente $hint .

$ commento

L'operatore $comment ti consente di allegare un commento a una query in qualsiasi contesto in cui $query possa apparire. Poiché i commenti si propagano al registro del profilo, l'aggiunta di un commento può semplificare l'interpretazione e il tracciamento del tuo profilo.

Puoi sfruttare $comment in uno dei tre modi seguenti:

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

Se desideri allegare commenti alle espressioni di query in altri contesti, ad esempio con db.collection.update() , sfrutta l'operatore di query $comment invece del metaoperatore.

$ max

Puoi menzionare un valore $max per specificare il limite superiore esclusivo per un particolare indice per vincolare i risultati di find() . Questo operatore specificherà il limite superiore per tutte le chiavi di un ordine specifico nell'indice.

Mongosh ti offre il seguente metodo wrapper max() :

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

Puoi anche menzionare $max con le seguenti due 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> } } )

Ad esempio, se desideri specificare il limite superiore esclusivo, tieni presente le seguenti operazioni su una raccolta denominata raccolta che contiene un indice { age: 1 } :

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

Questa operazione limiterà la query a quei documenti in cui il campo age è inferiore a 100 e forza un piano di query che analizzerà l'indice { age: 1 } da minKey a 100.

$spiega

Questo operatore ti fornirà informazioni sul piano di query. Restituisce un documento che descrive gli indici e i processi utilizzati per restituire la query. Questo può essere utile quando si tenta di ottimizzare una query.

Puoi menzionare l'operatore $explain in una delle seguenti forme:

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

Migliori pratiche per gli operatori MongoDB

In questa sezione, daremo un'occhiata ad alcune delle migliori pratiche durante l'utilizzo di questi operatori MongoDB.

Incorporamento e riferimento

L'incorporamento è un'estensione naturale della modellazione dei dati. Ti consente di evitare i join delle applicazioni, che possono ridurre gli aggiornamenti e le query.

Puoi incorporare dati con una relazione 1:1 all'interno di un singolo documento. Detto questo, anche i dati con una relazione molti:1 in cui vengono visualizzati "molti" oggetti con i documenti principali possono essere buoni candidati.

La memorizzazione di questi tipi di dati nello stesso documento sembra una scelta prudente. Tuttavia, l'incorporamento offre prestazioni migliori per le operazioni di lettura con questo tipo di località di dati.

I modelli di dati incorporati possono anche aiutare gli sviluppatori ad aggiornare i dati associati in un'unica operazione di scrittura. Funziona perché le scritture di documenti singoli sono transazionali.

Dovresti considerare l'utilizzo del riferimento per i seguenti scenari:

• Quando aggiorni un segmento di documento e continua ad allungarsi, mentre il resto del documento è statico.
• Quando si accede a un documento ma contiene dati usati raramente. L'incorporamento aumenterebbe solo i requisiti di memoria, quindi il riferimento ha più senso.
• Quando la dimensione del documento supera il limite di 16 MB di MongoDB. Questo può accadere quando si modellano molte:1 relazioni (ad esempio, dipendenti:dipartimento ).

Esaminare profili e modelli di query

Per la maggior parte degli sviluppatori, il primo passaggio nell'ottimizzazione delle prestazioni consiste nel comprendere i modelli di query effettivi e previsti. Una volta che conosci abbastanza bene i modelli di query della tua applicazione, puoi creare il tuo modello di dati e scegliere gli indici appropriati.

Gli sviluppatori MongoDB hanno accesso a vari potenti strumenti che consentono loro di migliorare le prestazioni. Ma ciò non significa che i profili e i modelli di query possano essere ignorati.

Ad esempio, un modo semplice per aumentare le prestazioni è analizzare i modelli di query e comprendere dove è possibile incorporare i dati. Altri modi per rafforzare le prestazioni di MongoDB dopo aver identificato i principali modelli di query includono:

• Assicurati di avere indici su tutti i campi su cui esegui query.
• Memorizzazione dei risultati di frequenti sottoquery sui documenti per ridurre il carico di lettura.
• Dai un'occhiata ai tuoi log per esaminare le query lente, quindi controlla i tuoi indici.

Rivedere l'indicizzazione e la modellazione dei dati

Durante la creazione del tuo modello di dati, dovrai decidere come modellare le relazioni tra i dati. La scelta di quando incorporare un documento rispetto alla creazione di un riferimento su documenti separati in raccolte diverse, ad esempio, è un esempio di considerazione specifica dell'applicazione.

Uno dei principali vantaggi dei documenti JSON è che consentono agli sviluppatori di modellare i dati in base ai requisiti dell'applicazione. L'annidamento di documenti secondari e matrici consente di modellare relazioni complesse tra i dati sfruttando semplici documenti di testo.

Puoi anche usare MongoDB per modellare quanto segue:

• Dati geospaziali
• Strutture tabulari, piatte e colonnari
• Semplici coppie chiave-valore
• Dati di serie temporali
• Bordi e nodi di strutture dati grafiche connesse e simili

Monitorare lo sharding e la replica

La replica può essere fondamentale per migliorare le prestazioni poiché aumenta la disponibilità dei dati attraverso il ridimensionamento orizzontale. La replica può portare a prestazioni migliori e maggiore sicurezza attraverso la ridondanza.

Il monitoraggio delle prestazioni può essere una seccatura che richiede risorse e tempo aggiuntivi per garantire un funzionamento regolare. Puoi sfruttare gli strumenti di monitoraggio delle prestazioni disponibili sul mercato che soddisfano le tue esigenze specifiche.

Ad esempio, Kinsta APM può acquisire informazioni con timestamp sulle query del database MySQL del tuo sito WordPress, sui processi PHP, sulle chiamate HTTP esterne e molto altro. Puoi anche utilizzare questo strumento gratuito per eseguire il debug:

• Chiamate API lunghe
• Richieste URL esterne lunghe
• Query lente del database per citarne alcuni.

In MongoDB, la replica può essere ottenuta tramite set di repliche che consentono agli sviluppatori di copiare i dati da un nodo primario o da un server su più secondari. Ciò consente alla tua replica di eseguire alcune query su secondarie anziché su quella primaria, evitando conflitti e portando a un migliore bilanciamento del carico.

I cluster partizionati in MongoDB sono un altro modo per migliorare potenzialmente le prestazioni. Analogamente alla replica, il partizionamento orizzontale può essere utilizzato per distribuire set di dati di grandi dimensioni su più server.

Sfruttando una chiave shard, gli sviluppatori possono copiare frammenti o parti di dati su più server. Questi server possono collaborare per utilizzare tutti i dati.

Lo sharding ha la sua giusta dose di vantaggi, tra cui il ridimensionamento orizzontale per scritture/letture, maggiore disponibilità e maggiore capacità di archiviazione.

Determina l'uso della memoria

MongoDB offre prestazioni migliori quando il working set di un'applicazione (cioè dati e indici a cui si accede frequentemente) si adatta alla memoria senza problemi. Mentre altri fattori sono fondamentali per le prestazioni, la dimensione della RAM è la più importante, ad esempio il dimensionamento.

Quando il working set di un'applicazione si adatta alla RAM, l'attività di lettura dal disco deve essere bassa. Ma se il tuo set di lavoro supera la RAM del server di istanza o le dimensioni, l'attività di lettura inizierà a salire.

Se vedi che ciò accade, potresti essere in grado di risolvere il problema passando a un'istanza più grande che ha più memoria.

Posiziona i campi multivalore alla fine

Se stai indicizzando un paio di campi e uno dei campi che desideri interrogare utilizza uno di quegli operatori "multivalore", dovresti inserirli alla fine dell'indice. È necessario ordinare l'indice in modo che i campi interrogati per i valori esatti vengano prima e gli operatori "multivalore" vengano visualizzati per ultimi nell'indice.

Un'eccezione a questo sarebbe l'ordinamento rispetto ai campi. Posizionali tra i campi "multivalore" ed esatti per ridurre la quantità di ordinamento in memoria necessario.

Riepilogo

Per MongoDB, la velocità è il nome del gioco. Per restituire rapidamente le query, MongoDB sfrutta gli operatori per eseguire attività matematiche o logiche. In poche parole, la comprensione degli operatori MongoDB è la chiave per padroneggiare MongoDB.

Questo articolo ha evidenziato alcuni degli operatori MongoDB chiave che puoi utilizzare sui tuoi dati come operatori di confronto, operatori logici, metaoperatori e operatori di proiezione, solo per citarne alcuni. Ti aiuta anche a capire come utilizzare gli operatori MongoDB e le migliori pratiche che ti permetteranno di ottenere il meglio da essi.

Tra tutti gli operatori, quale/i utilizzi più spesso e perché? Condividi i commenti qui sotto: ci piacerebbe sentire i tuoi pensieri!