9 types d'opérateurs Mongodb que vous devez connaître
Publié: 2022-09-09Dans toute entreprise, les données sont votre plus grand atout. En analysant les données, vous pouvez prendre des décisions sur les tendances des clients et la prédiction du comportement. Cela stimule la rentabilité de l'entreprise et une prise de décision efficace.
Sans logiciel de base de données, une tâche simple comme trouver la moyenne de toutes les valeurs dans un système plein d'enregistrements serait fastidieuse. Heureusement, les bases de données ont rendu l'analyse des données plus facile et plus rapide avec des fonctions et des opérateurs.
Cet article apportera un éclairage sur les opérateurs utilisés dans le logiciel de base de données MongoDB.
Que sont les opérateurs MongoDB ?
MongoDB est un logiciel de base de données NoSQL qui gère les informations orientées document.
L'une des principales caractéristiques de MongoDB est sa vitesse. Pour renvoyer les requêtes plus rapidement, MongoDB peut utiliser des opérateurs pour exécuter des fonctions spécifiques.
Les opérateurs sont des symboles spéciaux qui aident les compilateurs à effectuer des tâches mathématiques ou logiques. MongoDB propose plusieurs types d'opérateurs pour interagir avec la base de données.
Types d'opérateurs MongoDB
Il existe neuf types d'opérateurs, chacun nommé pour sa fonction. Par exemple, les opérateurs logiques utilisent des opérations logiques. Pour les exécuter, vous devez utiliser un mot-clé spécifique et suivre la syntaxe. Cependant, ils sont assez faciles à suivre!
À la fin de l'article, vous serez en mesure d'apprendre les bases de chaque opérateur et de ses fonctions.
Opérateurs logiques
Les opérateurs logiques sont souvent utilisés pour filtrer les données en fonction des conditions données. Ils permettent également l'évaluation de nombreuses conditions, dont nous parlerons plus en détail.
Voici quelques opérateurs logiques que vous pouvez utiliser :
$et
Une condition « et » effectue une opération « et » logique sur un tableau de deux expressions ou plus. Il sélectionne les documents où toutes les conditions des expressions sont satisfaites.
Voici la syntaxe standard de l'expression $and :
{ $and: [ { <expression1> }, { <expression2> }, ... , { <expressionN> } ] } Par exemple, si nous voulons sélectionner des documents dont le prix est de 10 $ et la quantité est inférieure à 15, nous pouvons saisir la requête suivante : db.inventory.find( { $and: [ { quantity: { $lt: 15 } }, { price: 10 } ] } )$ou
Une condition "ou" effectue une opération logique "ou" sur un tableau de deux expressions ou plus. Il sélectionne les documents où au moins une des expressions est vraie.
Voici la syntaxe standard de l'expression $or :
{ $or: [ { <expression1> }, { <expression2> }, ... , { <expressionN> } ] }.Par exemple, si nous voulons sélectionner des documents dont le prix est de 10 $ ou la quantité est inférieure à 15, nous pouvons saisir la requête suivante :
db.inventory.find( { $or: [ { quantity: { $lt: 15 } }, { price: 10 } ] } )Nous n'avons pas à limiter l'expression à deux critères — nous pouvons en ajouter d'autres. Par exemple, la requête ci-dessous sélectionne les documents dont le prix est égal à 10 $, la quantité est inférieure à 15 ou la balise est fixe :
db.inventory.find( { $or: [ { quantity: { $lt: 15 } }, { price: 10 }, { tag: stationary }] } ) Lors de l'exécution de ces clauses, MongoDB effectue soit une analyse de collection, soit une analyse d'index. Si tous les index prennent en charge les clauses, alors MongoDB utilise des index pour vérifier une expression $or . Sinon, il utilise une analyse de collection à la place.
Mais si vous souhaitez tester les critères dans le même champ, vous pouvez utiliser l'opérateur $in plutôt que l'opérateur $or . Par exemple, si vous souhaitez une collection de documents dont la quantité est de 10 ou 20, vous devrez peut-être exécuter la requête $in ci-dessous à la place :
db.inventory.find ( { quantity: { $in: [20, 50] } } ) Nous couvrirons plus sur l'opérateur $in plus tard.
$ni
Cet opérateur effectue une opération logique "nor" sur un tableau à l'aide d'une ou plusieurs expressions. Ensuite, il sélectionne les documents qui échouent aux expressions de requête. En termes plus simples, il fait le contraire de la condition $or .
Voici la syntaxe générale :
{ $nor: [ { <expression1> }, { <expression2> }, ... { <expressionN> } ] }Considérons la requête suivante :
db.inventory.find( { $nor: [ { price: 3.99 }, { sale: true } ] } )Cette requête sélectionne les documents qui contiennent :
- une valeur de champ de prix non égale à 3,99 $ et une valeur de vente non égale à vrai ; ou
- une valeur de champ de prix non égale à 3,99 $ et un champ de vente vide ou absent ; ou
- pas de champ de prix et un champ de vente non égal à vrai ; ou
- ni champ de prix ni champ de vente rempli ou présent.
$pas
Cet opérateur effectue une opération logique "non" sur un tableau pour l'expression spécifiée. Il sélectionne ensuite les documents qui ne correspondent pas aux expressions de la requête. Cela inclut les documents qui ne contiennent pas le champ.
Voici la syntaxe générale :
{ field: { $not: { <operator-expression> } } }Prenons par exemple la requête suivante :
db.inventory.find( { price: { $not: { $lt: 3.99 } } } )Cette requête sélectionnerait les documents qui contiennent :
- un champ de prix dont la valeur est supérieure ou égale à 3,99 $ ; et
- un champ de prix n'est pas renseigné ou n'existe pas.
Opérateurs de comparaison
Les opérateurs de comparaison peuvent être utilisés pour comparer des valeurs dans un ou plusieurs documents.
Vous trouverez ci-dessous un exemple de code d'une collecte d'inventaire simple pour un supermarché :
{ _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" ] }Nous utiliserons cet exemple tout en détaillant ensuite chaque opérateur de comparaison.
Égal à ($eq)
Cet opérateur correspond à des valeurs égales à la valeur donnée :
{ <field>: { $eq: <value> } }Par exemple, si nous voulons récupérer un document spécifique de la collection d'inventaire ayant la valeur de quantité exacte "20", nous saisirions la commande suivante :
db.inventory.find( { qty: { $eq: 20 } } )La requête renverrait ce qui suit :
{ _id: 2, item: { name: "banana", code: "123" }, qty: 20, tags: [ "B" ] }, { _id: 5, item: { name: "pears", code: "000" }, qty: 20, tags: [ [ "A", "B" ], "C" ] }Supérieur à ($gt)
Cet opérateur correspond si les valeurs sont supérieures à la valeur donnée :
{ field: { $gt: value } }Dans cet exemple, on récupère les documents dont la quantité est supérieure à 15 :
db.inventory.find({"qty": { $gt: 15}})La requête renverrait ce qui suit :
{ _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" ] }Moins de (lt $)
Cet opérateur correspond si les valeurs sont inférieures à la valeur fournie :
{ field: { $lt: value } }Trouvons les documents dont la quantité est inférieure à 25 :
db.inventory.find({"qty": { $lt: 25}})La requête renverrait ce qui suit :
{ _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" ] }Supérieur ou égal à ($gte)
Cet opérateur correspond lorsque les valeurs sont supérieures ou égales à la valeur donnée :
{ field: { $gte: value } }Dans cet exemple, on récupère les documents dont la quantité est supérieure ou égale à 25 :
db.inventory.find({"qty": { $gte: 25}})Cette requête renverrait ce qui suit :
{ _id: 3, item: { name: "spinach", code: "456" }, qty: 25, tags: [ "A", "B" ] } { _id: 4, item: { name: "lentils", code: "456" }, qty: 30, tags: [ "B", "A" ] }Inférieur ou égal à ($lte)
Cet opérateur correspond uniquement si les valeurs sont inférieures ou égales à la valeur donnée :
{ field: { $lte: value } }Cherchons les documents dont la quantité est inférieure ou égale à 25.
db.inventory.find({"qty": { $lte: 25}})Nous pouvons nous attendre à ce que cette requête renvoie les éléments suivants :
{ _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" ] }En (en $)
Cet opérateur renvoie les documents qui correspondent aux valeurs spécifiées :
{ field: { $in: [<value1>, <value2>, ... <valueN> ] } }La valeur d'un champ est égale à n'importe quelle valeur du tableau spécifié. Pour récupérer les documents avec les valeurs "30" et "15" dans la collection d'inventaire, par exemple, vous feriez ceci :
db.collection.find({ "qty": { $in: [30, 15]}})La sortie serait :
{ _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" ] } Pas dans ($nin)
Cet opérateur renvoie les documents qui ne correspondent pas aux valeurs données. Voici la syntaxe de base de l'opérateur $nin :
{ field: { $nin: [ <value1>, <value2> ... <valueN> ] $nin sélectionne les documents où :
- la valeur du champ n'est pas dans le tableau spécifié ; ou
- le terrain n'existe pas.
Si le champ contient des tableaux, il sélectionnera des tableaux où aucun élément spécifié dans la section valeur n'est présent. Par exemple, nous voulons sélectionner les documents dont la quantité n'est pas égale à 20 ou 15.
De plus, il correspond également aux documents qui n'ont pas de champ de quantité :
db.collection.find({ "qty": { $nin: [ 20, 15 ]}}, {_id: 0})La sortie serait :
{ _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" ] }Différent ($ne)
L'opérateur $ne renvoie les documents où la valeur spécifiée n'est pas égale :
{ $ne: value } }Par exemple, disons que nous voulons sélectionner tous les documents dont la quantité n'est pas égale à 20 :
db.inventory.find( { qty: { $ne: 20 } } )La sortie serait :
{ _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" ] }À partir de la sortie ci-dessus, nous pouvons voir que la requête sélectionnera les documents qui n'ont pas de champ de quantité.
Opérateurs d'élément
Les opérateurs de requête d'élément peuvent identifier des documents à l'aide des champs du document. Les opérateurs d'élément consistent en $exist et $type .
$existe
Cet opérateur correspond aux documents qui ont un champ spécifié. Cet opérateur a une valeur booléenne qui peut être true ou false .
S'il est spécifié comme étant true , il correspond aux documents qui contiennent ce champ, y compris les documents où la valeur du champ est null. Si <boolean> vaut false , la requête renvoie uniquement les documents qui ne contiennent pas le champ.
Voici la syntaxe standard :
{ field: { $exists: <boolean> } }Prenons un exemple où nous avons une collection de données pour un tableau nommé "bagofmarbles", où chaque sac contient des billes de différentes couleurs :
{ 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 } Disons que nous voulons une requête qui renverrait uniquement les sacs où les billes rouges existent. Cela signifie que nous devrons entrer la valeur booléenne comme true . Nous allons jeter un coup d'oeil:
db.bagofmarbles.find( { red: { $exists: true } } ) Les résultats seraient constitués des documents contenant le champ "rouge", même si la valeur était null . Cependant, il ne s'agirait pas des documents où le champ "rouge" n'existe même pas :
{ 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 }Si nous ne voulions que ces sacs où les billes rouges n'existent même pas en tant que champ, nous pouvons saisir la requête ci-dessous :
db.bagofmarbles.find( { red: { $exists: false} }Les résultats seraient constitués des documents qui ne contiennent pas le champ « rouge » :
{ green: 2, blue: 4 } { green: 2 } { blue: 6 }$type
Cet opérateur fait correspondre les documents en fonction du type de champ spécifié. Ceci est utile lorsque vous disposez de données hautement non structurées ou lorsque les types de données ne sont pas prévisibles. Ces types de champ sont des types BSON spécifiés et peuvent être définis soit par numéro de type, soit par alias.
C'est la syntaxe générale pour $type :
{ field: { $type: <BSON type> } }Disons que nous avons un carnet d'adresses contenant les documents ci-dessous :
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" ] } ] }En observant les documents ci-dessus, le code postal a différents types de données. Cela inclut les valeurs longues, doubles, entières et de chaîne.
Si nous ne voulons que les documents qui ont un type de données spécifié comme code postal — prenons une chaîne pour cette instance — nous devrons entrer la requête suivante dans le compilateur :
db.addressBook.find({ "zipCode": { $type: "string" } })Cela renverrait les documents suivants :
[ { "_id": 1, "address": "2100 Jupiter Spot", "zipCode": "9036325" }, { "_id": 5, "address": "1044 Venus Lane", "zipCode": [ "99883637232", "73488976234" ] } ] De plus, il existe un type "nombre", qui inclut toutes les valeurs longues, entières ou doubles sous la forme d'un tableau contenant un élément des types spécifiés :
db.addressBook.find( { "zipCode" : { $type : "number" } } )Production:
[ { "_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) } ] Si les documents ont un champ de type tableau, l'opérateur $type renvoie les documents dans lesquels au moins un élément du tableau correspond au type passé à l'opérateur.
Opérateurs de tableau
MongoDB se compose également d'opérateurs de tableau, pour interroger les documents contenant des tableaux.
Il existe trois opérateurs principaux : $all , $elemMatch et $size . Nous discuterons de chacun en détail ci-dessous.
$tout
L'opérateur $all choisit les documents dans lesquels la valeur d'un champ est un tableau contenant les éléments spécifiés :
{ : { $all: [ <value1> , <value2> ... ] } }Par exemple, supposons que nous ayons une collection de documents pour un magasin de vêtements, avec les éléments suivants en inventaire.
{ _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" } ] } Nous voudrions récupérer tous les documents (dans ce cas, les vêtements) de l'inventaire qui sont liés aux balises "tendance" et "y2k". La requête ci-dessous utilise l'opérateur $all où la valeur du champ tags est un tableau dont les éléments incluent "y2k" et "trendy":
db.inventory.find( { tags: { $all: [ "y2k", "trendy" ] } } )La requête ci-dessus renvoie ce qui suit :
{ _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" } ] } Dans l'exemple ci-dessus, nous constatons également que l'opérateur $all remplit simplement la même fonction que l'opération $and .
Alternativement, nous pourrions utiliser la requête ci-dessous qui donnerait un résultat similaire à ce qui précède :
db.collection.find({ $and: [ { tags: "y2k" }, { tags: "trendy" } ] }) $elemMatch
L'opérateur $elemMatch correspondre les documents qui contiennent un champ de tableau avec au moins un élément qui correspond à tous les critères de requête spécifiés :
{ : { $elemMatch: { <query1>, <query2>, ... } } } Bien que nous puissions utiliser des opérateurs de comparaison comme $lte et $gte , si nous ne spécifions qu'une seule condition de requête dans $elemMatch et que nous n'utilisons pas les opérateurs $not ou $ne , l'utilisation $elemMatch peut être omise car elle serait essentiellement performante la même fonction.
Il y a quelques autres choses à garder à l'esprit lors de l'utilisation de cet opérateur, principalement :
- Vous ne pouvez pas spécifier une expression
$wheredans une opération$elemMatch. - Vous ne pouvez pas spécifier une expression de requête
$textdans une opération$elemMatch.
Par exemple, nous avons les documents suivants dans la collection des résultats des élèves :
{ _id: 1, results: [ 92, 89, 98 ] } { _id: 2, results: [ 85, 99, 99 ] }La requête suivante correspond uniquement aux documents dont le tableau de résultats contient au moins un élément supérieur ou égal à 90 et inférieur à 95 :
db.studentresults.find( { results: { $elemMatch: { $gte: 90, $lt: 95 } } })Notre requête renvoie le document suivant, puisque l'élément 92 est à la fois supérieur ou égal à 90 et inférieur à 95 :
{ "_id" : 1, "results" :[ 92, 89, 98 ] }$taille
L'opérateur $size renvoie les documents dont la taille du tableau correspond au nombre d'éléments spécifiés dans l'argument :
{ field: { $size: value } }Voici un exemple :
db.collection.find( { field: { $size: 2 } }); Cela renverrait tous les documents dans la collection spécifiée où le champ est un tableau avec 2 éléments : { field: [ orange, apple] } et { field: [ blue, red] } , mais pas { field: blue} ou { field: [ raspberry, lemon, grapefruit ] } .
Cependant, bien que nous puissions entrer la valeur spécifique comme taille, nous ne pouvons pas spécifier de plages de valeurs comme taille.
Opérateurs géospatiaux
MongoDB vous permet de stocker des données géospatiales sous la forme de types GeoJSON. GeoJSON est un format standard ouvert basé sur la notation d'objet JavaScript qui peut représenter des caractéristiques géographiques et prendre en charge des attributs non spatiaux. Il existe deux types d'opérateurs géospatiaux dont nous parlerons dans cet article : les spécificateurs de géométrie et les sélecteurs de requête.
$géométrie
Cet opérateur mentionne la géométrie GeoJSON à utiliser avec les opérateurs de requête géospatiale suivants : $geoIntersects , $geoWithin , $nearSphere et $near . $geometry utilise EPSG:4326 comme système de référence de coordonnées (CRS) par défaut.
Pour mentionner les objets GeoJSON avec le CRS par défaut, vous pouvez utiliser l'extrait suivant pour $geometry :
$geometry: { type: "<GeoJSON object type>", coordinates: [ <coordinates> ] } Pour mentionner un polygone GeoJSON à anneau unique avec un CRS MongoDB personnalisé, vous pouvez utiliser l'extrait de code suivant (vous ne pouvez l'utiliser que pour $geoWithin et $geoIntersects ):
$geometry: { type: "Polygon", coordinates: [ <coordinates> ], crs: { type: "name", properties: { name: "urn:x-mongodb:crs:strictwinding:EPSG:4326" } } }$polygone
L'opérateur $polygon peut être utilisé pour spécifier un polygone pour une requête géospatiale $geoWithin sur des paires de coordonnées héritées. Cette requête renverra ensuite les paires qui se situent dans les limites du polygone. Cependant, $polygon n'interrogera aucun objet GeoJSON. Pour définir un polygone, vous devez spécifier un tableau de points de coordonnées comme suit :
{ : { $geoWithin: { $polygon: [ [ <x1> , <y1> ], [ <x2> , <y2> ], [ <x3> , <y3> ], ... ] } } }Ici, le dernier point est implicitement lié au premier. Vous pouvez mentionner autant de points ou de côtés que vous le souhaitez.
Par exemple, la requête suivante renverra tous les documents dont les coordonnées existent dans le polygone défini par [0,0], [1,5] et [3,3] :
db.places.find( { loc: { $geoWithin: { $polygon: [ [ 0 , 0 ], [ 1 , 5 ], [ 3 , 3 ] ] } } } )$geoWithin
Cet opérateur peut être utilisé pour sélectionner des documents avec des données géospatiales entièrement contenues dans une forme spécifique. La forme spécifiée peut être soit un multipolygone GeoJSON, soit un polygone GeoJSON (à anneaux multiples ou à anneau unique), soit une forme qui peut être définie par des paires de coordonnées héritées.
L'opérateur $geoWithin tirera parti de l'opérateur $geometry pour mentionner l'objet GeoJSON.
Pour mentionner les multipolygones ou polygones GeoJSON via le système de référence de coordonnées (CRS) par défaut, vous pouvez utiliser la syntaxe mentionnée ci-dessous :
{ : { $geoWithin: { $geometry: { type: <"Polygon" or "MultiPolygon"> , coordinates: [ <coordinates> ] } } } } Pour les requêtes $geoWithin qui mentionnent les géométries GeoJSON avec des zones plus grandes qu'un seul hémisphère, l'utilisation du CRS par défaut conduirait à des requêtes pour les géométries complémentaires.
Pour mentionner un polygone GeoJSON à anneau unique avec un CRS MongoDB personnalisé, vous pouvez tirer parti du prototype mentionné ci-dessous dans l'expression $geometry :
{ : { $geoWithin: { $geometry: { type: "Polygon" , coordinates: [ <coordinates> ], crs: { type: "name", properties: { name: "urn:x-mongodb:crs:strictwinding:EPSG:4326" } } } } } }L'exemple suivant sélectionne toutes les données de localisation qui existent complètement dans un polygone GeoJSON, la surface du polygone étant inférieure à la surface d'un seul hémisphère :
db.places.find( { loc: { $geoWithin: { $geometry: { type : "Polygon" , coordinates: [ [ [ 0, 0 ], [ 3, 6 ], [ 6, 1 ], [ 0, 0 ] ] ] } } } } )$box
Vous pouvez utiliser $box pour spécifier un rectangle pour une requête géospatiale $geoWithin afin de fournir des documents qui se trouvent dans les limites du rectangle, en fonction de leurs données de localisation basées sur des points. Lorsque vous utilisez $geoWithin avec la $box , vous obtenez des documents basés sur les coordonnées de la requête. Dans ce scénario, $geoWithin aucune forme GeoJSON.
Pour tirer parti de l'opérateur $box , vous devez mentionner les coins supérieur droit et inférieur gauche du rectangle dans un objet tableau :
{ <location field> : { $geoWithin: { $box: [ [ <bottom left coordinates> ], [ <upper right coordinates> ] ] } } }La requête susmentionnée calculera la distance en utilisant une géométrie plane (plate). La requête suivante renverra tous les documents qui se trouvent dans la boîte ayant des points à : [0,0], [0,30], [30,0], [30,30] :
db.places.find ( { loc: { $geoWithin: { $box: [ [ 0,0 ], [ 30,30 ] ] } } } )$nearSphere
Vous pouvez utiliser $nearSphere pour mentionner un point pour lequel une requête géospatiale renvoie les documents du plus proche au plus éloigné.
MongoDB utilise la géométrie sphérique pour calculer les distances pour $nearSphere . Il aura besoin d'un index géospatial comme suit :
- Index 2d pour les données de localisation décrites comme des paires de coordonnées héritées. Pour tirer parti d'un index 2D sur des points GeoJSON, vous devez générer l'index sur le champ de coordonnées de l'objet GeoJSON.
- Index 2dsphere pour les données de localisation décrites comme des points GeoJSON.
Pour mentionner un point GeoJSON, vous pouvez utiliser la syntaxe suivante :
{ $nearSphere: { $geometry: { type : "Point", coordinates : [ <longitude>, <latitude> ] }, $minDistance: <distance in meters>, $maxDistance: <distance in meters> } } Ici, $minDistance et $maxDistance sont facultatifs. $minDistance peut limiter les résultats aux documents qui sont au moins à la distance spécifiée du centre. Vous pouvez utiliser $maxDistance pour l'un ou l'autre index.
Considérons maintenant une collection de « lieux » qui se compose de documents avec un champ d'emplacement qui a un index 2dsphere. L'exemple suivant renverrait les points dont l'emplacement est au moins à 2 000 mètres et au plus à 6 000 mètres du point que vous choisissez, classés du plus proche au plus éloigné :
db.places.find( { location: { $nearSphere: { $geometry: { type : "Point", coordinates : [ -43.9532, 50.32 ] }, $minDistance: 2000, $maxDistance: 6000 } } } )$geoIntersections
L'opérateur $geoIntersects vous permet de sélectionner des documents dont les données géospatiales croisent un objet GeoJSON particulier (c'est-à-dire où la convergence de l'objet spécifié et des données n'est pas vide). Il exploite l'opérateur $geometry pour spécifier l'objet GeoJSON.
Pour mentionner les multipolygones ou polygones GeoJSON via le système de référence de coordonnées (CRS) par défaut, vous pouvez utiliser la syntaxe suivante :
{ <location field>: { $geoIntersects: { $geometry: { type: "<GeoJSON object type>" , coordinates: [ <coordinates> ] } } } } L'instance suivante utilisera $geoIntersects pour sélectionner toutes les données de localisation qui croisent le polygone décrit par le tableau de coordonnées :
db.places.find( { loc: { $geoIntersects: { $geometry: { type: "Polygon" , coordinates: [ [ [ 0, 0 ], [ 2, 6 ], [ 4, 1 ], [ 0, 0 ] ] ] } } } } )$centre
L'opérateur $center mentionne un cercle pour une requête $geoWithin qui renvoie des paires de coordonnées héritées qui se trouvent dans les limites du cercle.
$center ne renvoie pas les objets GeoJSON. Pour tirer parti de l'opérateur $center , vous devez spécifier un tableau contenant :
- Le rayon du cercle, tel que mesuré dans les unités utilisées par le système de coordonnées.
- Les coordonnées de grille du point central du cercle.
{ <location field> : { $geoWithin: { $center: [ [ <x> , <y> ] , <radius> ] } } }L'exemple mentionné ci-dessous renverra tous les documents dont les coordonnées se trouvent dans le cercle centré sur [2,3] et de rayon 40 :
db.places.find( { loc: { $geoWithin: { $center: [ [2, 3], 40 ] } } } )Opérateurs de projection
Vous pouvez utiliser des opérateurs de projection pour mentionner les champs renvoyés par une opération. Les opérateurs de projection MongoDB permettent d'utiliser la fonction find() avec des arguments de filtrage de données. Cela aide les utilisateurs à extraire uniquement les champs de données requis d'un document. Ainsi, il vous permet de projeter des données transparentes et concises sans affecter les performances globales de la base de données.
$elemMatch (projection)
L'opérateur $elemMatch est chargé de limiter le contenu d'un champ à partir des résultats de la requête pour qu'il ne contienne que le premier élément correspondant à la condition $elemMatch .
Voici quelques éléments que vous devez garder à l'esprit avant d'utiliser $elemMatch :
- Depuis MongoDB 4.4, quel que soit l'ordre des champs dans le document, la projection
$elemMatchd'un champ existant renvoie le champ suite à l'inclusion d'autres champs existants. - Les opérateurs
$elemMatchet$décrivent le premier élément correspondant d'un tableau en fonction d'une condition spécifiée. L'opérateur$projetterait le premier élément de tableau correspondant de chaque document d'une collection en fonction d'une condition de l'instruction de requête, tandis que l'opérateur de projection$elemMatchprend un argument de condition explicite. Cela vous permet de projeter en fonction d'une condition non présente dans la requête, ou si vous avez besoin de projeter en fonction de divers champs dans les documents intégrés du tableau.
Vous devez également connaître les restrictions suivantes avant d'utiliser l'opérateur $elemMatch sur vos données :
- Vous ne pouvez pas mentionner une expression de requête
$textdans un opérateur$elemMatch. - Les opérations
db.collection.find()sur les vues ne prennent pas en charge l'opérateur de projection$elemMatch.
L'exemple suivant sur l'opérateur de projection $elemMatch suppose une collection d' schools avec les documents suivants :
{ _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 }, ] } Dans ce cas, l'opération find() interroge tous les documents où la valeur du champ code postal est 63110. La projection $elemMatch renverrait uniquement le premier élément correspondant du tableau des students où le champ school a une valeur 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 } ] }$tranche (projection)
L'opérateur de projection $slice peut être utilisé pour spécifier le nombre d'éléments d'un tableau à renvoyer dans le résultat de la requête :
db.collection.find( <query> , { <arrayField> : { $slice: <number> } } );Il peut aussi s'exprimer ainsi :
db.collection.find( <query> , { <arrayField> : { $slice: [ <number> , <number> ] } } );Pour démontrer la même chose, vous pouvez créer un exemple de collection de tweets avec les documents suivants :
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'opération suivante utiliserait l'opérateur de projection $slice sur le tableau tweets pour renvoyer le tableau avec ses deux premiers éléments. Si un tableau contient moins de deux éléments, tous les éléments du tableau sont renvoyés :
db.posts.find( {}, { comments: { $slice: 2 } } )Cette opération renverrait les documents suivants :
{ "_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" } ] }$ (projection)
L'opérateur positionnel $ limite le contenu d'un tableau pour renvoyer le premier élément qui correspond à la condition de requête de ce tableau. Vous pouvez utiliser $ dans le document de projection de la méthode find() ou de la méthode findOne() lorsque vous n'avez besoin que d'un seul élément de tableau particulier dans les documents choisis.
Voici à quoi ressemble la syntaxe de l'opérateur $ :
db.collection.find( { <array>: <condition> ... }, { "<array>.$": 1 } ) db.collection.find( { <array.field>: <condition> ...}, { "<array>.$": 1 } ) Dans cet exemple, la collection des students se compose des documents suivants :
{ "_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 ] } Dans la requête suivante, la projection { "grades.$": 1 } renvoie uniquement le premier élément supérieur ou égal à 89 pour le champ grades :
db.students.find( { semester: 2, grades: { $gte: 89 } }, { "grades.$": 1 } )Cette opération renvoie les documents suivants :
{"_id": 3, "grades": [95] }Opérateurs d'évaluation
Vous pouvez tirer parti des opérateurs d'évaluation MongoDB pour évaluer la structure globale des données ou un champ individuel dans un document.
Examinons quelques opérateurs d'évaluation MongoDB courants.
$ mod
Vous pouvez utiliser cet opérateur pour faire correspondre les documents où la valeur d'un champ spécifié est égale au reste après avoir été divisé par une valeur spécifiée :
{ field: { $mod: [ divisor, remainder ] } }Disons que vous avez un tableau de voitures appartenant à différentes marques que vous possédez dans votre showroom. La requête suivante vous donnerait toutes les marques de voitures dont les numéros de stock sont en multiples de 250.
db.cars.find ( { qty: { $mod: [ 250,0 ] } } )$jsonSchema
Le $jsonSchema vous permet de faire correspondre les documents qui correspondent au schéma JSON spécifié. L'implémentation du schéma JSON par MongoDB inclut l'ajout du mot-clé bsonType , qui vous permet d'utiliser tous les types BSON dans l'opérateur $jsonSchema .
bsonType peut accepter les mêmes alias de chaîne que vous utiliseriez pour l'opérateur de type . Voici à quoi ressemblerait la syntaxe $jsonSchema :
{ $jsonSchema: <JSON Schema object> }Ici, l'objet de schéma JSON est formaté en fonction de la version préliminaire 4 de la norme de schéma JSON :
{ <keyword1>: <value1>, ... } Voici un exemple pour illustrer le fonctionnement $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" } } } } } } Vous pouvez également utiliser $jsonSchema dans un validateur de document pour appliquer le schéma spécifié lors des opérations de mise à jour et d'insertion :
db.createCollection(<collection> , { validator: { $jsonSchema: <schema> } } ) db.runCommand( { collMod: <collection>, validator:{ $jsonSchema: <schema> } } ) Gardez à l'esprit qu'il y a plusieurs choses qui ne sont pas prises en charge par l'opérateur $jsonSchema :
- Le type entier. Vous devez exploiter le type BSON long ou int avec le mot-clé bsonType.
- Mots clés inconnus.
- Liaison des propriétés et de l'hypermédia du schéma JSON, ainsi que l'utilisation de références JSON et de pointeurs JSON.
$texte
L'opérateur $text rechercherait un texte dans le contenu du champ spécifié, indexé avec un index de texte :
{ $text: { $search: <string>, $language: <string>, $caseSensitive: <boolean>, $diacriticSensitive: <boolean> } }Dans ce cas, l'extrait de code suivant passera au crible le tableau pour filtrer toutes les voitures contenant le texte "Porsche" :
db.cars.find( { $text: { $search: "Porsche" } } )$regex
L'opérateur $regex offre des capacités d'expression régulière pour faire correspondre les chaînes dans les requêtes. MongoDB utilise des expressions régulières compatibles avec Perl :
{<field> : /pattern/ <options>}L'exemple suivant aiderait à filtrer toutes les voitures contenant la chaîne "$78900" :
db.cars.find( { price: { $regex: /$78900/ } } )$expr
L'opérateur $expr vous permet d'exploiter les expressions d'agrégation dans le langage de requête :
{ $expr: { <expression> } } Vous pouvez également utiliser $expr pour créer des expressions de requête qui comparent les champs du même document dans une étape $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
$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> , ... ] } } La valeur du champ doit être soit une instance BinData, soit une valeur numérique pour que $bitsAllSet corresponde au document actuel.
Dans l'exemple suivant, nous exploitons une collection avec les documents suivants :
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 requête mentionnée ci-dessous utilisera l'opérateur $bitsAllSet pour tester si le champ a a des bits définis à la position 1 et à la position 5, où le bit le moins significatif serait à la position 0 :
db.collection.find( { a: { $bitsAllSet: [ 1, 5 ] } }Cette requête correspondrait aux documents suivants :
{ "_id" : 1, "a" : 54, "binaryValueofA" : "00110110" } { "_id" : 4, "a" : BinData(0,"Zg=="), "binaryValueofA" : "01100110" }$bitsAllClear
L'opérateur $bitsAllClear correspondra aux documents dans lesquels toutes les positions de bit fournies par la requête sont claires ou 0 :
{ <field> : { $bitsAllClear: <numeric bitmask> } } { <field> : { $bitsAllClear: < BinData bitmask> } } { <field> : { $bitsAllClear: [ <position1> , <position2> , ... ] } } Nous utiliserons ici l'exemple utilisé pour $bitsAllSet pour démontrer l'utilisation de $bitsAllClear . La requête suivante utiliserait cet opérateur pour vérifier si le champ a a les bits effacés aux positions 1 et 5 :
db.collection.find( { a: { $bitsAllClear: [ 1, 5 ] } } )Cette requête correspondrait aux documents suivants :
{ "_id" : 2, "a" : 20, "binaryValueofA" : "00010100" } { "_id" : 3, "a" : 20, "binaryValueofA" : "00010100" }Méta-opérateurs
Il existe différents modificateurs de requête qui vous permettent de modifier le comportement ou la sortie d'une requête dans MongoDB. Les interfaces de pilote peuvent fournir des méthodes de curseur qui les encapsulent pour votre usage.
$indice
MongoDB a déprécié $hint depuis la v3.2. Mais cet opérateur peut toujours être disponible pour les pilotes MongoDB tels que Go, Java, Scala, Ruby, Swift, etc. Il peut forcer l'optimiseur de requête à exploiter un index spécifique pour répondre à la requête, qui peut ensuite être mentionnée soit par document, soit par nom de l'index.
Vous pouvez également utiliser l'opérateur $hint pour tester les stratégies d'indexation et les performances des requêtes. Prenons par exemple l'opération suivante :
db.users.find().hint( { age: 1 } ) Cette opération renverrait tous les documents de la collection appelés users en tirant parti de l'index sur le champ d' age .
Vous pouvez également mentionner un indice en utilisant l'un des formulaires suivants :
db.users.find()._addSpecial( "$hint", { age : 1 } ) db.users.find( { $query: {}, $hint: { age : 1 } } ) Si un filtre d'index existe pour la forme de la requête, MongoDB ignorera simplement le $hint .
$commentaire
L'opérateur $comment vous permet de joindre un commentaire à une requête dans n'importe quel contexte dans lequel $query peut apparaître. Étant donné que les commentaires se propagent dans le journal de profil, l'ajout d'un commentaire peut faciliter l'interprétation et le suivi de votre profil.
Vous pouvez tirer parti $comment de l'une des trois manières suivantes :
db.collection.find( { <query> } )._addSpecial( "$comment", <comment> ) db.collection.find( { <query> } ).comment( <comment> ) db.collection.find( { $query: { <query> }, $comment: <comment> } ) Si vous souhaitez joindre des commentaires aux expressions de requête dans d'autres contextes, comme avec db.collection.update() , utilisez l'opérateur de requête $comment au lieu du méta-opérateur.
$max
Vous pouvez mentionner une valeur $max pour spécifier la limite supérieure exclusive d'un index particulier afin de contraindre les résultats de find() . Cet opérateur spécifiera la limite supérieure pour toutes les clés d'un ordre spécifique dans l'index.
Mongosh vous donne la méthode wrapper max() suivante :
db.collection.find( { <query> } ).max( { field1: <max value> , ... fieldN: <max valueN> } ) Vous pouvez également mentionner $max avec les deux formes suivantes :
db.collection.find( { <query> } )._addSpecial( "$max", { field1: <max value1> , ... fieldN: <max valueN> } ) db.collection.find( { $query: { <query> }, $max: { field1: <max value1> , ... fieldN: <max valueN> } } ) Par exemple, si vous souhaitez spécifier la limite supérieure exclusive, gardez à l'esprit les opérations suivantes sur une collection nommée collection qui contient un index { age: 1 } :
db.collection.find( { <query> } ).max( { age: 100 } ).hint( { age: 1 } ) Cette opération limitera la requête aux documents dont le champ age est inférieur à 100 et force un plan de requête qui analysera l'index { age: 1 } de minKey à 100.
$expliquer
Cet opérateur vous donnera des informations sur le plan de requête. Il renvoie un document qui décrit les index et les processus utilisés pour renvoyer la requête. Cela peut être utile lorsque vous essayez d'optimiser une requête.
Vous pouvez mentionner l'opérateur $explain sous l'une des formes suivantes :
db.collection.find()._addSpecial( "$explain", 1 ) db.collection.find( { $query: {}, $explain: 1 } )Meilleures pratiques pour les opérateurs MongoDB
Dans cette section, nous examinerons certaines des meilleures pratiques lors de l'utilisation de ces opérateurs MongoDB.
Intégration et référencement
L'intégration est une extension naturelle de la modélisation des données. Cela vous permet d'éviter les jointures d'applications, ce qui peut réduire les mises à jour et les requêtes.
Vous pouvez intégrer des données avec une relation 1:1 dans un seul document. Cela dit, les données avec une relation plusieurs:1 dans laquelle « plusieurs » objets apparaissent avec leurs documents parents peuvent également être de bons candidats.
Stocker ces types de données dans le même document semble être un choix prudent. Cependant, l'intégration offre de meilleures performances pour les opérations de lecture avec ce type de localité des données.
Les modèles de données intégrés peuvent également aider les développeurs à mettre à jour les données associées en une seule opération d'écriture. Cela fonctionne car les écritures de document unique sont transactionnelles.
Vous devriez envisager d'utiliser le référencement pour les scénarios suivants :
- Lorsque vous mettez à jour un segment de document et qu'il ne cesse de s'allonger, alors que le reste du document est statique.
- Lorsqu'un document est consulté mais contient des données rarement utilisées. L'intégration ne ferait qu'augmenter les besoins en mémoire, donc le référencement a plus de sens.
- Lorsque la taille du document dépasse la limite de 16 Mo de MongoDB. Cela peut se produire lors de la modélisation de relations many:1 (par exemple, employee:department ).
Examiner le profilage et les modèles de requête
Pour la plupart des développeurs, la première étape de l'optimisation des performances consiste à comprendre les modèles de requête réels et attendus. Une fois que vous connaissez suffisamment bien les modèles de requête de votre application, vous pouvez créer votre modèle de données et choisir les index appropriés.
Les développeurs MongoDB ont accès à divers outils puissants qui leur permettent d'améliorer les performances. Mais cela ne signifie pas que les profils et les modèles de requête peuvent être ignorés.
Par exemple, un moyen simple d'améliorer les performances consiste à analyser vos modèles de requête et à comprendre où vous pouvez intégrer des données. D'autres moyens de renforcer les performances de MongoDB après avoir identifié vos principaux modèles de requête incluent :
- Assurez-vous que vous avez des index sur tous les champs sur lesquels vous interrogez.
- Stockage des résultats des sous-requêtes fréquentes sur les documents pour réduire la charge de lecture.
- Examinez vos journaux pour examiner les requêtes lentes, puis vérifiez vos index.
Examiner l'indexation et la modélisation des données
Lors de la création de votre modèle de données, vous déciderez comment modéliser les relations entre les données. Choisir quand incorporer un document plutôt que créer une référence dans des documents séparés dans différentes collections, par exemple, est un exemple de considération spécifique à l'application.
Un avantage majeur des documents JSON est qu'ils permettent aux développeurs de modéliser les données en fonction des exigences de l'application. L'imbrication de sous-documents et de tableaux vous aide à modéliser des relations complexes entre les données en tirant parti de documents texte simples.
Vous pouvez également utiliser MongoDB pour modéliser les éléments suivants :
- Données géospatiales
- Structures tabulaires, plates et colonnaires
- Paires clé-valeur simples
- Données de séries chronologiques
- Bords et nœuds de structures de données de graphes connectés et similaires
Surveiller le partage et la réplication
La réplication peut être essentielle à l'amélioration des performances, car elle augmente la disponibilité des données grâce à une mise à l'échelle horizontale. La réplication peut conduire à de meilleures performances et à plus de sécurité grâce à la redondance.
La surveillance des performances peut être un problème nécessitant des ressources et du temps supplémentaires pour assurer un fonctionnement fluide. Vous pouvez tirer parti des outils de surveillance des performances disponibles sur le marché qui répondent à vos besoins spécifiques.
Par exemple, Kinsta APM peut récupérer des informations horodatées sur les requêtes de base de données MySQL de votre site WordPress, les processus PHP, les appels HTTP externes, et bien plus encore. Vous pouvez également utiliser cet outil gratuit pour déboguer :
- Appels API longs
- Demandes d'URL externes longues
- Requêtes de base de données lentes pour n'en nommer que quelques-unes.
Dans MongoDB, la réplication peut être réalisée via des jeux de répliques qui permettent aux développeurs de copier les données d'un nœud ou d'un serveur principal sur plusieurs serveurs secondaires. Cela permet à votre réplication d'exécuter certaines requêtes sur les secondaires plutôt que sur le principal, évitant ainsi les conflits et conduisant à un meilleur équilibrage de charge.
Les clusters partagés dans MongoDB sont un autre moyen d'améliorer potentiellement les performances. Semblable à la réplication, le partitionnement peut être utilisé pour distribuer de grands ensembles de données sur plusieurs serveurs.
En exploitant une clé de partition, les développeurs peuvent copier des fragments ou des éléments de données sur plusieurs serveurs. Ces serveurs peuvent travailler ensemble pour utiliser toutes les données.
Le sharding a sa juste part d'avantages, notamment la mise à l'échelle horizontale pour les écritures/lectures, une plus grande disponibilité et une capacité de stockage accrue.
Déterminer l'utilisation de la mémoire
MongoDB fonctionne mieux lorsque l'ensemble de travail d'une application (c'est-à-dire les données et les index fréquemment consultés) tient en mémoire sans problème. Alors que d'autres facteurs sont essentiels pour les performances, la taille de la RAM est le plus important pour le dimensionnement des instances.
Lorsque le jeu de travail d'une application tient dans la RAM, l'activité de lecture à partir du disque doit être faible. Mais si votre ensemble de travail dépasse la RAM du serveur d'instance ou sa taille, l'activité de lecture commencera à augmenter.
Si vous constatez que cela se produit, vous pourrez peut-être résoudre le problème en passant à une instance plus grande qui dispose de plus de mémoire.
Placer les champs multi-valeurs à la fin
Si vous indexez quelques champs et que l'un des champs que vous souhaitez interroger utilise l'un de ces opérateurs "multi-valeurs", vous devez les placer à la fin de l'index. Vous devez ordonner l'index de sorte que les champs interrogés pour les valeurs exactes viennent en premier et que les opérateurs "multi-valeurs" apparaissent en dernier dans l'index.
Une exception à cette règle serait le tri selon les champs. Placez-les entre les champs "multi-valeurs" et exacts pour réduire la quantité de tri en mémoire nécessaire.
Sommaire
Pour MongoDB, la vitesse est le nom du jeu. Pour renvoyer rapidement les requêtes, MongoDB utilise des opérateurs pour exécuter des tâches mathématiques ou logiques. En termes simples, comprendre les opérateurs MongoDB est la clé pour maîtriser MongoDB.
Cet article a mis en évidence certains des principaux opérateurs MongoDB que vous pouvez utiliser sur vos données, tels que les opérateurs de comparaison, les opérateurs logiques, les méta-opérateurs et les opérateurs de projection, pour n'en nommer que quelques-uns. Il vous aide également à comprendre comment vous pouvez utiliser les opérateurs MongoDB et les meilleures pratiques qui vous permettront d'en tirer le meilleur parti.
Parmi tous les opérateurs, lequel(s) utilisez-vous le plus souvent et pourquoi ? Partagez dans les commentaires ci-dessous - nous aimerions entendre vos pensées!