Manipular Arrays no MongoDB

Introdução

Neste laboratório, você aprenderá a lidar com arrays no MongoDB. Arrays são uma estrutura de dados fundamental no MongoDB que permitem armazenar listas de valores dentro de um único documento. Você explorará várias operações, incluindo a criação de documentos com campos de array, a adição e remoção de elementos, a atualização de valores dentro de arrays e a execução de consultas com base no conteúdo do array. Essas habilidades são essenciais para gerenciar estruturas de dados complexas de forma eficaz no MongoDB.

Ao final deste laboratório, você terá um entendimento sólido e prático de como trabalhar com arrays no MongoDB, permitindo que você construa esquemas de banco de dados mais sofisticados e flexíveis.

Criar Documentos com Campos de Array

Nesta primeira etapa, você se conectará ao servidor MongoDB e criará um novo documento que inclui um campo de array. Arrays são poderosos porque permitem armazenar múltiplos valores relacionados, como tags, comentários ou cursos, diretamente dentro de um documento.

Primeiro, abra o shell do MongoDB para começar a interagir com seu banco de dados. Você realizará todas as operações subsequentes neste laboratório dentro do shell mongosh.

mongosh

Uma vez dentro do shell, você verá um prompt como test>. Vamos mudar para o banco de dados arraylab, que foi pré-configurado para este laboratório.

use arraylab

O script setup já criou uma coleção students e inseriu um documento. Agora, você inserirá um novo documento para uma estudante chamada "Alice Johnson". Este documento terá um campo courses, que é um array de strings.

db.students.insertOne({
    name: "Alice Johnson",
    age: 22,
    courses: ["Mathematics", "Computer Science", "Physics"]
})

Este comando insere um único documento na coleção students. O campo courses contém um array com três elementos de string.

Para confirmar que o documento foi criado com sucesso, você pode usar o método find() para recuperar todos os documentos na coleção. O método .pretty() formata a saída para ser mais legível.

db.students.find().pretty()

Você deverá ver dois documentos: o de "Bob Smith" que foi criado durante a configuração e o documento de "Alice Johnson" que você acabou de adicionar.

[
  {
    _id: ObjectId("..."),
    name: 'Bob Smith',
    grades: [ 95, 87, 92 ],
    activities: [ 'Chess Club', 'Debate Team' ]
  },
  {
    _id: ObjectId("..."),
    name: 'Alice Johnson',
    age: 22,
    courses: [ 'Mathematics', 'Computer Science', 'Physics' ]
  }
]

Adicionar Elementos a um Array

Após criar arrays, uma tarefa comum é adicionar novos elementos a eles. Nesta etapa, você aprenderá a usar o operador $push para anexar elementos a um array existente.

Para adicionar um único elemento a um array, use o operador $push em uma operação de atualização. Vamos adicionar um novo curso, "Data Science", à lista de cursos de Alice Johnson.

db.students.updateOne(
    { name: "Alice Johnson" },
    { $push: { courses: "Data Science" } }
)

Neste comando, o primeiro argumento { name: "Alice Johnson" } é o filtro que encontra o documento a ser atualizado. O segundo argumento { $push: { courses: "Data Science" } } especifica a ação de atualização. $push anexa o valor "Data Science" ao array courses.

Vamos verificar a alteração encontrando o documento de Alice novamente.

db.students.find({ name: "Alice Johnson" }).pretty()

A saída mostra o novo curso adicionado ao array.

[
  {
    _id: ObjectId("..."),
    name: 'Alice Johnson',
    age: 22,
    courses: [ 'Mathematics', 'Computer Science', 'Physics', 'Data Science' ]
  }
]

Para adicionar múltiplos elementos de uma vez, você pode combinar $push com o modificador $each. Vamos adicionar duas novas atividades para Bob Smith.

db.students.updateOne(
    { name: "Bob Smith" },
    { $push: { activities: { $each: ["Robotics Club", "Swimming Team"] } } }
)

Aqui, $each instrui $push a anexar cada item da lista fornecida (["Robotics Club", "Swimming Team"]) ao array activities.

Verifique esta atualização também:

db.students.find({ name: "Bob Smith" }).pretty()

A saída confirma que ambas as novas atividades foram adicionadas.

[
  {
    _id: ObjectId("..."),
    name: 'Bob Smith',
    grades: [ 95, 87, 92 ],
    activities: [ 'Chess Club', 'Debate Team', 'Robotics Club', 'Swimming Team' ]
  }
]

Remover Elementos de um Array

Assim como você pode adicionar elementos, também precisa ser capaz de removê-los. O MongoDB fornece vários operadores para esse fim. Nesta etapa, você aprenderá a usar $pull para remover elementos por valor e $pop para removê-los por posição.

Para remover um elemento específico de um array com base em seu valor, use o operador $pull. Vamos remover "Physics" da lista de cursos de Alice.

db.students.updateOne(
    { name: "Alice Johnson" },
    { $pull: { courses: "Physics" } }
)

Este comando encontra o documento de Alice e remove todas as ocorrências de "Physics" de seu array courses. Verifique o resultado:

db.students.find({ name: "Alice Johnson" }).pretty()

A saída mostra que "Physics" não está mais no array.

[
  {
    _id: ObjectId("..."),
    name: 'Alice Johnson',
    age: 22,
    courses: [ 'Mathematics', 'Computer Science', 'Data Science' ]
  }
]

Para remover múltiplos elementos que correspondem a valores em uma lista, você pode usar o operador $pullAll. Vamos remover "Chess Club" e "Debate Team" das atividades de Bob.

db.students.updateOne(
    { name: "Bob Smith" },
    { $pullAll: { activities: ["Chess Club", "Debate Team"] } }
)

Verifique a atualização do documento de Bob:

db.students.find({ name: "Bob Smith" }).pretty()

A saída confirma a remoção das atividades especificadas.

[
  {
    _id: ObjectId("..."),
    name: 'Bob Smith',
    grades: [ 95, 87, 92 ],
    activities: [ 'Robotics Club', 'Swimming Team' ]
  }
]

Se você precisar remover um elemento do início ou do fim de um array, pode usar o operador $pop. Use 1 para remover o último elemento e -1 para remover o primeiro. Vamos remover o último curso da lista de Alice.

db.students.updateOne(
    { name: "Alice Johnson" },
    { $pop: { courses: 1 } }
)

Vamos ver o estado final dos cursos de Alice:

db.students.find({ name: "Alice Johnson" }).pretty()

A saída mostra que o último elemento, "Data Science", foi removido.

[
  {
    _id: ObjectId("..."),
    name: 'Alice Johnson',
    age: 22,
    courses: [ 'Mathematics', 'Computer Science' ]
  }
]

Atualizar Elementos em um Array

Atualizar elementos existentes dentro de um array é outra operação crucial. Esta etapa abrange como atualizar elementos de array usando operadores posicionais.

Para atualizar um único elemento específico em um array, você deve primeiro corresponder ao documento e ao elemento que deseja alterar. Em seguida, você pode usar o operador posicional $ para realizar a atualização. Vamos mudar "Mathematics" para "Advanced Mathematics" no array courses de Alice.

db.students.updateOne(
    { name: "Alice Johnson", courses: "Mathematics" },
    { $set: { "courses.$": "Advanced Mathematics" } }
)

Neste comando, o filtro { name: "Alice Johnson", courses: "Mathematics" } encontra o documento e identifica a posição da primeira ocorrência de "Mathematics" no array. A atualização { $set: { "courses.$": "Advanced Mathematics" } } usa courses.$ para se referir à posição desse elemento correspondente e define seu novo valor.

Verifique a alteração:

db.students.find({ name: "Alice Johnson" }).pretty()

A saída mostra o nome do curso atualizado.

[
  {
    _id: ObjectId("..."),
    name: 'Alice Johnson',
    age: 22,
    courses: [ 'Advanced Mathematics', 'Computer Science' ]
  }
]

Para atualizar todos os elementos em um array que correspondem a uma condição, você pode usar o operador posicional $[ ]. Vamos aumentar todas as notas de Bob em 5 pontos usando o operador $inc (incrementar).

db.students.updateOne(
    { name: "Bob Smith" },
    { $inc: { "grades.$[]": 5 } }
)

Aqui, grades.$[] aplica a operação $inc a cada elemento no array grades.

Verifique as novas notas de Bob:

db.students.find({ name: "Bob Smith" }).pretty()

A saída mostra que cada nota foi aumentada em 5.

[
  {
    _id: ObjectId("..."),
    name: 'Bob Smith',
    grades: [ 100, 92, 97 ],
    activities: [ 'Robotics Club', 'Swimming Team' ]
  }
]

Consultar Documentos com Base no Conteúdo do Array

A consulta é o cerne de qualquer banco de dados. O MongoDB oferece um rico conjunto de operadores para consultar documentos com base no conteúdo de seus arrays. Nesta etapa final, você aprenderá como encontrar documentos correspondendo a elementos de array e suas propriedades.

Para encontrar todos os documentos em que um array contém um elemento específico, você pode incluir esse valor em seu filtro de consulta. Vamos encontrar todos os alunos matriculados em "Computer Science".

db.students.find({ courses: "Computer Science" }).pretty()

Esta consulta retornará o documento de Alice, pois seu array courses contém "Computer Science".

Para encontrar documentos em que um array contém todos de um conjunto especificado de elementos, use o operador $all.

db.students.find({
    courses: { $all: ["Advanced Mathematics", "Computer Science"] }
}).pretty()

Isso também retornará o documento de Alice porque seu array courses contém ambos esses valores.

Para condições mais complexas em elementos de array, o operador $elemMatch é muito útil. Ele permite que você especifique múltiplos critérios que um único elemento de array deve atender. Vamos encontrar alunos que têm pelo menos uma nota maior que 95.

db.students.find({
    grades: { $elemMatch: { $gt: 95 } }
}).pretty()

Esta consulta retornará o documento de Bob, pois ele tem notas que agora estão acima de 95. $gt significa "greater than" (maior que).

Você também pode consultar com base no número de elementos em um array usando o operador $size. Vamos encontrar alunos que estão em exatamente duas atividades.

db.students.find({
    activities: { $size: 2 }
}).pretty()

Isso retornará o documento de Bob, pois seu array activities atualmente tem dois elementos.

Finalmente, vamos adicionar mais um aluno para praticar uma consulta combinada.

db.students.insertOne({
    name: "Charlie Brown",
    courses: ["Art", "Music", "Literature"],
    grades: [88, 92, 85],
    activities: ["Painting Club"]
})

Agora, encontre alunos que estão cursando "Art" ou "Music" (usando o operador $in) E têm pelo menos uma nota maior ou igual a 90 (usando $elemMatch com $gte).

db.students.find({
    courses: { $in: ["Art", "Music"] },
    grades: { $elemMatch: { $gte: 90 } }
}).pretty()

Esta consulta retornará o documento de "Charlie Brown", que atende a ambas as condições.

Resumo

Neste laboratório, você aprendeu as técnicas fundamentais para lidar com arrays no MongoDB. Você começou criando documentos com campos de array e, em seguida, praticou a adição de elementos usando $push e $each. Você explorou a remoção de elementos por valor com $pull e $pullAll, e por posição com $pop. Você também aprendeu como atualizar elementos de array específicos usando o operador posicional $ e todos os elementos com o operador $[ ]. Finalmente, você praticou a consulta de documentos com base no conteúdo do array usando operadores como $all, $elemMatch, $size e $in. Essas habilidades são cruciais para construir e gerenciar aplicações com estruturas de dados complexas e aninhadas no MongoDB.