MongoDB $ CMP

Le $ CMP est l'opérateur de pipeline d'agrégation de MongoDB qui est utilisé pour la comparaison des valeurs. L'opérateur $ CMP renvoie les résultats en valeurs numériques qui incluent «1», «-1» et «0» en fonction des valeurs données. L'opérateur $ CMP renvoie «1» lorsque la première valeur spécifiée a une valeur supérieure à la deuxième valeur. D'un autre côté, l'opérateur $ CMP donne «-1» lorsque la première valeur définie est inférieure à la deuxième valeur donnée. Les résultats «0» sont obtenus lorsque les valeurs données pour la comparaison dans l'opérateur $ CMP sont égales.

Comment l'opérateur $ CMP de MongoDB compare-t-il les deux valeurs

Ici, nous utilisons l'opérateur $ CMP à des fins de comparaison. Nous créons la collection «MyData» qui a besoin des documents pour la mise en œuvre de l'opérateur $ CMP. Nous stockons les six documents en même temps dans la collection «MyData» en utilisant la requête InsertMany suivante:

db.Mes données.insertmany ([

"_id": 1,
"Mesure": "Distance",
"X": 5,
"Y": 3,
"Z": "Z1": 6, "Z2": 2
,

"_id": 2,
"Mesure": "vitesse",
"X": 10,
"Y": 10,
"z": "z1": 4, "z2": 7
,

"_id": 3,
"Mesure": "Velocity",
"X": 8,
"Y": 14,
"z": "z1": 3, "z2": 9
,

"_id": 4,
"Mesure": "déplacement",
"X": null,
"Y": null,
"z": "z1": 15, "z2": 3
,

"_id": 5,
"Mesure": "temps",
"X": null,
"Y": 16,
"z": "z1": 0, "z2": 2
,

"_id": 6,
"Mesure": "déplacement",
"X": Isodate ("2020-12-10T05: 00: 20.112Z "),
"Y": Isodate ("2023-02-06T05: 00: 20.112Z "),
"z": "z1": 3, "z2": 9

])

Nous récupérons l'option de reconnaissance comme vraie qui indique que les documents sont insérés dans la collection donnée de MongoDB.

Reconnu: vrai,
insertEDID: '0': 1, '1': 2, '2': 3, '3': 4, '4': 5, '5': 6

Exemple 1: Utilisation de l'opérateur $ CMP dans MongoDB pour comparer avec la valeur

Nous utilisons ici l'opérateur $ CMP de MongoDB pour comparer le champ spécifié du document avec une autre valeur. L'opérateur $ Match est défini avec l'expression «« Mesurer »:« Distance »» d'abord pour correspondre au document pour comparer les opérations. Ensuite, nous utilisons l'opérateur de projet $ qui projette le champ «Résultat» pour l'opérateur $ CMP. L'opérateur $ CMP est invoqué dans le champ «Résultat» projeté et saisit l'expression «$ x», 5] »où« $ x »est un champ du document correspondant et le« 5 »est la valeur à comparer avec le Champ «$ x».

db.Mes données.agrégat ([$ correspond: "mesure": "distance",
$ Project:
Résultat: $ cmp: ["$ x", 5]])

Les résultats de l'opérateur $ CMP montrent la valeur de «0» par rapport au champ «Résultat» prévu car la valeur «$ x» du champ est «5» dans le document et la valeur à comparer est également «5».

[_id: 1, résultat: 0]

Exemple 2: Utilisation de l'opérateur $ CMP dans MongoDB pour comparer avec les champs

Nous utilisons l'opérateur $ CMP pour comparer le champ avec la valeur définie. Maintenant, nous accomplissons la comparaison avec deux champs du même document. Nous commençons par l'opérateur de projet $ où les champs «_id», «$ x» et «$ y» donnent une valeur de «1» affichée avec la sortie résultante. Ensuite, nous définissons un autre champ «Résultat» dans l'opérateur de projet $ où l'opérateur $ CMP est employé avec la déclaration «[« $ x »,« $ y »]». Les «$ x» et «$ y» sont les champs des documents qui sont utilisés par l'opérateur $ CMP pour comparer leurs valeurs.

db.Mes données.agrégat(
[
$ Project:
"_id": 0,
"X": 1,
"Y": 1,
Résultat: $ cmp: ["$ x", "$ y"]


]]
)

La valeur qui est renvoyée par l'opérateur $ CMP pour les champs de comparaison de chaque document est affichée dans les éléments suivants. Certains résultats ont la valeur de «1» par rapport au champ «Résultat» car la valeur «$ x» est supérieure à la valeur «$ y». Certains résultats de l'opérateur $ CMP contiennent la valeur «-1» où les valeurs «$ x» sont inférieures à la valeur de «$ y». Là, nous pouvons voir les résultats qui ont les résultats "0" en raison de la valeur égale de "$ x" et "$ y".

[
X: 5, y: 3, résultat: 1,
X: 10, y: 10, résultat: 0,
X: 8, y: 14, résultat: -1,
X: null, y: null, résultat: 0,
X: null, y: 16, résultat: -1,
X: isodate ("2020-12-10T05: 00: 20.112Z "), Y: Isodate (" 2023-02-06T05: 00: 20.112Z "),
Résultat: -1
]]

Exemple 3: Utilisation de l'opérateur $ CMP dans MongoDB pour comparer avec les champs intégrés

Ensuite, nous déployons l'opérateur $ CMP à comparer sur les champs intégrés du document. Ici, nous découvrons le document dont le champ «Mesure» stocke la valeur «vitesse». Une fois le document correspondant à l'opérateur de correspondance $, l'opérateur $ CMP compare la valeur. Nous avons le champ «Résultat» à l'intérieur de l'opérateur de projet $ qui est défini avec l'opérateur $ CMP. L'opérateur $ CMP contient les deux champs intégrés, «Z1» et «Z2», du champ «Z» à comparer.

db.Mes données.agrégat ([$ correspond: "mesure": "vitesse",
$ Project: Résultat:
$ cmp: ["$ z.z1 "," $ z.z2 "]])

La valeur retournée est «-1» par rapport à l'option «Résultat» par l'opérateur $ CMP depuis le «$ z intégré.Le champ Z1 ”a une valeur plus petite que le $ z.valeur z2.

[_id: 2, résultat: -1]

Exemple 4: Utilisation de l'opérateur $ CMP dans MongoDB pour comparer avec les valeurs nulles

L'opérateur $ CMP compare également les valeurs nuls dans MongoDB. Le «null» est spécifié car la valeur est considérée comme la valeur de chaîne. Ici, nous comparons les champs du document qui ont des valeurs nulles. Nous définissons l'opérateur de match $ qui correspond au document avec le champ «_id» dont la valeur est «4». Après cela, nous définissons les champs «_id», «mesure», «x» et «y» avec le «1» pour l'inclusion de ces champs. Ensuite, l'opérateur $ CMP est utilisé par l'opérateur de projet $ le champ «Res». L'opérateur $ CMP compare ici les valeurs des champs «$ x» et «$ y» qui est stocké dans le document de «_id: 4».

db.Mes données.agrégat (
[
$ correspond: "_id": 4,
$ Project:

"_id": 1,
"X": 1,
"Y": 1,
Résultat: $ cmp: ["$ x", "$ y"]


]]
)

Le «res» a la valeur de sortie de «0» car lorsque les valeurs sont comparées par l'opérateur $ CMP, ils contiennent nul. Si l'une des valeurs est nul et l'autre a un nombre, l'opérateur $ CMP les compare différemment, ce qui est discuté dans l'exemple suivant:

[_id: 4, x: null, y: null, résultat: 0]

Exemple 5: Utilisation de l'opérateur $ CMP dans MongoDB pour comparer les différents types

L'opérateur $ CMP compare la valeur ainsi que les différents types en fonction de l'ordre de comparaison fourni. Nous avons les documents dans notre collection «MyData» qui contient les différents types de valeurs. L'opérateur $ CMP peut les comparer et générer le résultat en fonction du type de valeur. Nous avons une requête où l'opérateur de Match $ trouve les documents avec le champ «_id». Le champ «_ID» réglé à l'intérieur de l'opérateur de Match $ car une expression est en outre appelé l'opérateur $ nin. L'opérateur Nin Nin du MongoDB ne correspond que le document dont les valeurs «1, 2, 3» ne sont pas égales. Après cela, nous invoquons l'opérateur $ CMP qui compare les champs de document correspondants, «$ x» et «$ y», ayant des valeurs de type différentes.

db.Mes données.agrégat (
[
$ correspond: "_id": $ nin: [1, 2, 3],
$ Project:

"_id": 1,
"Mesure": 1,
"X": 1,
"Y": 1,
Res: $ cmp: ["$ x", "$ y"]


]]
)

Nous pouvons voir les valeurs des champs «X» et «Y» comparés dans la sortie et leurs valeurs résultantes générées par l'opérateur $ CMP. Chaque document correspondant renvoie les différentes valeurs comparées.

[
[
_id: 4, mesure: «déplacement», x: null, y: null, res: 0,
_id: 5, mesure: 'temps', x: null, y: 16, res: -1,

_id: 6,
Mesure: «déplacement»,
X: Isodate ("2020-12-10T05: 00: 20.112Z "),
Y: Isodate ("2023-02-06T05: 00: 20.112Z "),
Res: -1

]]

Conclusion

Ce guide a exploré l'opérateur MongoDB $ CMP pour comparer les valeurs. Ici, nous avons discuté de l'opérateur $ CMP avec des exemples. Nous avons d'abord comparé le champ avec la valeur spécifiée en utilisant l'opérateur $ CMP. Ensuite, nous avons comparé les deux champs différents et les champs intégrés par l'opérateur $ CMP. L'opérateur $ CMP est également utilisé pour comparer les valeurs nulles. Enfin, nous avons une utilisation de l'opérateur $ CMP pour comparer la valeur de différents types.