MongoDB $ Lookup

Os documentos são passados ​​para o pipeline com vários operadores, como $ Match e $. O operador de pesquisa $ é um dos operadores do pipeline de agregação que permite que os dados sejam unidos a uma coleção de entrada. O operador de pesquisa do MongoDB usa a operação de junção externa esquerda para combinar os dados de um documento para outro. Em palavras simples, o método $ Lookup nos permite “ingressar” facilmente as diferentes coleções, fornecendo os resultados que incluem os campos de todas as coleções dadas. A principal vantagem do operador de pesquisa MongoDB $ é que ele lida com os dados no servidor, que é muito mais rápido do que executar várias consultas de banco de dados e analisar os resultados do lado do cliente. Discutiremos sobre o princípio operacional do MongoDB $ neste artigo.

Como funciona o operador de pesquisa MongoDB $?

Como afirmado, o operador de pesquisa $ em MongoDB nos permite combinar os documentos de diferentes coleções no mesmo banco de dados. O operador $ Lookup lida com as sub-questões não relacionadas, bem como as correspondências da igualdade. Cada correspondência com o operador de pesquisa $ tem uma estrutura diferente na qual veremos com o exemplo de implementação. Estabelecemos a coleção "candidatos" que usamos em nosso exemplo para executar o operador $ Lookup. Aqui, inserimos dois documentos com o método insertMany () que contêm os seguintes campos:

dB.Candidatos.InsertMany (
[[

Candidato_id: 01,
"Nome": "Andrew",
"RollNumber": 099912,
"Teste": "MBBS",
"AcademicStatus": ["Schoolks": "A", "CollegeGrades": "B"],
"Status": "elegível"
,

Candidato_id: 02,
"Nome": "Stella",
"RollNumber": 0012123,
"Teste": "BDS",
"AcademicStatus": ["SchoolGrades": "A+", "CollegeGrades": "A"],
"Status": "elegível"

]
);

Os resultados da consulta inserida devem aparecer assim na coleção MongoDB:

Em seguida, construímos outra coleção que é intitulada "candidatoinfo". Inserimos o documento nesta coleção, utilizando o método insertMany ().

dB.CandidatoInfo.InsertMany (
[[

"Candidato_name": "Andrew",
"Idade": 27,
"Género masculino",
"Teste": "MBBS",
"Cidade": "Califórnia"
,

"Candidato_name": "Stella",
"Idade": 25,
"Sexo: Feminino",
"Teste": "BDS",
"City": "Houston"

]
);

Os resultados de adicionar o documento à coleção "candidatoinfo" indica que os documentos são inseridos corretamente. Agora, podemos usar essas duas coleções para vincular -se ao operador de pesquisa $.

Exemplo 1: Usando o operador de pesquisa MongoDB $ para a correspondência de igualdade

O operador de pesquisa $ MongoDB é empregado neste exemplo para mesclar as operações em uma chave do banco de dados especificado e do banco de dados combinado. Aqui, especificamos a consulta de correspondência de igualdade na coleção "candidato" com o método agregate (). O método agregate () é ainda mais implementado com o operador de pesquisa $. O operador de pesquisa $ contém restrições diferentes que são necessárias para combinar a coleção fornecida.

A primeira restrição implantada é a restrição "de" que é atribuída com um nome da coleção, "candidatoinfo", a ser acompanhado. Em seguida, definimos a restrição "Localfield", onde o nome do campo "Nome" do documento da coleção fornecida é atribuído. O campo local é definido como o campo da coleção local a ser combinado. Em seguida, definimos o atributo estrangeiro especificado com o campo "candidato_name" da coleção "CandidateInfo" para se fundir com a coleção "candidato". Depois disso, a restrição “AS” é usada para gerar a matriz dos resultados correspondentes do operador $ Lookup.

dB.Candidatos.agregar([
$ Lookup:

De: "candidatoinfo",
Localfield: "Nome",
Fourlingfield: "candidato_name",
AS: "candidatoinfo"


]))

A saída da consulta $ Lookup combina as partidas da coleção "CandidateInfo" com a coleção "Candidatos" usando os valores de campo "nome" e "candidato_name" nas coleções "candidatos" e "candidatos", respectivamente, respectivamente, respectivamente.

Exemplo 2: Usando o operador de pesquisa MongoDB $ com os critérios de seleção

A correspondência de igualdade das coleções é realizada no exemplo anterior. Agora, usamos o operador de pesquisa $ com o operador condicional para ingressar nas coleções. Damos uma consulta de operador de pesquisa $ no método de agregação na coleção "candidatoinfo". Dentro do método agregate (), temos o operador de pesquisa $ especificado com as diferentes restrições para ingressar nas coleções.

Primeiro, definimos a restrição "de" que é definida com outra coleção que é "candidatos". Observe que usamos as restrições "Let" e "Pipeline" após a restrição "de" em vez do campo local e do Foreignfield. A restrição "Let" é declarada com a variável "c_age", que é atribuída com um campo "$ AGE". A variável "c_test" é declarada que contém o nome do campo "$ teste". Declaramos essas variáveis ​​para recuperar os campos dos documentos na coleção combinada que são passados ​​para o pipeline.

Depois disso, criamos o atributo "pipeline", onde os operadores condicionais são inseridos. O uso da restrição de pipeline é executar a operação de junção sobre a coleção fornecida. Em seguida, o oleoduto está associado ao estágio $ da partida, que define ainda mais o estágio $ expr. O estágio $ expr compara os campos usando as variáveis ​​de entrada no atributo "let". O estágio $ expr é declarado com o $ e o operador onde fornecemos o "$ lt: [" $ AGE "," $$ c_age "]" e $ eq: ["$$ c_test", "$ test" ] expressões. Podemos comparar a coleção apenas dessa maneira para o operador $ Lookup. As expressões são especificadas com o sinal de duplo dólar "$$" para se referir às variáveis ​​que são definidas na restrição "Let" e o sinal de dólar único "$" indica um campo estrangeiro. O atributo do pipeline é então fechado. Por fim, definimos o atributo "AS" do operador de $ Lookup para dar a coleção "candidato" para combinar com a coleção "candidatoinfo".

dB.CandidatoInfo.agregar([
$ Lookup:

De: "Candidato",
Let: c_age: "$ AGE", c_test: "$ test",
oleoduto: [
$ Match:
$ expr:
$ e:
[[
$ lt: ["$ AGE", "$$ c_age"],
$ eq: ["$$ c_test", "$ test"]
]



],
AS: "Candidatos"


])).bonito();

A saída a seguir é obtida executando o pipeline de operador de pesquisa $ com os critérios de seleção:

Exemplo 3: Usando o operador MongoDB $ Lookup com o operador $ MergeObject

Os objetos $ Merge são usados ​​para alterar os documentos na coleção fornecida que dependem das restrições definidas no $ Lookup Oeprator. Aqui, primeiro definimos o operador de pesquisa $ com suas restrições. Em seguida, chamamos o $ MergeObject, que também define sua restrição para executar a coleção modificada que são devolvidos do Operador $ Lookup. Na consulta a seguir, o operador de pesquisa $ é usado para ingressar na coleção "candidato" do "candidatoinfo" usando o campo local e o Fourlousfield como "teste". Em seguida, empregamos o estágio $ replaceroot, que chama os $ mergeoBjects para combinar documentos das coleções "candidatos" e "candidatoinfo".

dB.Candidatos.agregado ([

$ Lookup:
De: "candidatoinfo",
Localfield: "Teste",
Foreignfield: "Teste",
AS: "Fromcandi"

,

$ replaceroot: newroot: $ mergeObjects: [$ ArrayElemat: ["$ fromCandi", 0], "$$ root"]
,
$ Project: "Fromcandi": 0
]))

Depois de consultar esta operação de pesquisa $ com o $ MergeObject, temos os seguintes resultados:

Conclusão

O operador de pesquisa $ ajuda a identificar os dados apropriados e adquirir os resultados desejados. Implementamos três exemplos usando o $ Lookup Operator. No primeiro exemplo, usamos o operador de pesquisa $ para correspondência de igualdade. Em seguida, temos um exemplo em que as condições são usadas para executar os resultados do operador de pesquisa. Também usamos o estágio $ MergeObjects com o operador de pesquisa $ para modificar os documentos.