MONGODB $ CMP

O $ CMP é o operador de oleoduto de agregação do MongoDB que é usado para a comparação dos valores. O operador $ CMP retorna os resultados em valores numéricos que incluem "1", "-1" e "0" com base nos valores fornecidos. O operador $ cmp retorna "1" quando o primeiro valor especificado tem um valor maior que o segundo valor. Por outro lado, o operador $ cmp fornece "-1" quando o primeiro valor definido é menor que o segundo valor dado. Os resultados “0” são obtidos quando os valores fornecidos para comparação no operador $ cmp são iguais.

Como o operador $ cmp do MongoDB compara os dois valores

Aqui, usamos o operador $ cmp para fins de comparação. Criamos a coleção "MyData", que precisa dos documentos para a implementação do operador $ CMP. Armazenamos os seis documentos ao mesmo tempo na coleção "mydata" usando a seguinte consulta InsertMany:

dB.Meus dados.InsertMany ([

"_id": 1,
"Medida": "Distância",
"X": 5,
"Y": 3,
"Z": "Z1": 6, "Z2": 2
,

"_id": 2,
"Medida": "velocidade",
"X": 10,
"Y": 10,
"Z": "Z1": 4, "Z2": 7
,

"_id": 3,
"Medida": "Velocity",
"X": 8,
"Y": 14,
"Z": "Z1": 3, "Z2": 9
,

"_id": 4,
"Medida": "deslocamento",
"X": NULL,
"Y": nulo,
"Z": "Z1": 15, "Z2": 3
,

"_id": 5,
"Medida": "tempo",
"X": NULL,
"Y": 16,
"Z": "Z1": 0, "Z2": 2
,

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

]))

Recuperamos a opção de reconhecimento como verdadeira, que indica que os documentos são inseridos na coleção dada de MongoDB.

reconhecido: verdadeiro,
inserdids: '0': 1, '1': 2, '2': 3, '3': 4, '4': 5, '5': 6

Exemplo 1: Usando o operador $ CMP em MongoDB para comparar com o valor

Usamos o operador $ cmp do MongoDB aqui para comparar o campo especificado do documento com outro valor. O operador de Match $ está definido com a expressão ““ Medida ”:“ Distância ”” primeiro para corresponder ao documento para comparar as operações. Em seguida, usamos o Operador de Projeto $ que projeta o campo "Resultado" para o operador $ CMP. O operador $ cmp é chamado no campo "Resultado" projetado e insere a expressão "$ x", 5] "em que" $ x "é um campo do documento correspondente e o" 5 "é o valor a ser comparado com o "$ X" campo.

dB.Meus dados.agregado ([$ Match: "Medida": "Distance",
$ Project:
Resultado: $ cmp: ["$ x", 5]])

Os resultados do operador de $ CMP mostram o valor de "0" no campo "Resultado" projetado, porque o campo "$ x" é "5" no documento e o valor a ser comparado também é "5".

[_id: 1, resultado: 0]

Exemplo 2: Usando o operador $ cmp em MongoDB para comparar com os campos

Usamos o operador $ cmp para comparar o campo com o valor definido. Agora, realizamos a comparação com dois campos do mesmo documento. Começamos com o operador de projeto $ onde os campos “_id”, “$ x” e “$ y” dão um valor de “1” que são mostrados junto com a saída resultante. Em seguida, definimos outro campo de "resultado" no operador de projeto $, onde a operadora $ cmp está empregada com a declaração "[" $ x "," $ y "]" ". Os "$ x" e "$ y" são os campos dos documentos usados ​​pelo operador $ cmp para comparar seus valores.

dB.Meus dados.agregar(
[[
$ Project:
"_id": 0,
"X": 1,
"Y": 1,
Resultado: $ cmp: ["$ x", "$ y"]


]
)

O valor que é retornado pelo operador $ cmp para campos de comparação de cada documento é exibido no seguinte. Alguns resultados têm o valor de "1" no campo "resultado" porque o valor "$ x" é maior que o valor "$ y". Alguns resultados do operador $ cmp contêm o valor "-1" em que os valores "$ x" são menores que o valor de "$ y". Lá, podemos ver os resultados que têm os resultados "0" devido ao valor igual de "$ x" e "$ y".

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

Exemplo 3: Usando o operador $ cmp em MongoDB para comparar com os campos incorporados

Em seguida, implantamos o operador $ cmp a ser comparado com os campos incorporados do documento. Aqui, descobrimos o documento cujo campo de "medida" armazena o valor de "velocidade". Depois que o documento é correspondido pelo operador de Match $, o operador $ CMP compara o valor. Temos o campo "Resultado" dentro do operador de projeto $ definido com o operador $ cmp. O operador $ CMP contém os dois campos incorporados, "Z1" e "Z2", do campo "Z" a ser comparado.

dB.Meus dados.agregado ([$ Match: "Medida": "Speed",
$ Project: resultado:
$ cmp: ["$ z.Z1 "," $ Z.Z2 "]])

O valor retornado é "-1" contra a opção "Resultado" do operador $ CMP desde o "$ Z incorporado.O campo Z1 ”tem um valor menor que o $ z.valor z2.

[_id: 2, resultado: -1]

Exemplo 4: Usando o operador $ cmp em MongoDB para comparar com os valores nulos

O operador $ cmp também compara os valores nulos em MongoDB. O "nulo" é especificado como o valor é considerado o valor da string. Aqui, comparamos os campos do documento que têm valores nulos. Definimos o operador de Match $ que corresponde ao documento com o campo "_id" cujo valor é "4". Depois disso, definimos os campos "_id", "medir", "x" e "y" com o "1" para a inclusão desses campos. Em seguida, o operador $ cmp é utilizado pelo operador de projeto $ o campo "Res". O operador $ cmp aqui compara os valores dos campos "$ x" e "$ y", que são armazenados no documento de "_id: 4".

dB.Meus dados.agregado (
[[
$ Match: "_id": 4,
$ Project:

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


]
)

O "res" tem o valor de saída de "0" porque quando os valores são comparados pelo operador $ cmp, eles contêm nulo. Se um dos valores for nulo e o outro tiver um número, o operador de $ CMP os compara de maneira diferente, o que é discutido no exemplo a seguir:

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

Exemplo 5: Usando o operador $ cmp em MongoDB para comparar os diferentes tipos

O operador $ CMP compara o valor e os diferentes tipos de acordo com a ordem de comparação fornecida. Temos os documentos em nossa coleção "mydata", que contém os diferentes tipos de valores. O operador $ CMP pode compará -los e gerar o resultado de acordo com o tipo de valor. Temos uma consulta em que o operador de Match $ encontra os documentos com o campo "_id". O campo “_id” definido dentro do operador de match $ como uma expressão é mais chamado de operador $ nin. O operador de $ nin do MongoDB corresponde apenas ao documento cujos valores "1, 2, 3" não são iguais. Depois disso, invocamos o operador $ cmp que compara os campos de documentos correspondentes, "$ x" e "$ y", com valores de tipo diferentes.

dB.Meus dados.agregado (
[[
$ Match: "_id": $ nin: [1, 2, 3],
$ Project:

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


]
)

Podemos ver os valores dos campos comparados "x" e "y" na saída e seus valores resultantes que são gerados pelo operador $ cmp. Cada documento correspondente retorna os diferentes valores comparados.

[[
[[
_id: 4, meça: 'deslocamento', x: null, y: null, res: 0,
_id: 5, meça: 'tempo', x: null, y: 16, res: -1,

_id: 6,
Medida: 'Deslocamento',
X: Isodato ("2020-12-10T05: 00: 20.112Z "),
y: isodate ("2023-02-06T05: 00: 20.112Z "),
Res: -1

]

Conclusão

Este guia explorou o operador MongoDB $ CMP para comparar os valores. Aqui, discutimos o operador $ cmp com exemplos. Primeiro comparamos o campo com o valor especificado usando o operador $ cmp. Em seguida, comparamos os dois campos diferentes e os campos incorporados pelo operador $ cmp. O operador $ cmp também é usado para comparar os valores nulos. Por fim, temos um uso do operador de $ cmp para comparar o valor de diferentes tipos.