Operatore di filtri MongoDB $
Come viene utilizzato l'operatore di $ filtro in mongodb
L'operatore di $ filtri $ di MongoDB viene utilizzato per filtrare i dati dell'array in base alla dichiarazione condizionale data. L'utilizzo dell'operatore del filtro $ funziona sui documenti inseriti nella raccolta specificata di MongoDB. Qui, distribuiamo la query InsertMany () di MongoDB per inserire tre documenti nella collezione "Cricket". Ogni record contiene tre campi - "_id", "giocatore" e "runsrecord" - che sono impostati come un array. Il formato di inserimento del documento è rappresentato nel seguente:
db.Cricket.insertMany ([
"_id": 1,
"giocatore": "Ravi",
"Runsrecord": [100, 50, 70],
"Matches":
"Match1": "WorldCup",
"Anno": "2000"
,
"_id": 2,
"giocatore": "Andrew",
"Runsrecord": [150, 90, 55]
,
"_id": 3,
"giocatore": "Smith",
"Runsrecord": [80, 99, 45]
,
"_id": 4,
"giocatore": "Alex",
"RunSrecord": []
])
I documenti nella raccolta "cricket" sono inseriti correttamente come mostrato nella seguente uscita:
riconosciuto: True, InsertedIds: '0': 1, '1': 2, '2': 3, '3': 4
Esempio 1: MongoDB utilizza l'operatore di $ Filtro in MongoDB
In questa sezione è riportato l'operatore di Basic $ Filter dell'esempio MongoDB. Abbiamo impostato una query in cui l'operatore del progetto $ viene chiamato nel metodo aggregato. Invochiamo l'operatore di $ Filter all'interno dell'operatore $ Project. L'operatore di filtro $ è ulteriormente specificato con il suo parametro. Il parametro "input" è impostato con il nome del campo array "$ runsrecord" con il segno "$" per estrarre i dati da esso. Quindi, utilizziamo il parametro "AS" per dare il titolo alla variabile di ritorno, "RunsRecord". Questa variabile viene quindi indicata utilizzando il parametro "cond" con il segno doppio dollaro, "$$". Il prossimo è il parametro "cond" in cui l'espressione è assegnata come "$ gt: [" $$ runsrecord ", 50]". Le condizioni implicano che l'operatore "$ gt" ottiene l'elemento array che è maggiore del valore di "50" nel campo array "runsrecord".
db.Cricket.aggregato([
$ Progetto:
HighRuns:
$ filtro:
Input: "$ runsrecord",
AS: "RunSrecord",
cond: $ gt: ["$$ runsrecord", 50]
])
I risultati della seguente query di $ Filter restituiscono solo quei valori dall'array che è maggiore "50". Il valore che è inferiore a "50" è ignorato dall'operatore di $ filtri.
[
_id: 1, Highruns: [100, 70],
_id: 2, Highruns: [150, 90, 55],
_id: 3, Highruns: [80, 99],
_id: 4, highruns: []
"
Esempio 2: MongoDB utilizza l'operatore $ filtri per filtrare il campo di non esistenza
Ora, prendiamo un caso in cui l'operatore del filtro $ viene applicato sul campo che non è presente in alcun documento di raccolta inseriti. Qui, abbiamo una domanda in cui l'operatore di $ filtri è impiegato con i parametri. Il parametro di input è impostato con il campo "$ stipendio" per filtrare il documento. Quindi, utilizziamo il parametro opzionale "AS" che viene anche fornito con il nome della variabile, "stipendio", che viene utilizzato nell'array di input come elemento. Successivamente, abbiamo un'espressione condizionale nel parametro "cond" di $ filtro. L'operatore di $ filtri $ filtra l'elemento array in base alla condizione specificata che è "$ gte: [" $$ stipendio ", 6000]".
db.Cricket.aggregato([
$ match: _id: $ in: [2]
,
$ Progetto:
HighRuns:
$ filtro:
Input: "$ stipendio",
AS: "Stipendio",
cond: $ gte: ["$$ Stipendio", 6000]
])
Come sappiamo, il campo "stipendio" fornito non è presente nel documento il cui "_id" è "2", quindi l'output della query precedente dell'operatore del filtro $ fornisce un valore nullo.
[_id: 2, highruns: null]
Esempio 3: MongoDB utilizza l'operatore $ filtri per filtrare l'array vuoto
Il prossimo è lo scenario in cui il filtro $ viene impiegato sul array vuoto. L'operatore di $ filtro $ restituisce un set di array vuoto se uno dei documenti nella raccolta ha un array vuoto. Abbiamo la seguente query per operatore di filtri $. Abbiamo prima l'operatore $ match in cui è prevista l'espressione "_id: $ in: [4]". Quando l'operatore $ in trova il valore di "4" rispetto al campo "_id", l'operatore successivo procede. Quindi, abbiamo un operatore di $ filtri che filtra l'array di elementi in base alla condizione data che è "$ gt: [" $$ runsrecord ", 45]".
db.Cricket.aggregato([
$ match: _id: $ in: [4]
,
$ Progetto:
HighRuns:
$ filtro:
Input: "$ runsrecord",
AS: "RunSrecord",
cond: $ gt: ["$$ runsrecord", 45]
])
Il "_id: 4" ha il campo array "runsrecord" che è vuoto. Ecco perché quando viene eseguita la query, emette l'array vuoto come segue:
[_id: 4, highruns: []]
ESEMPIO 4: MongoDB utilizza l'operatore di filtro $ in MongoDB con il nome della variabile opzionale
Abbiamo impostato un titolo sulla variabile nelle istanze precedenti usando l'argomento "As". Se l'argomento "AS" non è impostato con alcun nome di variabile, la variabile "$ this" è impostata per impostazione predefinita da MongoDB. Facciamo l'esempio di query per questa affermazione. Abbiniamo il documento chiamando l'operatore $ match in cui abbiamo un campo "_id" in cui sono impostati i valori. Assegniamo un operatore di $ filtro all'operatore "$ progetto" in cui viene chiamato l'operatore di $ filtro con i parametri. Qui, abbiamo un parametro "input" con il nome del campo array "$ runsrecord". Quindi, applichiamo il parametro "cond" con la condizione specificata. La condizione è impostata come "cond: $ lt: [" $$ this ", 80]". Questa volta, l'operatore $ LT viene utilizzato per trovare il valore inferiore al valore di "80". Si noti che invece di un nome variabile "$$ runsrecord", utilizziamo il nome della variabile predefinita "$$ this" qui che non influisce sull'output risultante.
db.Cricket.aggregato([
$ match: _id: $ in: [1, 2, 3, 4]
,
$ Progetto:
HighRuns:
$ filtro:
Input: "$ runsrecord",
cond: $ lt: ["$$ this", 80]
])
L'operatore di $ filtri $ filtra l'array specificato con $ questa variabile allo stesso modo della variabile specificata.
[
_id: 1, Highruns: [50, 70],
_id: 2, highruns: [55],
_id: 3, Highruns: [45],
_id: 4, highruns: []
"
Esempio 5: MongoDB utilizza l'operatore da filtro $ per filtrare con più condizioni
Possiamo fornire più di una condizione all'operatore di $ filtri per filtrare solo quei documenti che corrispondono alla condizione data. Qui, definiamo l'operatore di $ filtro in cui l'operatore $ e l'operatore viene utilizzato nel parametro "cond". Il $ e l'operatore sono impostati con le molteplici condizioni come "$ gte: [" $$ runsrecord ", 45]" e "$ lte: [" $$ runsrecord ", 99]". Vengono utilizzati $ e l'operatore che richiedono entrambe le condizioni come vere.
db.Cricket.aggregato([
$ Progetto:
HighRuns:
$ filtro:
Input: "$ runsrecord",
AS: "RunSrecord",
cond: $ e: [
$ gte: ["$$ runsrecord", 45],
$ lte: ["$$ runsrecord", 99]
]
])
Con le condizioni multiple, filtriamo il documento abbinato nel seguente:
[
_id: 1, Highruns: [50, 70],
_id: 2, Highruns: [90, 55],
_id: 3, Highruns: [80, 99, 45],
_id: 4, highruns: []
"
Conclusione
Abbiamo esplorato questo articolo che riguarda l'operatore di $ filtri di MongoDB. Qui, abbiamo fornito l'implementazione dello script MongoDB dell'operatore di $ Filter per filtrare i dati specificati. Abbiamo dimostrato per la prima volta l'uso di base dell'operatore di $ filtri. Quindi, abbiamo utilizzato l'operatore di $ filtri $ sul documento il cui campo non è aggiunto nel documento. La custodia del campo dell'array vuota viene anche distribuita sull'operatore di filtro $ che recupera l'array vuoto. Inoltre, l'operatore $ filtro viene utilizzato con $ questa variabile che è la variabile predefinita.