Opérateurs conditionnels MongoDB spécifier une condition à laquelle la valeur du champ document doit correspondre.
Opérateurs de requête de comparaison
- $eq (égal)
- $ne (pas égal)
- $gt (plus de)
- $lt (moins de)
- $gte (plus ou égal)
- $lte (inférieur ou égal)
- en $ définit un tableau de valeurs, dont l'une doit avoir un champ de document
- neuf $ définit un tableau de valeurs qui ne doivent pas avoir de champ de document
Par exemple, nous trouverons tous les documents dont la valeur de clé d'âge est inférieure à 30 :
db.users.find ({age: {$lt : 30}})
L'utilisation d'autres opérateurs de comparaison sera similaire. Par exemple, la même clé, seulement plus de 30 :
db.users.find ({age: {$gt : 30}})
Notez que la comparaison ici est faite sur des types entiers, pas sur des chaînes. Si l'âge de la clé représente des valeurs de chaîne, la comparaison doit être effectuée sur les lignes :db.users.find ({age :{$gt :"30"}}), mais le résultat sera le même.
Mais imaginons une situation où nous devons trouver tous les volumes avec une valeur de champ âge supérieure à 30 mais inférieure à 50. Dans ce cas, nous pouvons combiner deux opérateurs :
db.users.find ({age: {$gt : 30, $lt: 50}})
Nous trouverons des utilisateurs dont l'âge est de 22 ans :
db.users.find ({age: {$eq : 22}})
En gros, c'est l'analogie de la requête suivante :
db.users.find ({age: 22})
Opération inverse - trouver des utilisateurs dont l'âge n'est PAS de 22 ans :
db.users.find ({age: {$ne : 22}})
L'opérateur $in définit un tableau d'expressions possibles et recherche les clés dont la valeur se trouve dans le tableau :
db.users.find ({age: {$in : [22, 32]}})
A l'inverse, l'opérateur $nin définit un tableau d'expressions possibles et recherche les clés dont la valeur est absente de ce tableau :
db.users.find ({âge :{$nin :[22, 32]}})
Opérateurs logiques
Les opérateurs logiques sont exécutés sur des conditions d'échantillonnage :
- $ou :relie deux conditions, et le document doit répondre à l'une de ces conditions
- $et : relie deux conditions, et le document doit remplir les deux conditions
- $pas : le document ne doit PAS correspondre à la condition
- $nor : relie deux conditions, et le document ne doit PAS remplir les deux conditions
Exemples d'opérateurs MongoDB
L'opérateur $ou représente une opération OU logique et définit un ensemble de paires clé-valeur qui doivent être présentes dans un document. Et si un document possède au moins une telle paire clé-valeur, elle correspond à cette requête et est extraite de la base de données :
db.users.find ({$or : [{name: "Tom"}, {age: 22}]})
Cette expression renverra tous les documents avec name=Tom ou age=22.
Un autre exemple renverra tous les documents avec soit name=Tom et age=22 ou avec "german" parmi les valeurs de langue :
db.users.find ({name: "Tom", $or : [{age: 22}, {languages: "german"}]})
Les opérateurs conditionnels peuvent être utilisés dans des sous-expressions ou des sous-expressions :
db.users.find ({$or : [{name: "Tom"}, {age: {$gte:30}}]})
Dans ce cas, nous sélectionnons tous les documents où name="Tom" ou le champ age a une valeur de 30 ou plus.
Opérateur $et
L'opérateur $et représente une opération logique ET (multiplication logique) et définit un ensemble de critères qu'un document doit respecter. Contrairement à l'opérateur $ou, le document doit répondre à tous les critères spécifiés. Par exemple :
db.users.find ({$and : [{name: "Tom"}, {age: 32}]})
Ici, les documents sélectionnés doivent porter le nom de Tom et avoir 32 ans - ces deux caractéristiques.
Recherche de tableau MongoDB
Certains opérateurs sont conçus pour fonctionner avec des tableaux :
- $tout : définit un ensemble de valeurs qui doivent exister dans un tableau
- $size : définit le nombre d'éléments qui doivent être dans un tableau
- $elemMatch : spécifie la condition à laquelle les éléments du tableau doivent correspondre
MongoDB $all
L'opérateur $all définit un tableau d'expressions possibles et nécessite que les documents contiennent l'ensemble complet d'expressions défini. En conséquence, il est utilisé pour rechercher le tableau. Par exemple, les documents ont un tableau de langues qui stocke les langues étrangères parlées par l'utilisateur. Et pour trouver toutes les personnes qui parlent à la fois anglais et français, on peut utiliser l'expression suivante :
db.users.find ({languages: {$all : ["english", "french"]}})
Opérateur $elemMatch
L'opérateur $elemMatch vous permet de sélectionner des documents dans lesquels des tableaux contiennent des éléments qui relèvent de certaines conditions. Par exemple, laissez la base de données contenir une collection d'évaluations d'utilisateurs pour des cours spécifiques. Ajoutons quelques documents :
db.grades.insertMany([{student: "Tom", courses:[{name: "Java", grade: 5}, {name: "MongoDB", grade: 4}]},
{student: "Alice", courses:[{name: "C++", grade: 3}, {name: "MongoDB", grade: 5}]}))
Chaque document a un tableau, qui à son tour se compose de documents imbriqués.
Nous allons maintenant trouver les étudiants qui ont une note supérieure à 3 pour le cours MongoDB :
db.grades.find({courses: {$elemMatch: {name: "MongoDB", grade: {$gt: 3}}}})
Opérateur $size
L'opérateur $size est utilisé pour trouver des documents dans lesquels les tableaux ont un nombre d'éléments égal à la valeur de $size. Par exemple, extrayons tous les documents où il y a deux éléments dans le tableau langues :
db.users.find ({languages: {$size:2}})
Une telle requête correspondra par exemple au document suivant :
{"name": "Tom", "age": 32, languages: ["english", "german"]}
L'opérateur $existe
L'opérateur $existe permet d'extraire uniquement les documents où une certaine clé est présente ou absente. Par exemple, renvoyez tous les documents contenant la clé de l'entreprise :
db.users.find ({company: {$exists:true}})
Si nous spécifions $existe comme paramètre faux, la requête nous renverra uniquement les documents qui ne contiennent pas la clé de l'entreprise.
Type $opérateur
L'opérateur $type extrait uniquement les documents où une certaine clé a une valeur d'un certain type, par exemple, une chaîne ou un nombre :
db.users.find ({age: {$type: "string"}})
> db.users.find ({age: {$type: "number"}})
Opérateur $regex
L'opérateur $regex spécifie une expression régulière à laquelle la valeur du champ doit correspondre . Par exemple, laissez le nom du champ avoir obligatoirement la lettre "b":
db.users.find ({name: {$regex: "b"}})
Il est important de comprendre que $regex ne prend pas que des chaînes, mais des expressions régulières, par exemple :name :{$regex :"om$"} – la valeur de name doit se terminer par "om".
