MongoDB $ cmp

El $ CMP es el operador de tuberías de agregación de MongoDB que se utiliza para la comparación de los valores. El operador de $ CMP devuelve los resultados en valores numéricos que incluyen "1", "-1" y "0" basado en los valores dados. El operador de $ CMP devuelve "1" cuando el primer valor especificado tiene un valor mayor que el segundo valor. Por otro lado, el operador de $ CMP proporciona "-1" cuando el primer valor establecido es menor que el segundo valor dado. Los resultados "0" se obtienen cuando los valores dados para la comparación en el operador de $ CMP son iguales.

¿Cómo compara el operador de $ CMP de MongoDB los dos valores?

Aquí, usamos el operador de $ CMP para fines de comparación. Creamos la colección "MyData" que necesita los documentos para la implementación del operador de $ CMP. Almacenamos los seis documentos al mismo tiempo en la colección "MyData" utilizando la siguiente consulta InsertMany:

db.Mis datos.insertmany ([

"_id": 1,
"Medir la distancia",
"X": 5,
"Y": 3,
"Z": "Z1": 6, "Z2": 2
,

"_id": 2,
"Medir": "velocidad",
"X": 10,
"Y": 10,
"Z": "Z1": 4, "Z2": 7
,

"_id": 3,
"Medir": "Velocidad",
"X": 8,
"Y": 14,
"Z": "Z1": 3, "Z2": 9
,

"_id": 4,
"Medir": "desplazamiento",
"X": NULL,
"Y": NULL,
"Z": "Z1": 15, "Z2": 3
,

"_id": 5,
"Medir el tiempo",
"X": NULL,
"Y": 16,
"Z": "Z1": 0, "Z2": 2
,

"_id": 6,
"Medir": "desplazamiento",
"X": Isodate ("2020-12-10T05: 00: 20.112Z "),
"Y": Isodate ("2023-02-06T05: 00: 20.112Z "),
"Z": "Z1": 3, "Z2": 9

])

Recuperamos la opción de reconocimiento como verdadera que indica que los documentos se insertan en la colección dada de MongoDB.

Reconocido: verdadero,
insertedids: '0': 1, '1': 2, '2': 3, '3': 4, '4': 5, '5': 6

Ejemplo 1: Uso del operador de $ CMP en MongoDB para comparar con el valor

Utilizamos el operador de $ CMP de MongoDB aquí para comparar el campo especificado del documento con otro valor. El operador $ Match se establece con la expresión "" Medida ":" Distancia "" primero para que coincida con el documento para comparar las operaciones. A continuación, utilizamos el operador de proyecto $ que proyecta el campo "Resultado" para el operador de $ CMP. El operador de $ CMP se invoca dentro del campo "Resultado" proyectado e ingresa la expresión "$ x", 5] "donde" $ x "es un campo del documento coincidente y el" 5 "es el valor que se comparará con el Campo "$ x".

db.Mis datos.Aggregate ([$ Match: "Medido": "Distancia",
$ Project:
Resultado: $ cmp: ["$ x", 5]])

Los resultados del operador de $ CMP muestran que el valor de "0" contra el campo "Resultado" proyectado porque tanto el valor "$ x" es "5" en el documento y el valor a comparar también es "5".

[_id: 1, resultado: 0]

Ejemplo 2: Uso del operador de $ CMP en MongoDB para comparar con los campos

Usamos el operador $ CMP para comparar el campo con el valor establecido. Ahora, logramos la comparación con dos campos del mismo documento. Comenzamos con el operador de proyecto $ donde los campos "_id", "$ x" y "$ y" dan un valor de "1" que se muestran junto con la salida resultante. Luego, definimos otro campo de "resultado" en el operador de proyecto $ donde el operador de $ CMP se emplea con la declaración "[" $ x "," $ y "]". Los "$ x" y "$ y" son los campos de los documentos que utilizan el operador de $ CMP para comparar sus valores.

db.Mis datos.agregar(
[
$ Project:
"_id": 0,
"X": 1,
"Y": 1,
Resultado: $ cmp: ["$ x", "$ y"]


]
)

El valor que devuelve el operador de $ CMP para los campos de comparación de cada documento se muestra a continuación. Algunos resultados tienen el valor de "1" contra el campo "resultado" porque el valor "$ x" es mayor que el valor "$ y". Algunos resultados del operador de $ CMP contienen el valor "-1" donde los valores "$ x" son menores que el valor de "$ y". Allí, podemos ver los resultados que tienen los resultados "0" debido al valor igual de "$ x" y "$ y".

[
X: 5, y: 3, resultado: 1,
X: 10, y: 10, resultado: 0,
X: 8, y: 14, resultado: -1,
X: nulo, y: nulo, resultado: 0,
X: nulo, y: 16, resultado: -1,
X: isodate ("2020-12-10t05: 00: 20.112z "), y: isodate (" 2023-02-06T05: 00: 20.112Z "),
Resultado: -1
]

Ejemplo 3: Uso del operador de $ CMP en MongoDB para comparar con los campos integrados

A continuación, implementamos el operador de $ CMP que se comparará con los campos integrados del documento. Aquí, descubrimos el documento cuyo campo de "medida" almacena el valor de "velocidad". Una vez que el documento coincide con el operador $ Match, el operador de $ CMP compara el valor. Tenemos el campo "Resultado" dentro del operador de proyecto $ que se establece con el operador de $ CMP. El operador de $ CMP contiene los dos campos integrados, "Z1" y "Z2", del campo "Z" que se compara.

db.Mis datos.Aggregate ([$ Match: "Medida": "Speed",
$ Project: resultado:
$ cmp: ["$ z.z1 "," $ z.z2 "]])

El valor devuelto es "-1" frente a la opción "resultado" por el operador de $ CMP ya que el "$ z incrustado.El campo Z1 ”tiene un valor menor que el $ z.valor z2.

[_id: 2, resultado: -1]

Ejemplo 4: Uso del operador de $ CMP en MongoDB para comparar con los valores nulos

El operador de $ CMP también compara los valores nulos en MongoDB. El "nulo" se especifica como el valor se considera el valor de la cadena. Aquí, comparamos los campos del documento que tienen valores nulos. Establecemos el operador $ coincidencia que coincide con el documento con el campo "_id" cuyo valor es "4". Después de esto, definimos los campos "_id", "medir", "x" e "y" con el "1" para la inclusión de estos campos. Luego, el operador de $ CMP es utilizado por el operador de proyecto $ el campo "Res". El operador de $ CMP aquí compara los valores de los campos "$ x" y "$ y" que se almacena en el documento de "_id: 4".

db.Mis datos.agregado (
[
$ Match: "_id": 4,
$ Project:

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


]
)

"Res" tiene el valor de salida de "0" porque cuando el operador de $ CMP comparan los valores, contienen nulo. Si uno de los valores es nulo y el otro tiene un número, el operador de $ CMP los compara de manera diferente, lo que se discute en el siguiente ejemplo:

[_id: 4, x: nulo, y: nulo, resultado: 0]

Ejemplo 5: Uso del operador de $ CMP en MongoDB para comparar los diferentes tipos

El operador de $ CMP compara el valor y los diferentes tipos de acuerdo con el orden de comparación proporcionado. Tenemos los documentos en nuestra colección "MyData" que contiene los diferentes tipos de valores. El operador de $ CMP puede compararlos y generar el resultado de acuerdo con el tipo de valor. Tenemos una consulta en la que el operador de $ coincidencia encuentra los documentos con el campo "_id". El campo "_id" establecido dentro del operador $ Match como expresión se llama más al operador $ NIN. El operador de $ NIN del MongoDB solo coincide con el documento cuyos valores "1, 2, 3" no son iguales. Después de eso, invocamos el operador de $ CMP que compara los campos de documentos emparejados, "$ x" y "$ y", con diferentes valores de tipo.

db.Mis datos.agregado (
[
$ Match: "_id": $ nin: [1, 2, 3],
$ Project:

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


]
)

Podemos ver los valores de los campos "x" e "y" comparados en la salida y sus valores resultantes generados por el operador de $ CMP. Cada documento coincidente devuelve los diferentes valores comparados.

[
[
_id: 4, medir: 'desplazamiento', x: nulo, y: nulo, res: 0,
_id: 5, Medida: 'Tiempo', X: Null, Y: 16, Res: -1,

_id: 6,
Medida: 'desplazamiento',
X: Isodate ("2020-12-10T05: 00: 20.112Z "),
Y: Isodate ("2023-02-06T05: 00: 20.112Z "),
Res: -1

]

Conclusión

Esta guía exploró el operador MongoDB $ CMP para comparar los valores. Aquí, discutimos el operador de $ CMP con ejemplos. Primero comparamos el campo con el valor especificado utilizando el operador de $ CMP. Luego, comparamos los dos campos diferentes y los campos integrados por el operador de $ CMP. El operador de $ CMP también se usa para comparar los valores nulos. Por último, tenemos un uso del operador de $ CMP para comparar el valor de diferentes tipos.