Opérateurs de comparaison : $eq, $gt, $lt, $in

Les filtres d'égalité simples comme { status: 'active' } sont utiles, mais les requêtes réelles nécessitent davantage de nuances. MongoDB fournit un riche ensemble d'opérateurs de requête préfixés par $, qui permettent d'exprimer des conditions allant au-delà de la simple égalité. Ces opérateurs vous permettent de filtrer selon des intervalles numériques, l'appartenance à une liste, la présence d'une valeur et la correspondance avec un modèle.

Les opérateurs de comparaison sont la catégorie la plus utilisée. Ils fonctionnent avec tout type BSON comparable : nombres, chaînes de caractères (comparaison lexicographique), dates et même ObjectIds (dans l'ordre chronologique, puisque les ObjectIds encodent des horodatages).

L'opérateur $eq teste explicitement l'égalité : { age: { $eq: 30 } }. Dans la plupart des cas, la forme abrégée { age: 30 } est identique et préférable pour la lisibilité ; $eq est principalement utile lorsque l'opérateur est nécessaire à l'intérieur d'une autre expression comme $expr.

Une différence existe : $eq est requis dans les expressions de pipeline d'agrégation lorsqu'il faut comparer deux valeurs de champ (par exemple { $eq: ['$price', '$salePrice'] }). Dans les filtres find classiques, utilisez la syntaxe abrégée de l'égalité, sauf si un contexte particulier impose la forme avec opérateur.

$gt (supérieur à) et $gte (supérieur ou égal à) filtrent les documents dont la valeur d'un champ dépasse un seuil. Ils fonctionnent avec les nombres, les dates, les chaînes de caractères (ordre lexicographique) et les ObjectIds.

Les comparaisons de dates sont particulièrement puissantes : { createdAt: { $gte: new Date('2024-01-01') } } trouve tous les documents créés depuis le 1er janvier 2024. Cette requête peut utiliser un index sur createdAt pour atteindre une complexité en O(log n), ce qui rend les requêtes sur des intervalles de dates extrêmement efficaces, même dans de grandes collections.

$lt (inférieur à) et $lte (inférieur ou égal à) sont les compléments de $gt/$gte. Combinez les deux opérateurs sur le même champ pour créer une requête sur un intervalle : MongoDB applique les deux conditions au même champ, ce qui équivaut à BETWEEN en SQL.

Les requêtes sur des intervalles portant sur des champs indexés sont très efficaces, car MongoDB peut se positionner sur la borne inférieure dans l'index, puis parcourir celui-ci jusqu'à la borne supérieure en ne consultant que les entrées pertinentes. C'est l'une des principales raisons d'indexer les champs sur lesquels vous effectuez fréquemment des filtrages par intervalle.

$ne (différent de) sélectionne les documents dont la valeur d'un champ n'est pas égale à la valeur indiquée. Il sélectionne également les documents dans lesquels le champ n'existe pas du tout, car un champ manquant est implicitement différent de toute valeur.

Soyez prudent avec $ne dans les grandes collections non indexées : MongoDB ne peut généralement pas utiliser efficacement un index pour satisfaire une négation et peut revenir à un parcours de la collection. Pour les requêtes comportant de nombreux filtres, privilégiez autant que possible les conditions positives ($eq, $in) aux conditions négatives.

$in sélectionne les documents dont la valeur d'un champ est égale à l'une quelconque des valeurs d'un tableau fourni. C'est l'équivalent MongoDB de la clause SQL IN. Cette solution est bien plus concise que l'écriture de plusieurs conditions $or pour un même champ.

Sur un champ indexé, $in est implémenté sous la forme de plusieurs recherches ponctuelles dans l'arbre d'index, une par valeur du tableau, ce qui est très efficace. Pour les grandes listes (des centaines de valeurs), les performances diminuent, mais pour les cas d'utilisation habituels (5 à 20 valeurs), $in est un excellent choix.

$nin (ne se trouve pas dans) est la négation de $in : il sélectionne les documents dont la valeur du champ ne se trouve pas dans le tableau fourni, et sélectionne également les documents dans lesquels le champ est absent. Comme $ne, il peut être moins efficace que $in, car il nécessite souvent de parcourir les documents.

Cas d'utilisation pratique : exclure un ensemble connu d'identifiants. Si un utilisateur a bloqué certains autres utilisateurs, vous pouvez exclure leur contenu : { authorId: { $nin: blockedUserIds } }. Pour de meilleures performances, veillez à garder la liste d'exclusion courte.

Vous pouvez combiner plusieurs opérateurs de comparaison sur le même champ ou sur des champs différents au sein d'une seule requête. Lorsque les opérateurs apparaissent sur le même champ dans un objet, ils agissent comme un AND implicite : les deux conditions doivent être vraies. Lorsqu'ils portent sur des champs différents, les deux conditions doivent également être vraies.

Construisez des filtres complexes en réfléchissant à chaque champ indépendamment, puis en combinant les conditions. MongoDB évalue ensemble toutes les conditions portant sur les champs et utilise les index disponibles afin de réduire au minimum le nombre de documents examinés.

Les comparaisons de dates comptent parmi les utilisations les plus courantes des opérateurs de comparaison dans les applications réelles. Le type BSON Date de MongoDB stocke les dates sous forme de millisecondes sur 64 bits ; tous les opérateurs de comparaison fonctionnent donc naturellement sur les champs de date.

Parmi les schémas courants figurent la recherche des enregistrements créés au cours des N derniers jours, le filtrage des abonnements actifs qui expirent après aujourd'hui et les requêtes sur des intervalles correspondant à des périodes de rapport. Construisez toujours des objets Date dans la requête : ne comparez jamais les dates sous forme de chaînes, car la comparaison lexicographique des chaînes produit des résultats incorrects pour la plupart des formats de date.

Les opérateurs de comparaison bénéficient énormément des index. Un index sur un champ numérique transforme un parcours en O(n) en une opération en O(log n + taille du résultat). Points essentiels :

• Les requêtes sur des intervalles ($gt, $lt) peuvent utiliser un index à champ unique pour accéder directement au début de l'intervalle
• $in effectue plusieurs recherches ponctuelles dans l'index, une par valeur
• Les opérateurs de négation ($ne, $nin) parcourent souvent l'index au lieu d'effectuer des recherches ponctuelles et sont donc moins efficaces
• Utilisez explain('executionStats') pour vérifier que vos requêtes de comparaison utilisent IXSCAN et non COLLSCAN

Les opérateurs de comparaison apparaissent dans deux contextes : comme opérateurs de requête dans les filtres de find() (avec la syntaxe { field: { : value } }) et comme opérateurs d'expression dans le pipeline d'agrégation, dans les étapes et (avec une syntaxe différente : { : ['', value] }).

Dans , les opérateurs d'expression renvoient une valeur booléenne ou une valeur calculée. Par exemple, vous pouvez ajouter un champ calculé isExpensive qui vaut vrai lorsque le prix dépasse 100 : { : { isExpensive: { : ['', 100] } } }. L'étape utilise la même syntaxe de requête que find().

Dans cette leçon, vous avez appris que $gt/$gte/$lt/$lte créent des conditions d'intervalle sur les nombres, les dates et les chaînes, et fonctionnent avec les index pour effectuer des parcours d'intervalles en O(log n), que $in sélectionne toute valeur d'une liste et est nettement plus lisible et efficace que plusieurs conditions d'égalité $or sur le même champ, et que $ne/$nin sont des opérateurs de négation qui sélectionnent tout ce qui se trouve en dehors de la valeur ou de la liste indiquée, mais sont moins efficaces avec les index que leurs équivalents positifs. Nous allons maintenant découvrir les opérateurs logiques — $and, $or, $nor et $not — afin de combiner des conditions portant sur différents champs.