Opérateur de filtre MongoDB $
Comment l'opérateur de filtre $ est utilisé dans MongoDB
L'opérateur de filtre $ de MongoDB est utilisé pour filtrer les données de tableau en fonction de l'énoncé conditionnel donné. L'utilisation de l'opérateur de filtre $ fonctionne sur les documents insérés dans la collection spécifiée de MongoDB. Ici, nous déployons la requête insertMany () de MongoDB pour insérer trois documents dans la collection «Cricket». Chaque enregistrement contient trois champs - «_id», «lecteur» et le «runsrecord» - qui sont définis comme un tableau. Le format d'insertion du document est représenté dans les éléments suivants:
db.Criquet.insertmany ([
"_id": 1,
"Joueur": "Ravi",
"RunsRecord": [100, 50, 70],
"Allumettes" :
"Match1": "Worldcup",
"Année": "2000"
,
"_id": 2,
"Joueur": "Andrew",
"RunsRecord": [150, 90, 55]
,
"_id": 3,
"Joueur": "Smith",
"RunsRecord": [80, 99, 45]
,
"_id": 4,
"Joueur": "Alex",
"runsRecord": []
])
Les documents de la collection «Cricket» sont insérés avec succès comme indiqué dans la sortie suivante:
reconnue: true, insertEDIDS: '0': 1, '1': 2, '2': 3, '3': 4
Exemple 1: MongoDB utilise l'opérateur de filtre $ dans MongoDB
L'opérateur de filtre $ de base de l'exemple MongoDB est donné dans cette section. Nous définissons une requête où l'opérateur de projet $ est appelé dans la méthode agrégée. Nous invoquons l'opérateur de filtre $ au sein de l'opérateur de projet $. L'opérateur de filtre $ est spécifié avec son paramètre. Le paramètre «d'entrée» est défini avec le nom du champ de tableau «$ runsrecord» avec le signe «$» pour en extraire les données. Ensuite, nous utilisons le paramètre «AS» pour donner le titre à la variable de retour, «RunSrecord». Cette variable est ensuite mentionnée en utilisant le paramètre «Cond» avec le signe double dollar, «$$». Ensuite, le paramètre «cond» où l'expression est attribuée comme «$ gt: [« $$ runsrecord », 50]». Les conditions impliquent que l'opérateur «$ gt» obtient l'élément de tableau qui est supérieur à la valeur de «50» dans le champ de tableau «RunSrecord».
db.Criquet.agrégat([
$ Project:
Highruns:
$ filtre:
Entrée: "$ runsrecord",
AS: "RunsRecord",
cond: $ gt: ["$$ runsRecord", 50]
])
Les résultats de la requête de filtre $ suivante ne renvoient que les valeurs du tableau qui est plus grande «50». La valeur inférieure à «50» est ignorée par l'opérateur de filtre $.
[
_id: 1, Highruns: [100, 70],
_id: 2, Highruns: [150, 90, 55],
_id: 3, Highruns: [80, 99],
_id: 4, Highruns: []
]]
Exemple 2: MongoDB utilise l'opérateur de filtre $ pour filtrer le champ de non-existence
Maintenant, nous prenons un cas où l'opérateur de filtre $ est appliqué sur le terrain qui n'est présent dans aucun document de collecte inséré. Ici, nous avons une requête où l'opérateur de filtre $ est employé avec les paramètres. Le paramètre d'entrée est défini avec le champ «Salaire $» pour filtrer le document. Ensuite, nous utilisons le paramètre facultatif «AS» qui est également donné avec le nom de la variable, «Salaire», qui est utilisé dans le tableau d'entrée comme élément. Après cela, nous avons une expression conditionnelle dans le paramètre «cond» du filtre $. L'opérateur de filtre $ filtre l'élément de tableau en fonction de la condition spécifiée qui est «$ gte: [« $$ salaire », 6000]».
db.Criquet.agrégat([
$ correspond: _id: $ in: [2]
,
$ Project:
Highruns:
$ filtre:
Entrée: "$ Salaire",
AS: "Salaire",
cond: $ gte: ["$$ salaire", 6000]
])
Comme nous le savons, le champ «salarial» fourni n'est pas présent dans le document dont «_id» est «2», donc la sortie de la requête précédente de l'opérateur de filtre $ donne une valeur nul.
[_id: 2, highruns: null]
Exemple 3: MongoDB utilise l'opérateur de filtre $ pour filtrer le tableau vide
Vient ensuite le scénario où le filtre $ est employé sur le tableau vide. L'opérateur de filtre $ renvoie un ensemble de tableau vide si l'un des documents de la collection a un tableau vide. Nous avons la requête de l'opérateur de filtre $ suivant. Nous avons d'abord l'opérateur de match $ Match où l'expression «_id: $ in: [4]» est fournie pour être satisfaite. Lorsque l'opérateur $ in trouve la valeur de «4» contre le champ «_id», l'opérateur suivant procède. Ensuite, nous avons un opérateur de filtre $ qui filtre le tableau d'éléments en fonction de la condition donnée qui est "$ gt: [" $$ runsrecord ", 45]".
db.Criquet.agrégat([
$ correspond: _id: $ in: [4]
,
$ Project:
Highruns:
$ filtre:
Entrée: "$ runsrecord",
AS: "RunsRecord",
cond: $ gt: ["$$ runsRecord", 45]
])
Le «_id: 4» a le champ de tableau «RunsRecord» qui est vide. C'est pourquoi lorsque la requête est exécutée, il publie le tableau vide comme suit:
[_id: 4, highruns: []]
Exemple 4: MongoDB utilise l'opérateur de filtre $ dans MongoDB avec le nom de variable facultatif
Nous définissons un titre sur la variable dans les instances précédentes en utilisant l'argument «AS». Si l'argument «AS» n'est défini avec aucun nom de variable, la variable «$ this» est définie par défaut par MongoDB. Ayons l'exemple de requête pour cette déclaration. Nous correspondons au document en appelant l'opérateur de match $ où nous avons un champ «_id» dans lequel les valeurs sont définies. Nous attribuons un opérateur de filtre $ à l'opérateur «$ project» où l'opérateur de filtre $ est appelé avec les paramètres. Ici, nous avons un paramètre «d'entrée» avec le nom du champ de tableau «$ runsrecord». Ensuite, nous appliquons le paramètre «cond» avec la condition spécifiée. La condition est définie comme «cond: $ lt: [« $$ ceci », 80]». Cette fois, l'opérateur $ lt est utilisé pour trouver la valeur qui est inférieure à la valeur de «80». Notez qu'au lieu d'un nom de variable «RunSrecord», nous utilisons ici le nom de variable par défaut «$$ cette» qui n'affecte pas la sortie résultante.
db.Criquet.agrégat([
$ correspond: _id: $ in: [1, 2, 3, 4]
,
$ Project:
Highruns:
$ filtre:
Entrée: "$ runsrecord",
cond: $ lt: ["$$ ceci", 80]
])
L'opérateur de filtre $ filtre le tableau spécifié avec la variable $ cette variable de la même manière qu'avec la variable spécifiée.
[
_id: 1, Highruns: [50, 70],
_id: 2, Highruns: [55],
_id: 3, Highruns: [45],
_id: 4, Highruns: []
]]
Exemple 5: MongoDB utilise l'opérateur de filtre $ pour filtrer avec plusieurs conditions
Nous pouvons fournir plus d'une condition à l'opérateur de filtre $ pour filtrer uniquement les documents qui correspondent à la condition donnée. Ici, nous définissons l'opérateur de filtre $ où les $ et l'opérateur sont utilisés dans le paramètre «cond». Le $ et l'opérateur est défini avec les multiples conditions comme «$ gte: [« $$ runsrecord », 45]» et «$ lte: [« $$ runsrecord », 99]». Les $ et l'opérateur sont utilisés qui nécessitent les deux conditions comme vraies.
db.Criquet.agrégat([
$ Project:
Highruns:
$ filtre:
Entrée: "$ runsrecord",
AS: "RunsRecord",
cond: $ et: [
$ gte: ["$$ runsrecord", 45],
$ lte: ["$$ runsRecord", 99]
]
])
Avec les multiples conditions, nous filtrons le document apparié dans ce qui suit:
[
_id: 1, Highruns: [50, 70],
_id: 2, Highruns: [90, 55],
_id: 3, Highruns: [80, 99, 45],
_id: 4, Highruns: []
]]
Conclusion
Nous avons exploré cet article qui concerne l'opérateur de filtre $ de MongoDB. Ici, nous avons fourni la mise en œuvre du script MongoDB de l'opérateur de filtre $ pour filtrer les données spécifiées. Nous avons d'abord démontré l'utilisation de base de l'opérateur de filtre $. Ensuite, nous avons utilisé l'opérateur de filtre $ sur le document dont le champ n'est pas ajouté dans le document. Le boîtier de champ de tableau vide est également déployé sur l'opérateur de filtre $ qui récupère le tableau vide. De plus, l'opérateur de filtre $ est utilisé avec la variable $ cette variable qui est la variable par défaut.