MongoDB $ Lookup

I documenti vengono passati alla pipeline con più operatori come $ Match e $ esistono per aggregare i dati. L'operatore di ricerca $ è uno degli operatori della pipeline di aggregazione che consente di unirsi ai dati a una raccolta di input. L'operatore di ricerca MongoDB utilizza l'operazione di join esterna sinistra per combinare i dati da un documento a un altro. In parole semplici, il metodo $ Lookup ci consente di "unirci facilmente" le diverse collezioni fornendo i risultati che includono i campi di tutte le collezioni fornite. Il vantaggio principale dell'operatore di ricerca MongoDB $ è che gestisce i dati sul server, il che è molto più veloce rispetto all'esecuzione di diverse query DB e all'analisi dei risultati dal lato client. Discuteremo del principio operativo della ricerca MongoDB $ in questo articolo.

Come funziona l'operatore di ricerca MongoDB $?

Come affermato, l'operatore di ricerca $ in MongoDB ci consente di combinare i documenti da raccolte diverse nello stesso database. L'operatore di ricerca $ gestisce le sotto-domande non correlate e le corrispondenze di uguaglianza. Ogni partita con l'operatore di ricerca $ ha una struttura diversa in cui esamineremo l'implementazione di esempio. Stabiliremo la collezione "candidati" che utilizziamo nel nostro esempio per eseguire l'operatore di ricerca $. Qui, inseriamo due documenti con il metodo InsertMany () che contengono i seguenti campi:

db.Candidati.InsertMany (
[

Candidate_id: 01,
"Nome": "Andrew",
"Rollnumber": 099912,
"Test": "MBBS",
"AcademicStatus": ["Schoolmarks": "A", "CollegeGrades": "B"],
"Stato": "idoneo"
,

Candidate_id: 02,
"Nome": "Stella",
"Rollnumber": 0012123,
"Test": "BDS",
"AcademicStatus": ["Schoolgrades": "A+", "CollegeGrades": "A"],
"Stato": "idoneo"

"
);

I risultati della query inseriti dovrebbero apparire così nella collezione MongoDB:

Successivamente, costruiamo un'altra collezione intitolata "CandidaInfo". Inseriamo il documento in questa raccolta utilizzando il metodo InsertMany ().

db.CandidateInfo.InsertMany (
[

"Candidate_name": "Andrew",
"Age": 27,
"Genere maschile",
"Test": "MBBS",
"Città": "California"
,

"Candidate_name": "Stella",
"Age": 25,
"Genere femminile",
"Test": "BDS",
"Città": "Houston"

"
);

I risultati dell'aggiunta del documento alla raccolta "CandidateInfo" indicano che i documenti sono correttamente inseriti. Ora, possiamo usare entrambe queste collezioni per collegare con l'operatore di ricerca $.

Esempio 1: Utilizzo dell'operatore di ricerca MongoDB $ per l'uguaglianza

L'operatore di ricerca $ di MongoDB è impiegato in questo esempio per unire le operazioni su una chiave dal database indicato e il database combinato. Qui, specifichiamo la query per l'uguaglianza sulla raccolta "candidato" con il metodo aggregato (). Il metodo aggregato () è ulteriormente implementato con l'operatore di ricerca $. L'operatore di ricerca $ contiene diversi vincoli che sono tutti necessari per combinare la raccolta data.

Il primo vincolo schierato è il vincolo "da" che viene assegnato con un nome della raccolta, "CandidaInfo", da unire. Quindi, abbiamo impostato il vincolo "Localfield" in cui è assegnato il nome del campo "Nome" dal documento della raccolta data. Il Localfield è definito come il campo nella collezione locale da combinare. Successivamente, definiamo l'attributo Foreignfield specificato con il campo "Candidate_name" dalla collezione "CandidaInfo" per unirsi alla raccolta "Candidate". Successivamente, il vincolo "AS" viene utilizzato per generare l'array dei risultati abbinati dall'operatore di ricerca $.

db.Candidati.aggregato([
$ Lookup:

Da: "CandidateInfo",
Localfield: "Nome",
Foreignfield: "Candidate_name",
AS: "CandidateInfo"


])

L'output della query di ricerca $ combina le partite della raccolta "CandidateInfo" alla collezione "Candidati" utilizzando i valori di campo "Nome" e "Candidate_Name" nelle raccolte "Candidati" e "CandidaInfo", rispettivamente.

Esempio 2: utilizzando l'operatore di ricerca MongoDB $ con i criteri di selezione

La corrispondenza dell'uguaglianza delle collezioni è realizzata nell'esempio precedente. Ora, utilizziamo l'operatore di ricerca $ con l'operatore condizionale per unirsi alle collezioni. Diamo una query di operatore di ricerca $ nel metodo di aggregazione sulla collezione "CandidateInfo". All'interno del metodo aggregato (), abbiamo l'operatore di ricerca $ specificato con i diversi vincoli per unirsi alle collezioni.

Innanzitutto, definiamo il vincolo "da" definito con un'altra raccolta che è "candidati". Si noti che utilizziamo i vincoli "let" e "pipeline" dopo il vincolo "da" invece di Localfield e Foreignfield. Il vincolo "let" è dichiarato con la variabile "c_age" che è assegnata con un campo "$ age". Viene dichiarata la variabile "C_test" che contiene il nome del campo "$ test". Dichiariamo queste variabili per recuperare i campi dai documenti nella raccolta combinata che vengono passati alla pipeline.

Successivamente, creiamo l'attributo "Pipeline" in cui gli operatori condizionali vengono inseriti. L'uso del vincolo della pipeline è di eseguire l'operazione di join sulla raccolta data. Quindi, la pipeline è associata alla fase di $ Match che imposta ulteriormente la fase di $ EXPR. La fase di $ EXPR confronta i campi usando le variabili di input all'interno dell'attributo "let". La fase $ expr è dichiarata con $ e operatore in cui forniamo il "$ lt: [" $ age "," $$ c_age "]" e $ eq: ["$$ c_test", "$ test" ] espressioni. Possiamo confrontare la raccolta solo in questo modo per l'operatore di ricerca $. Le espressioni sono specificate con il segno a doppio dollaro "$$" per fare riferimento alle variabili che sono definite nel vincolo "let" e il segno singolo in dollari "$" indica un campo estero. L'attributo della pipeline viene quindi chiuso. Infine, definiamo l'attributo "AS" dell'operatore di Lookup $ per dare la collezione "Candidate" da combinare con la collezione "CandidateInfo".

db.CandidateInfo.aggregato([
$ Lookup:

Da: "candidato",
Let: c_age: "$ age", c_test: "$ test",
tubatura: [
$ match:
$ expr:
$ e:
[
$ lt: ["$ age", "$$ c_age"],
$ eq: ["$$ c_test", "$ test"]
"



",
AS: "Candidati"


]).bello();

La seguente uscita viene ottenuta eseguendo la pipeline dell'operatore di ricerca $ con i criteri di selezione:

Esempio 3: Utilizzo dell'operatore di ricerca $ MongoDB $ con l'operatore $ MergeObject

Gli oggetti $ Merge vengono utilizzati per modificare i documenti nella raccolta data che dipendono dai vincoli impostati in $ Lookup OePrator. Qui, abbiamo impostato per la prima volta l'operatore di lookup $ con i suoi vincoli. Quindi, chiamiamo $ MergeObject che imposta anche il suo vincolo per eseguire la raccolta modificata che viene restituita dall'operatore di ricerca $. Nella seguente query, l'operatore di Lookup $ viene utilizzato per unirsi alla collezione "Candidate" dalla "CandidateInfo" utilizzando Localfield e Foreignfield come "Test". Quindi, impieghiamo la fase di $ sostituita che invoca $ MergeObjects per combinare i documenti delle collezioni "candidati" e "candidateInfo".

db.Candidati.aggregato ([

$ Lookup:
Da: "CandidateInfo",
Localfield: "Test",
Foreignfield: "Test",
AS: "Fromcandi"

,

$ repliceroot: newroot: $ MergeObjects: [$ ArrayEleMat: ["$ fromcandi", 0], "$$ root"]
,
$ Progetto: "Fromcandi": 0
])

Dopo aver interrogato questa operazione di ricerca $ con $ MergeObject, abbiamo i seguenti risultati:

Conclusione

L'operatore di ricerca $ aiuta a identificare i dati appropriati e ad acquisire i risultati desiderati. Abbiamo implementato tre esempi utilizzando l'operatore $ Lookup. Nel primo esempio, abbiamo usato l'operatore di ricerca $ per la corrispondenza dell'uguaglianza. Quindi, abbiamo un esempio in cui le condizioni vengono utilizzate per eseguire i risultati dell'operatore di ricerca. Abbiamo anche usato la fase di $ MergeObjects con l'operatore $ Lookup per modificare i documenti.