MongoDB Opérateurs de requête

Dans ce chapitre, nous allons voir comment utiliser les opérateurs de requête dans MongoDB.

Dans MongoDB, les opérateurs de requête servent à filtrer, comparer et effectuer des opérations logiques lors de l'interrogation de documents.

Ces opérateurs peuvent être divisés en catégories suivantes : opérateurs de comparaison, opérateurs logiques, opérateurs d'élément, opérateurs de tableau et autres opérateurs couramment utilisés.

Opérateurs de comparaison

Les opérateurs de comparaison sont :

OperatorDescriptionExemple
$eqequals{ age: { $eq: 25 } }
$nedifférent de{ age: { $ne: 25 } }
$gtsupérieur à{ age: { $gt: 25 } }
$gtesupérieur ou égal à{ age: { $gte: 25 } }
$ltinférieur à{ age: { $lt: 25 } }
$lteinférieur ou égal à{ age: { $lte: 25 } }
$inest dans le tableau spécifié{ age: { $in: [25, 30, 35] } }
$ninn'est pas dans le tableau spécifié{ age: { $nin: [25, 30, 35] } }

$eq (égal à)

Syntaxe :

{ field: { $eq: value } }

Trouver les personnes dont l'âge est égal à 25 :

db.collection.find({ age: { $eq: 25 } })

$ne (différent de)

Syntaxe :

{ field: { $ne: value } }

Trouver les personnes dont l'âge n'est pas égal à 25 :

db.collection.find({ age: { $ne: 25 } })

$gt (supérieur à)

Syntaxe :

{ field: { $gt: value } }

Trouver les personnes dont l'âge est supérieur à 25 :

db.collection.find({ age: { $gt: 25 } })

$gte (supérieur ou égal à)

Syntaxe :

{ field: { $gte: value } }

Trouver les personnes dont l'âge est supérieur ou égal à 25 :

db.collection.find({ age: { $gte: 25 } })

$lt (inférieur à)

Syntaxe : { field: { $lt: value } }

Trouver les personnes dont l'âge est inférieur à 25 :

db.collection.find({ age: { $lt: 25 } })

$lte (inférieur ou égal à)

Syntaxe :

{ field: { $lte: value } }

Trouver les personnes dont l'âge est inférieur ou égal à 25 :

db.collection.find({ age: { $lte: 25 } })

$in (la valeur est dans le tableau)

Syntaxe :

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

Trouver les personnes dont l'âge est l'une des valeurs 20, 25 et 30 :

db.collection.find({ age: { $in: [20, 25, 30] } })

$nin (la valeur n'est pas dans le tableau)

Syntaxe :

{ field: { $nin: [value1, value2, ...] } }

Trouvez les personnes dont l'âge ne fait pas partie des valeurs 20, 25 et 30 :

db.collection.find({ age: { $nin: [20, 25, 30] } })

Opérateurs logiques

Les opérateurs logiques sont :

OperatorDescriptionExemple
$andET logique, satisfait toutes les conditions{ $and: [ { age: { $gt: 25 } }, { city: "New York" } ] }
$orOU logique, satisfait au moins une condition{ $or: [ { age: { $lt: 25 } }, { city: "New York" } ] }
$notNégation, ne satisfait pas la condition{ age: { $not: { $gt: 25 } } }
$norNON-OU logique, ne satisfait aucune des conditions{ $nor: [ { age: { $gt: 25 } }, { city: "New York" } ] }

$and (toutes les conditions sont satisfaites)

Syntaxe :

{ $and: [ { condition1 }, { condition2 } ] }

Trouvez les personnes dont l'âge est supérieur à 25 et inférieur à 35 :

db.collection.find({ $and: [{ age: { $gt: 25 } }, { age: { $lt: 35 } }] })

$or (au moins une condition est satisfaite)

Syntaxe :

{ $or: [ { condition1 }, { condition2 } ] }

Trouvez les personnes dont l'âge est supérieur à 25 ou inférieur à 18 :

db.collection.find({ $or: [{ age: { $gt: 25 } }, { age: { $lt: 18 } }] })

$not (nie la condition)

Syntaxe :

{ field: { $not: { condition } } }

Trouvez les personnes dont l'âge n'est pas supérieur à 25 :

db.collection.find({ age: { $not: { $gt: 25 } } })

$nor (aucune des conditions n'est remplie)

Syntaxe :

{ $nor: [ { condition1 }, { condition2 } ] }

Trouver les personnes dont l'âge n'est pas supérieur à 25 et n'est pas inférieur à 18 :

db.collection.find({ $nor: [{ age: { $gt: 25 } }, { age: { $lt: 18 } }] })

Opérateurs d'éléments

Les opérateurs d'éléments sont :

OperatorDescriptionExemple
$existssi le champ existe{ age: { $exists: true } }
$typele type BSON du champ{ age: { $type: "int" } }

$exists (le champ existe)

Syntaxe :

{ field: { $exists: boolean } }

Trouver les documents qui contiennent le champ age :

db.collection.find({ age: { $exists: true } })

$type (type du champ)

Syntaxe :

{ field: { $type: "type" } }

Trouver les documents où le champ age est de type entier :

db.collection.find({ age: { $type: "int" } })

Opérateurs de tableau

Les opérateurs de tableau sont :

OperatorDescriptionExemple
$allLe tableau contient tous les éléments spécifiés{ tags: { $all: ["red", "blue"] } }
$elemMatchLes éléments du tableau correspondent aux conditions spécifiées{ results: { $elemMatch: { score: { $gt: 80, $lt: 85 } } } }
$sizeLa longueur du tableau est égale à la valeur spécifiée{ tags: { $size: 3 } }

Trouver les documents dont le tableau tags contient "red" et "blue" :

db.myCollection.find({ tags: { $all: ["red", "blue"] } });

$all (le tableau contient tous les éléments spécifiés)

Syntaxe :

{ field: { $all: [value1, value2, ...] } }

Trouver les documents dont le tableau tags contient "mongodb" et "database" :

db.collection.find({ tags: { $all: ["mongodb", "database"] } })

$elemMatch (au moins un élément du tableau remplit la condition)

Syntaxe :
{ field: { $elemMatch: { condition } } }

Trouver les éléments dans le tableau items où quantity est supérieur à 10 :

db.collection.find({ items: { $elemMatch: { quantity: { $gt: 10 } } } })

$size (taille du tableau)

Syntaxe :

{ field: { $size: value } }

Trouver les documents où le tableau tags a une taille de 3 :

db.collection.find({ tags: { $size: 3 } })

Autres opérateurs

Il existe quelques autres opérateurs comme suit :

OperatorDescriptionExemple
$regexCorrespond à une expression régulière{ name: { $regex: /^A/ } }
$textEffectue une recherche textuelle{ $text: { $search: "coffee" } }
$whereUtilise des expressions JavaScript pour le filtrage conditionnel{ $where: "this.age > 25" }
$nearTrouver des documents près d’un point spécifiédb.collection.find({ location: { $near: [10, 20], $maxDistance: 1000 } })
$geoWithinTrouver des documents dans une zone géographique spécifiéedb.collection.find({ location: { $geoWithin: { $centerSphere: [[10, 20], 1] } } })

$regex (correspondance par expression régulière)

Syntaxe :

{ field: { $regex: "pattern" } }

Trouver des documents dont le nom commence par "John" :

db.collection.find({ name: { $regex: /^John/ } })

$near (documents près d’un point spécifié)

Syntaxe :

{ field: { $near: [longitude, latitude], $maxDistance: distance } }

Trouver des documents proches d’un certain emplacement :

db.collection.find({ location: { $near: [10, 20], $maxDistance: 1000 } })

$geoWithin (trouver des documents dans une zone spécifiée)

Syntaxe :

{ field: { $geoWithin: { $centerSphere: [[longitude, latitude], radius] } } }

Trouver des documents dans une zone géographique spécifiée :

db.collection.find({ location: { $geoWithin: { $centerSphere: [[10, 20], 1] } } })
Autres extensions