Consultas MongoDB: como funcionam as consultas de dados

Com as consultas do MongoDB (também chamadas de queries), pode pesquisar e analisar a sua base de dados de forma rápida e eficaz. A estrutura do método é muito lógica e permite utilizar pa­râ­me­tros para res­trin­gir as consultas.

Pesquisa eficaz em coleções

O MongoDB é uma solução do­cu­men­tal NoSQL com a qual é possível armazenar e gerir fa­cil­mente grandes quan­ti­da­des de dados diversos. O sistema de gestão de bases de dados é muito flexível e tem uma es­ca­la­bi­li­dade ho­ri­zon­tal simples.

Ao contrário das bases de dados re­la­ci­o­nais, neste caso os dados são ar­ma­ze­na­dos em do­cu­men­tos BSON (JSON binário) e agrupados em coleções. No entanto, para que isso ocorra, são ne­ces­sá­rios me­ca­nis­mos de consulta poderosos que possam filtrar a base de dados e apre­sen­tar apenas as in­for­ma­ções ne­ces­sá­rias. Essas consultas do MongoDB pesquisam até mesmo em coleções complexas e fornecem as in­for­ma­ções pro­cu­ra­das.

O que são consultas MongoDB?

O MongoDB queries é uma fer­ra­menta intuitiva que serve para pesquisar em es­tru­tu­ras de dados complexas. Segue regras lógicas e funciona como as opções de filtro de muitas páginas web, pelo que é possível realizar uma pesquisa muito restrita e obter os melhores re­sul­ta­dos. Isto é es­pe­ci­al­mente im­por­tante, uma vez que o MongoDB permite armazenar muitos tipos di­fe­ren­tes de dados e, se não exis­tis­sem as opções de filtragem ne­ces­sá­rias, seria difícil gerir uma base de dados. A seguir, ex­pli­ca­mos passo a passo como criar fa­cil­mente consultas no MongoDB e como utilizá-las.

Quais são os re­qui­si­tos para usar as consultas MongoDB?

Para utilizar as consultas MongoDB, são ne­ces­sá­rios apenas alguns re­qui­si­tos.

1. Primeiro, deve instalar o MongoDB no seu com­pu­ta­dor. A base de dados funciona em muitos sistemas ope­ra­ti­vos, pelo que pode seguir estas ins­tru­ções com Linux, OS X ou Windows. Os passos após a ins­ta­la­ção são os mesmos em todos os sistemas e afetam apenas a própria base de dados. No nosso tutorial do MongoDB pode ler como funciona a ins­ta­la­ção.
2. Para utilizar a função de pesquisa, é ne­ces­sá­rio ter direitos de ad­mi­nis­tra­dor.
3. O melhor é criar um ambiente de teste para utilizar o método pela primeira vez sem riscos. A seguir, ex­pli­ca­mos quais passos seguir.

Estrutura de uma coleção de teste

Primeiro, abra o Shell e inicie sessão com os seus dados de ad­mi­nis­tra­dor. Em seguida, crie uma nova coleção, que servirá como ambiente de teste para realizar as suas primeiras consultas MongoDB. O método não leva em con­si­de­ra­ção apenas do­cu­men­tos simples, mas também matrizes, vários campos e do­cu­men­tos in­cor­po­ra­dos. Para de­mons­trar o alcance das consultas MongoDB, vamos criar uma coleção um pouco mais complexa.

Como exemplo, vamos ter uma lista de clientes. O formato deve ser o seguinte:

{
    "name" : "Sanz",
    "units" : 642,
    "location" : [ "Germany", "Austria" ],
    "transactions" : {
        "first" : {
            "year" : 2017,
        },
        "last" : {
            "year" : 2023,
        },
        "total" : 14
    }
}

Este documento contém as seguintes in­for­ma­ções:

• name: o nome da empresa do cliente que vendeu a mer­ca­do­ria.
• unidades: a quan­ti­dade total de produtos que a empresa en­co­men­dou.
• lo­ca­li­za­ção: a sede da outra empresa. Se houver mais filiais, estas podem ser guardadas na forma de matriz.
• tran­sac­ti­ons: este campo contém agora outro documento que é in­cor­po­rado ou aninhado (em inglês, fala-se de «embedded documents» ou «nested documents»). Cada documento de transação contém in­for­ma­ções sobre o tempo que a empresa é cliente (no ponto «first»), quando foi feito o último pedido (no ponto «last») e, por último, quantas vezes fez pedidos (no ponto «total»).

Neste caso, os do­cu­men­tos adi­ci­o­nais foram incluídos para poder adicionar mais in­for­ma­ções pos­te­ri­or­mente. Assim, os dados continuam or­ga­ni­za­dos.

Criação da coleção de teste para as consultas MongoDB

Agora vamos criar uma coleção chamada «Clientes», que no nosso exemplo deve conter apenas cinco entradas para uma melhor or­ga­ni­za­ção. Se mais tarde quiser utilizar consultas MongoDB de forma pro­fis­si­o­nal, poderá criar coleções muito mais extensas através do método in­sert­Many. Assim ficaria o nosso exemplo:

db.clientes.insertMany ( [
{
    "name" : "Sanz",
    "units" : 642,
    "location" : [ "Germany", "Austria" ],
    "transactions" : {
        "first" : {
            "year" : 2017,
        },
        "last" : {
            "year" : 2023,
        },
        "total" : 14
    }
},
{
    "name" : "ATS",
    "units" : 17,
    "location" : "France",
    "transactions" : {
        "first" : {
            "year" : 2021,
        },
        "last" : {
            "year" : 2022,
        },
        "total" : 2,
    }
},
{
    "name" : "Murillo",
    "units" : 814,
    "location" : [ "Austria", "Germany" ],
    "transactions" : {
        "first" : {
            "year" : 2016,
        },
        "last" : {
            "year" : 2023,
        },
        "total" : 22,
    }
},
{
    "name" : "Pawolski",
    "units" : 313,
    "location" : [ "Germany", "Poland" ],
    "transactions" : {
            "first" : {
            "year" : 2017,
            },
        "last" : {
            "year" : 2020,
        },
        "total" : 9,
    }
},
{
    "name" : "Jorgensen",
    "units" : 7,
    "location" : "Dinamarca",
    "transactions" : {
        "first" : {
            "year" : 2022,
        },
        "last" : {
            "year" : 2023,
        },
        "total" : 2,
    }
}
] )

Se copiar esta entrada ou preenchê-la com os seus próprios dados, receberá uma lista dos IDs de objeto atri­buí­dos. Estes são únicos e garantem que cada documento também possa ser en­con­trado através do ID. Se quiser garantir que todos os do­cu­men­tos foram trans­fe­ri­dos para a coleção, pode utilizar o MongoDB find em vez de continuar a in­tro­du­zir pa­râ­me­tros adi­ci­o­nais:

db.clientes.find ( )

Como resultado, obtém-se uma lista de todos os Object ID com os do­cu­men­tos completos, que agora poderá explorar com consultas MongoDB.

Consultar campos in­di­vi­du­ais com consultas MongoDB

Este resultado por si só destaca o valor acres­cen­tado oferecido pelas consultas MongoDB. Mesmo no nosso pequeno exemplo, o resultado terá longas cadeias de ca­rac­te­res, o que, no mínimo, di­fi­cul­tará muito a sua análise se não tiver outras fer­ra­men­tas. Por isso, a seguir, também uti­li­za­re­mos o método find, mas es­pe­ci­fi­cando a pesquisa. Para isso, vamos definir um requisito especial que um documento deve cumprir para aparecer nos re­sul­ta­dos. No nosso exemplo, pro­cu­ra­mos todos os do­cu­men­tos cujo nome cor­res­ponda ao valor «ATS». Deve ficar assim:

db.clientes.find (
    { "name" : "ATS" }
)

As consultas MongoDB simples deste tipo procuram agora todos os do­cu­men­tos ar­ma­ze­na­dos na coleção cor­res­pon­dente e mostram as cor­res­pon­dên­cias com o valor do nome «ATS». Na nossa coleção, existe apenas uma entrada com este valor, pelo que o resultado será o seguinte:

db.clientes.find ( { "name" : "ATS" } )
{
    "_id" : ObjectID ( "673d14684o75iftbb0ct5003" ),
    "name" : "ATS",
    "units" : 17,
    "location" : "France",
    "transactions" : {
        "first" : {
            "year" : 2021,
        },
        "last" : {
            "year" : 2022,
        },
        "total" : 2
    }

Também é possível fazer o contrário. Se quiser mostrar todos os re­sul­ta­dos, exceto a entrada com «ATS», escreva da seguinte forma:

db.clientes.find (
    { "name" : { $ne : "ATS" } }
)

Se quiser gerar consultas MongoDB com valores di­fe­ren­tes, também pode fazê-lo com uma matriz. No nosso exemplo, in­tro­du­zi­mos os clientes «ATS» e «Jorgensen».

db.clientes.find (
    { "name" : [ $in : [ "ATS", "Jorgensen" ] } }
)

Consultar vários campos com consultas MongoDB

Se precisar de re­sul­ta­dos muito precisos, é im­por­tante res­trin­gir ainda mais a consulta. Para isso, pode es­pe­ci­fi­car as consultas MongoDB uti­li­zando pa­râ­me­tros adi­ci­o­nais. Se agora fizermos uma consulta es­pe­ci­fi­cando o valor do segmento «units» (unidades), além do nome da empresa «ATS», será procurado um documento que contenha ambos os valores:

db.clientes.find (
    { "name" : "ATS", "units" : 17 }
)

Neste caso, obtém-se novamente uma cor­res­pon­dên­cia exata. No entanto, se um dos dois valores não tiver cor­res­pon­dên­cias, não será obtido nenhum resultado. Por exemplo, esta entrada não teria re­sul­ta­dos:

db.clientes.find (
    { "name" : "ATS", "units" : 25 }
)

No entanto, se quiser utilizar consultas MongoDB para con­si­de­rar di­fe­ren­tes valores, mas quiser que a entrada seja feita apenas quando pelo menos um dos re­qui­si­tos for cumprido, introduza o seguinte:

db.clientes.find (
    { $or : [ {"name" : "ATS"}, { "units" : 25 } ] }
)

Consultar valores em matrizes

Os valores das matrizes também podem ser con­si­de­ra­dos nas consultas do MongoDB. No nosso caso, há empresas que têm filiais em vários países. Por exemplo, pode obter todos os clientes que têm pelo menos uma filial na Alemanha:

db.clientes.find (
    { "location" : "Germany" }
)

O resultado agora contém os três clientes que têm pelo menos uma filial na Alemanha. No entanto, se quiser expandir a entrada e recuperar os clientes com filiais na Alemanha e também na Áustria, deve utilizar uma matriz:

db.clientes.find (
    { "location" : [ "Germany", "Austria" ] }
)

Como pode observar, obtém-se apenas um resultado, embora, em teoria, duas empresas cor­res­pon­dam aos critérios de pesquisa. Isto deve-se ao facto de as consultas MongoDB terem em conta a entrada exata e, portanto, neste caso, a ordem. No entanto, se quiser obter valores que podem estar em qualquer ordem numa matriz, faça a consulta desta forma:

db.clientes.find (
    { "location" : { $all : [ "Germany", "Austria" ] } }
)

Consultas MongoDB para do­cu­men­tos in­cor­po­ra­dos

No nosso exemplo, também uti­li­zá­mos do­cu­men­tos in­cor­po­ra­dos (ou do­cu­men­tos aninhados). Estes também podem aparecer nos re­sul­ta­dos ao utilizar consultas MongoDB. Para isso, é ne­ces­sá­rio adicionar um ponto para indicar ao MongoDB que os campos de um documento in­cor­po­rado devem ser ana­li­sa­dos. Por exemplo, se precisar de uma lista dos clientes que têm mais de dez tran­sa­ções de encomenda, introduza o seguinte:

db.clientes.find (
    { "transactions.total" : { $gt : 10 } }
)

O MongoDB acede ao documento «tran­sac­ti­ons» e, em seguida, considera o número total de tran­sa­ções de en­co­men­das.

Consultas MongoDB: limitar o resultado

Mesmo depois de aprender os métodos men­ci­o­na­dos, é possível que os re­sul­ta­dos obtidos com as consultas MongoDB pareçam muito extensos. Talvez queira limitar o resultado a alguns campos. Para isso, utilizam-se as chamadas projeções, que contêm o valor 1 (para campos incluídos) e 0 (para campos que devem ser excluídos). No exemplo a seguir, vamos realizar uma consulta em duas partes. Primeiro, inicia-se uma pesquisa sem pa­râ­me­tros que conteria todas as in­for­ma­ções. Ime­di­a­ta­mente depois, realiza-se uma projeção que leva em con­si­de­ra­ção apenas o campo do nome.

db.clientes.find (
    { }
    { "name" : 1 }
)

Assim, pode obter todos os dados, mas o resultado será limitado aos nomes cor­res­pon­den­tes.

Utilizar cursores para otimizar o resultado

Os cursores são métodos que não controlam os re­sul­ta­dos das consultas do MongoDB em si, mas per­so­na­li­zam a sua vi­su­a­li­za­ção. Por exemplo, pode limitar o número de re­sul­ta­dos ou alterar a sua ordem. Se quiser mostrar apenas dois dos re­sul­ta­dos, deve utilizar o método limit. Funciona assim:

db.clientes.find (
    { }
    { "name" : 1 }
).limit ( 2 )

Com o seguinte comando, pode ordenar o resultado e obter os três clientes que menos produtos en­co­men­da­ram:

db.clientes.find (
    { }
    { "name" : 1 }
).limit ( 2 ) .sort ( { "units" : 1 } )