Filtrar Coleções MongoDB

Introdução

Neste laboratório, você aprenderá como filtrar coleções MongoDB de forma eficaz usando várias técnicas de consulta. O laboratório abrange a aplicação de múltiplas condições, o uso de operadores de comparação, a correspondência com expressões regulares, a verificação da existência de campos e a busca por valores nulos. Essas habilidades são essenciais para a recuperação precisa de dados no MongoDB. As instruções passo a passo fornecem exemplos práticos para ajudá-lo a dominar os fundamentos das consultas MongoDB.

Aplicar Múltiplas Condições

Nesta etapa, você aprenderá a aplicar múltiplas condições para filtrar documentos em uma coleção MongoDB. Isso permite consultas mais precisas ao combinar vários critérios.

Primeiro, abra seu terminal e inicie o MongoDB Shell. Este shell interativo é onde você executará todos os seus comandos de banco de dados.

mongosh

Uma vez dentro do shell mongosh, você verá um prompt >. Vamos mudar para um novo banco de dados chamado school_database e criar uma coleção students com alguns dados de exemplo.

use school_database

db.students.insertMany([
  { name: "Alice", age: 22, grade: "A", major: "Computer Science" },
  { name: "Bob", age: 20, grade: "B", major: "Mathematics" },
  { name: "Charlie", age: 25, grade: "A", major: "Physics" },
  { name: "David", age: 19, grade: "C", major: "Computer Science" }
]);

Este comando insere quatro documentos na coleção students. Agora, vamos encontrar alunos que atendam a múltiplas condições. Usaremos o operador $and para encontrar alunos que tenham 20 anos ou mais E tenham a nota "A".

db.students.find({
  $and: [{ age: { $gte: 20 } }, { grade: "A" }]
});

Esta consulta usa $gte, que significa "maior ou igual a" (greater than or equal to), e $and para garantir que ambas as condições sejam atendidas. A saída mostrará Alice e Charlie:

[
  {
    _id: ObjectId("..."),
    name: 'Alice',
    age: 22,
    grade: 'A',
    major: 'Computer Science'
  },
  {
    _id: ObjectId("..."),
    name: 'Charlie',
    age: 25,
    grade: 'A',
    major: 'Physics'
  }
]

Em seguida, usaremos o operador $or para encontrar documentos que correspondam a pelo menos uma de várias condições. Esta consulta encontra alunos que estão cursando "Computer Science" OU têm menos de 21 anos.

db.students.find({
  $or: [{ major: "Computer Science" }, { age: { $lt: 21 } }]
});

Esta consulta usa $lt, que significa "menor que" (less than). O resultado incluirá Alice e David (estudantes de Ciência da Computação) e Bob e David (com menos de 21 anos). Como David atende a ambas as condições, ele aparece uma vez.

[
  {
    _id: ObjectId("..."),
    name: 'Alice',
    age: 22,
    grade: 'A',
    major: 'Computer Science'
  },
  {
    _id: ObjectId("..."),
    name: 'Bob',
    age: 20,
    grade: 'B',
    major: 'Mathematics'
  },
  {
    _id: ObjectId("..."),
    name: 'David',
    age: 19,
    grade: 'C',
    major: 'Computer Science'
  }
]

Na próxima etapa, você explorará mais operadores de comparação. Por enquanto, você pode permanecer no shell mongosh.

Usar Operadores de Comparação

Nesta etapa, você usará os operadores de comparação do MongoDB para construir consultas mais sofisticadas. Esses operadores permitem filtrar dados com base em comparações de valores.

Você ainda deve estar no shell mongosh da etapa anterior. Primeiro, vamos limpar a coleção existente e inserir novos dados com um campo credits para trabalhar.

db.students.drop();

db.students.insertMany([
  {
    name: "Alice",
    age: 22,
    grade: "A",
    major: "Computer Science",
    credits: 45
  },
  { name: "Bob", age: 20, grade: "B", major: "Mathematics", credits: 35 },
  { name: "Charlie", age: 25, grade: "A", major: "Physics", credits: 50 },
  { name: "David", age: 19, grade: "C", major: "Computer Science", credits: 25 }
]);

Agora, vamos usar os operadores "maior que" ($gt) e "menor que" ($lt) para encontrar alunos que têm mais de 20 anos, mas menos de 25.

db.students.find({ age: { $gt: 20, $lt: 25 } });

Esta consulta retornará apenas o documento de Alice, que tem 22 anos.

Em seguida, use "maior ou igual a" ($gte) e "menor ou igual a" ($lte) para encontrar alunos com créditos entre 40 e 50, inclusive.

db.students.find({ credits: { $gte: 40, $lte: 50 } });

Esta consulta retornará Alice (45 créditos) e Charlie (50 créditos).

Finalmente, vamos usar o operador "diferente de" ($ne) para encontrar todos os alunos cuja nota não seja "C".

db.students.find({ grade: { $ne: "C" } });

Isso retornará Alice, Bob e Charlie, excluindo David, que tem a nota "C". Esses operadores são fundamentais para criar consultas detalhadas e específicas no MongoDB.

Corresponder com Expressões Regulares

Expressões regulares (regex) fornecem uma maneira flexível de realizar buscas de texto poderosas. Nesta etapa, você aprenderá como usar regex em suas consultas MongoDB.

Primeiro, vamos preparar os dados para esta etapa. Limpe a coleção e insira novos documentos com campos de string mais detalhados.

db.students.drop();

db.students.insertMany([
  {
    name: "Alice Johnson",
    age: 22,
    major: "Computer Science",
    email: "alice.j@example.com"
  },
  {
    name: "Bob Smith",
    age: 20,
    major: "Mathematics",
    email: "bob.smith@university.edu"
  },
  {
    name: "Charlie Brown",
    age: 25,
    major: "Physics",
    email: "charlie.brown@school.org"
  },
  {
    name: "David Lee",
    age: 19,
    major: "Computer Engineering",
    email: "david.lee@tech.net"
  }
]);

Para encontrar todos os alunos cujos nomes começam com "Alice", você pode usar o operador $regex com a âncora ^.

db.students.find({ name: { $regex: "^Alice" } });

Esta consulta retornará o documento de "Alice Johnson". O caractere ^ significa o início da string.

Para encontrar alunos com um endereço de e-mail de um domínio específico, como example.com, use a âncora $ para corresponder ao final da string.

db.students.find({ email: { $regex: "@example.com$" } });

Isso encontrará "Alice Johnson", cujo e-mail termina com @example.com.

Você também pode realizar buscas que não diferenciam maiúsculas de minúsculas. A seguinte consulta encontra qualquer aluno com "smith" em seu nome, independentemente do caso, usando a opção i.

db.students.find({ name: { $regex: "smith", $options: "i" } });

Esta consulta corresponderá a "Bob Smith".

Finalmente, para encontrar qualquer curso que contenha a palavra "Computer", você pode usar um padrão de regex simples sem âncoras.

db.students.find({ major: { $regex: "Computer" } });

Isso retornará tanto "Alice Johnson" (Computer Science) quanto "David Lee" (Computer Engineering).

Verificar Existência de Campo

Às vezes, os documentos em uma coleção têm estruturas diferentes. Esta etapa ensina como consultar documentos com base na existência ou não de um campo específico.

Vamos começar inserindo um novo conjunto de documentos onde alguns campos estão faltando.

db.students.drop();

db.students.insertMany([
  { name: "Alice", age: 22, major: "Computer Science", scholarship: 1000 },
  { name: "Bob", age: 20, major: "Mathematics" },
  { name: "Charlie", age: 25, major: "Physics", internship: "Research Lab" },
  { name: "David", age: 19, contact: { phone: "555-1234" } }
]);

Para encontrar todos os alunos que possuem um campo scholarship, use o operador $exists com o valor true.

db.students.find({ scholarship: { $exists: true } });

Esta consulta retornará apenas o documento de Alice, pois ela é a única com o campo scholarship.

Inversamente, para encontrar alunos que não possuem um campo internship, defina $exists como false.

db.students.find({ internship: { $exists: false } });

Isso retornará os documentos de Alice, Bob e David, pois nenhum deles possui o campo internship.

O operador $exists também funciona em campos aninhados. Para encontrar um aluno que tenha um objeto contact que contenha um campo phone, você pode usar a notação de ponto.

db.students.find({ "contact.phone": { $exists: true } });

Esta consulta procura especificamente pelo campo phone dentro do objeto contact e retornará o documento de David.

Encontrar Valores Nulos

Nesta etapa final, você aprenderá como consultar documentos que contêm valores null. Um valor null representa a ausência intencional de um valor.

Primeiro, vamos configurar uma coleção com documentos contendo valores null e campos ausentes.

db.students.drop();

db.students.insertMany([
  { name: "Alice", age: 22, email: null },
  { name: "Bob", age: 20, major: "Mathematics" },
  { name: "Charlie", age: null, major: "Physics" },
  { name: "David", contact: { email: null } }
]);

Para encontrar documentos onde um campo tem um valor null, você pode consultar diretamente por null. A seguinte consulta encontra todos os documentos onde o campo email é null OU o campo email não existe.

db.students.find({ email: null });

Esta consulta retornará todos os quatro documentos: Alice (onde email é explicitamente null), Bob (onde o campo email está ausente), Charlie (onde o campo email está ausente) e David (onde o campo email está ausente).

Para encontrar apenas os documentos onde um campo está explicitamente definido como null, você deve combinar a verificação de null com uma verificação $exists.

db.students.find({ email: { $type: "null" } });

Alternativamente, você pode usar o operador $type. O tipo BSON para null é 10. Esta consulta retornará apenas o documento de Alice.

db.students.find({ email: { $type: 10 } });

Você também pode consultar valores null dentro de documentos aninhados. A seguinte consulta encontra documentos onde o campo email dentro do objeto contact é null OU onde o campo contact não existe.

db.students.find({ "contact.email": null });

Isso retornará todos os quatro documentos: Alice, Bob e Charlie (onde o campo contact está ausente) e David (onde contact.email é explicitamente null). Compreender como consultar por null é crucial para lidar com dados incompletos ou esparsos.

Quando terminar, você pode sair do shell mongosh digitando exit ou pressionando Ctrl+D.

Resumo

Neste laboratório, você aprendeu várias técnicas essenciais para filtrar coleções no MongoDB. Você praticou a aplicação de múltiplas condições usando os operadores $and e $or, o que permite a criação de consultas complexas e precisas. Você também explorou uma variedade de operadores de comparação como $gt, $lt e $ne para refinar os critérios de busca. Além disso, você ganhou experiência em correspondência de texto usando expressões regulares, verificando a existência de campos com $exists e consultando valores null. Essas habilidades fornecem uma base sólida para a recuperação e manipulação eficaz de dados no MongoDB.