MongoDB $ CMP

Il $ CMP è l'operatore della pipeline di aggregazione di MongoDB che viene utilizzato per il confronto dei valori. L'operatore $ CMP restituisce i risultati in valori numerici che includono "1", "-1" e "0" in base ai valori dati. L'operatore $ CMP restituisce “1” quando il primo valore specificato ha un valore maggiore rispetto al secondo valore. D'altra parte, l'operatore $ CMP fornisce "-1" quando il primo valore di impostazione è inferiore al secondo valore dato. I risultati "0" sono ottenuti quando i valori dati per il confronto nell'operatore $ CMP sono uguali.

In che modo l'operatore $ CMP di MongoDB confronta i due valori

Qui, utilizziamo l'operatore $ CMP per scopi di confronto. Creiamo la raccolta "MyData" che richiede i documenti per l'implementazione dell'operatore $ CMP. Archiviamo i sei documenti contemporaneamente nella collezione "MyData" utilizzando la seguente query InsertMany:

db.I miei dati.InsertMany ([

"_id": 1,
"Misura": "Distanza",
"X": 5,
"Y": 3,
"z": "z1": 6, "z2": 2
,

"_id": 2,
"Misura": "Speed",
"X": 10,
"Y": 10,
"z": "z1": 4, "z2": 7
,

"_id": 3,
"Misura": "Velocità",
"X": 8,
"Y": 14,
"z": "z1": 3, "z2": 9
,

"_id": 4,
"Misura": "spostamento",
"X": null,
"Y": null,
"z": "z1": 15, "z2": 3
,

"_id": 5,
"Misura": "Time",
"X": null,
"Y": 16,
"z": "z1": 0, "z2": 2
,

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

])

Recuperiamo l'opzione di riconoscimento come vera, il che indica che i documenti sono inseriti nella raccolta di MongoDB.

riconosciuto: vero,
inseritedids: '0': 1, '1': 2, '2': 3, '3': 4, '4': 5, '5': 6

Esempio 1: utilizzando l'operatore $ CMP in MongoDB per confrontare con il valore

Usiamo qui l'operatore $ CMP di MongoDB per confrontare il campo specificato del documento con un altro valore. L'operatore $ match è impostato con l'espressione "" misura ":" distanza "" per abbinare il documento per confrontare le operazioni. Successivamente, utilizziamo l'operatore $ Project che proietta il campo "Risultato" per l'operatore $ CMP. L'operatore $ CMP è invocato all'interno del campo "risultato" previsto e input l'espressione "$ x", 5] "in cui" $ x "è un campo del documento abbinato e il" 5 "è il valore da confrontare con il Campo "$ x".

db.I miei dati.Aggregate ([$ match: "misura": "distanza",
$ Progetto:
Risultato: $ cmp: ["$ x", 5]])

I risultati dell'operatore $ CMP mostrano il valore di "0" rispetto al campo "risultato" previsto perché sia ​​il valore "$ x" è "5" nel documento e il valore da confrontare è anche "5".

[_id: 1, risultato: 0]

Esempio 2: utilizzando l'operatore $ CMP in MongoDB per confrontare con i campi

Utilizziamo l'operatore $ CMP per confrontare il campo con il valore impostato. Ora, realizziamo il confronto con due campi dello stesso documento. Iniziamo con l'operatore del progetto $ in cui i campi "_id", "$ x" e "$ y" danno un valore di "1" che sono mostrati insieme all'output risultante. Quindi, definiamo un altro campo "risultato" nell'operatore del progetto $ in cui l'operatore $ CMP viene impiegato con la dichiarazione "[" $ x "," $ y "]". I "$ x" e "$ y" sono i campi dei documenti utilizzati dall'operatore $ CMP per confrontare i loro valori.

db.I miei dati.aggregato(
[
$ Progetto:
"_id": 0,
"X": 1,
"Y": 1,
Risultato: $ cmp: ["$ x", "$ y"]


"
)

Il valore restituito dall'operatore $ CMP per i campi di confronto di ciascun documento viene visualizzato nel seguente. Alcuni risultati hanno il valore di "1" rispetto al campo "risultato" perché il valore "$ x" è maggiore del valore "$ y". Alcuni risultati dell'operatore $ CMP contengono il valore "-1" in cui i valori "$ x" sono inferiori al valore di "$ y". Lì, possiamo vedere i risultati che hanno i risultati "0" a causa dell'eguale valore di "$ x" e "$ y".

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

Esempio 3: Utilizzo dell'operatore $ CMP in MongoDB per essere confrontato con i campi incorporati

Successivamente, distribuiamo l'operatore $ CMP per essere confrontato sui campi incorporati del documento. Qui, scopriamo il documento il cui campo "Misura" memorizza il valore "velocità". Una volta che il documento è abbinato dall'operatore $ Match, l'operatore $ CMP confronta il valore. Abbiamo il campo "Risultato" all'interno dell'operatore di progetto $ che è impostato con l'operatore $ CMP. L'operatore $ CMP contiene i due campi incorporati, "Z1" e "Z2", del campo "Z" da confrontare.

db.I miei dati.Aggregate ([$ match: "misura": "velocità",
$ Progetto: risultato:
$ cmp: ["$ z.z1 "," $ z.z2 "]])

Il valore restituito è "-1" rispetto all'opzione "risultato" da parte dell'operatore $ CMP da quando è incorporato "$ z.Il campo z1 "ha un valore inferiore a $ z.Valore z2.

[_id: 2, risultato: -1]

Esempio 4: utilizzando l'operatore $ CMP in MongoDB per confrontare i valori null

L'operatore $ CMP confronta anche i valori null in MongoDB. Il "null" è specificato poiché il valore è considerato il valore della stringa. Qui, confrontiamo i campi del documento che hanno valori nulli. Abbiamo impostato l'operatore $ match che corrisponde al documento con il campo "_id" il cui valore è "4". Dopo questo, definiamo i campi "_id", "misura", "x" e "y" con "1" per l'inclusione di questi campi. Quindi, l'operatore $ CMP è utilizzato dall'operatore del progetto $ il campo "RES". L'operatore $ CMP qui confronta i valori dei campi "$ x" e "$ y" che sono archiviati nel documento di "_id: 4".

db.I miei dati.aggregato (
[
$ match: "_id": 4,
$ Progetto:

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


"
)

La "res" ha il valore di output di "0" perché quando i valori vengono confrontati dall'operatore $ CMP, contengono null. Se uno dei valori è nullo e l'altro ha un numero, l'operatore $ CMP li confronta in modo diverso, che è discusso nel seguente esempio:

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

Esempio 5: utilizzando l'operatore $ CMP in MongoDB per confrontare i diversi tipi

L'operatore $ CMP confronta il valore e i diversi tipi in base all'ordine di confronto fornito. Abbiamo i documenti nella nostra raccolta "MyData" che contiene i diversi tipi di valori. L'operatore $ CMP può confrontarli e generare il risultato in base al tipo di valore. Abbiamo una domanda in cui l'operatore $ Match trova i documenti con il campo "_id". Il campo "_id" impostato all'interno dell'operatore $ match come espressione è inoltre chiamato $ nin operatore. L'operatore $ nin di MongoDB corrisponde solo al documento i cui valori "1, 2, 3" non sono uguali. Successivamente, invochiamo l'operatore $ CMP che confronta i campi di documento abbinati, "$ x" e "$ y", con valori di tipo diversi.

db.I miei dati.aggregato (
[
$ match: "_id": $ nin: [1, 2, 3],
$ Progetto:

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


"
)

Possiamo vedere i valori dei campi "x" e "y" confrontati nell'output e i loro valori risultanti che sono generati dall'operatore $ CMP. Ogni documento abbinato restituisce i diversi valori confrontati.

[
[
_id: 4, misura: 'spostamento', x: null, y: null, res: 0,
_id: 5, misura: 'time', x: null, y: 16, res: -1,

_id: 6,
Misura: "spostamento",
X: isodate ("2020-12-10T05: 00: 20.112Z "),
Y: Isodate ("2023-02-06T05: 00: 20.112Z "),
Res: -1

"

Conclusione

Questa guida ha esplorato l'operatore MongoDB $ CMP per confrontare i valori. Qui, abbiamo discusso dell'operatore $ CMP con esempi. Abbiamo prima confrontato il campo con il valore specificato utilizzando l'operatore $ CMP. Quindi, abbiamo confrontato i due diversi campi e i campi incorporati dall'operatore $ CMP. L'operatore $ CMP viene anche utilizzato per confrontare i valori null. Infine, abbiamo un utilizzo dell'operatore $ CMP per confrontare il valore di diversi tipi.