Gerenciar Documentos Embutidos no MongoDB

Introdução

Neste laboratório, você aprenderá como gerenciar efetivamente documentos embutidos no MongoDB. Documentos embutidos, ou documentos aninhados, são um recurso central do modelo de dados do MongoDB que permite armazenar dados complexos e hierárquicos dentro de um único documento. Você aprenderá uma série de técnicas, incluindo a criação de documentos com dados aninhados, a atualização de campos específicos dentro deles, a remoção de elementos e a consulta a essas estruturas complexas. Você também aprenderá como impor uma estrutura de dados consistente usando validação de esquema (schema validation). Essas habilidades são essenciais para construir aplicações robustas e eficientes com o MongoDB.

Criar Documentos com Dados Aninhados

Nesta etapa, você aprenderá como criar documentos com estruturas aninhadas no MongoDB. Esta é uma habilidade fundamental para modelar dados relacionados dentro de um único documento.

Primeiro, abra o MongoDB Shell (mongosh) para começar a interagir com o banco de dados. Todos os comandos subsequentes neste laboratório serão executados dentro deste shell, a menos que especificado de outra forma.

mongosh

Em seguida, mude para um novo banco de dados chamado bookstore. Se este banco de dados não existir, o MongoDB o criará para você quando você armazenar dados nele pela primeira vez.

use bookstore

Agora, você criará uma coleção chamada books e inserirá um único documento. Este documento conterá objetos aninhados e um array de objetos aninhados, representando os detalhes de um livro.

db.books.insertOne({
    title: "Advanced MongoDB",
    author: {
        name: "Jane Smith",
        contact: {
            email: "jane.smith@example.com",
            phone: "+1-555-123-4567"
        }
    },
    published: {
        year: 2023,
        publisher: "Tech Publications"
    },
    chapters: [
        { number: 1, title: "Introduction to Nested Documents" },
        { number: 2, title: "Advanced Document Structures" }
    ]
})

No documento que você acabou de criar:

• author e published são documentos aninhados (objetos).
• O documento author contém outro documento aninhado, contact.
• chapters é um array que contém múltiplos documentos aninhados, cada um representando um capítulo.

Para visualizar o documento e confirmar sua estrutura, use o método find().

db.books.find()

Você deverá ver a seguinte saída, confirmando que o documento foi inserido corretamente. O _id é um identificador único gerado automaticamente pelo MongoDB.

[
  {
    _id: ObjectId("..."),
    title: 'Advanced MongoDB',
    author: {
      name: 'Jane Smith',
      contact: {
        email: 'jane.smith@example.com',
        phone: '+1-555-123-4567'
      }
    },
    published: {
      year: 2023,
      publisher: 'Tech Publications'
    },
    chapters: [
      { number: 1, title: 'Introduction to Nested Documents' },
      { number: 2, title: 'Advanced Document Structures' }
    ]
  }
]

Atualizar Campos Aninhados e Elementos de Array

Após criar documentos, você frequentemente precisará modificar partes deles. Nesta etapa, você aprenderá como atualizar campos específicos dentro de documentos aninhados e arrays. Você ainda deve estar no shell mongosh da etapa anterior.

Primeiro, vamos atualizar as informações de contato do autor. Para fazer isso, você usa o operador $set com notação de ponto para especificar o caminho exato para o campo que deseja alterar. Este comando alterará o número de telefone e adicionará um novo campo website.

db.books.updateOne(
    { title: "Advanced MongoDB" },
    { $set: {
        "author.contact.phone": "+1-888-999-0000",
        "author.contact.website": "www.janesmith.com"
    } }
)

A notação de ponto "author.contact.phone" instrui o MongoDB a navegar para dentro do objeto author, depois para dentro do objeto contact, e atualizar o campo phone.

Em seguida, você adicionará um novo capítulo ao array chapters usando o operador $push.

db.books.updateOne(
    { title: "Advanced MongoDB" },
    { $push: {
        chapters: {
            number: 3,
            title: "MongoDB Advanced Techniques"
        }
    } }
)

Você também pode atualizar um elemento específico dentro de um array. Vamos modificar o título do primeiro capítulo. Usamos o operador posicional $, que atua como um placeholder para o primeiro elemento do array que corresponde à condição da consulta ("chapters.number": 1).

db.books.updateOne(
    { title: "Advanced MongoDB", "chapters.number": 1 },
    { $set: {
        "chapters.$.title": "Introduction to Nested Documents (Revised)"
    } }
)

Para verificar todas as alterações, recupere o documento novamente. O método .pretty() formata a saída para ser mais legível.

db.books.find({ title: "Advanced MongoDB" }).pretty()

A saída mostrará o número de telefone atualizado, o novo website, o terceiro capítulo adicionado e o título revisado para o primeiro capítulo.

Remover Campos Aninhados e Elementos de Array

Nesta etapa, você aprenderá como remover partes de seus documentos. Isso inclui remover campos específicos, documentos aninhados inteiros e elementos de um array.

Primeiro, vamos remover o campo website das informações de contato do autor usando o operador $unset. O valor fornecido para $unset (neste caso, uma string vazia "") não importa; o operador simplesmente remove o campo especificado.

db.books.updateOne(
    { title: "Advanced MongoDB" },
    { $unset: { "author.contact.website": "" } }
)

Em seguida, você removerá um elemento de um array. Vamos remover o terceiro capítulo (aquele com number: 3) do array chapters usando o operador $pull. O operador $pull remove todos os elementos do array que correspondem à condição especificada.

db.books.updateOne(
    { title: "Advanced MongoDB" },
    { $pull: {
        chapters: { number: 3 }
    } }
)

Finalmente, você pode remover um objeto aninhado inteiro. Vamos remover o objeto contact do documento author, novamente usando o operador $unset.

db.books.updateOne(
    { title: "Advanced MongoDB" },
    { $unset: { "author.contact": "" } }
)

Para ver o resultado dessas operações de remoção, consulte o documento novamente.

db.books.find({ title: "Advanced MongoDB" }).pretty()

A saída mostrará que o campo website e o objeto contact inteiro desapareceram, e o array chapters agora contém apenas dois elementos.

Consultar Documentos com Dados Aninhados

A consulta é uma operação fundamental de banco de dados. Nesta etapa, você aprenderá como consultar documentos com base em valores dentro de objetos aninhados e arrays. Para garantir que tenhamos um conjunto de dados limpo para estes exemplos, primeiro exclua a coleção books existente.

db.books.drop()

Agora, insira alguns novos documentos com diferentes estruturas aninhadas para praticar a consulta.

db.books.insertMany([
    {
        title: "MongoDB Essentials",
        author: {
            name: "John Doe",
            experience: { years: 5, specialization: "Database Design" }
        },
        tags: ["beginner", "database", "nosql"],
        chapters: [
            { number: 1, title: "Introduction", pages: 25 },
            { number: 2, title: "Advanced Concepts", pages: 45 }
        ]
    },
    {
        title: "Advanced Database Techniques",
        author: {
            name: "Jane Smith",
            experience: { years: 8, specialization: "Distributed Systems" }
        },
        tags: ["advanced", "distributed", "nosql"],
        chapters: [
            { number: 1, title: "System Design", pages: 35 },
            { number: 2, title: "Performance Optimization", pages: 55 }
        ]
    }
])

Para encontrar um livro por um campo em um documento aninhado, use a notação de ponto. Esta consulta encontra o livro escrito por "John Doe".

db.books.find({ "author.name": "John Doe" })

Você pode ir mais fundo em estruturas aninhadas. Esta consulta encontra livros onde a especialização do autor é "Database Design".

db.books.find({ "author.experience.specialization": "Database Design" })

Para encontrar documentos onde um array contém um valor específico, você pode consultar o campo do array diretamente. Isso encontra todos os livros marcados com "nosql".

db.books.find({ tags: "nosql" })

Você também pode consultar documentos onde um elemento de array atende a uma determinada condição. Esta consulta encontra livros que têm pelo menos um capítulo com mais de 40 páginas, usando o operador $gt (maior que).

db.books.find({ "chapters.pages": { $gt: 40 } })

Finalmente, você pode combinar várias condições. Esta consulta encontra livros marcados como "advanced" escritos por um autor com 5 ou mais anos de experiência ($gte significa maior ou igual a).

db.books.find({
    "author.experience.years": { $gte: 5 },
    tags: "advanced"
})

Impor Estrutura de Documento com Validação de Schema

Para manter a consistência dos dados, o MongoDB permite impor uma estrutura específica para documentos em uma coleção usando a validação de JSON Schema. Nesta etapa, você criará uma nova coleção com um validador para garantir que todos os documentos sigam uma estrutura predefinida.

Primeiro, crie uma nova coleção chamada courses. Ao criá-la, você passará uma opção validator contendo as regras do schema.

db.createCollection("courses", {
   validator: {
      $jsonSchema: {
         bsonType: "object",
         required: ["title", "instructor", "duration", "topics"],
         properties: {
            title: {
               bsonType: "string",
               description: "must be a string and is required"
            },
            instructor: {
               bsonType: "object",
               required: ["name", "email"],
               properties: {
                  name: { bsonType: "string" },
                  email: {
                     bsonType: "string",
                     pattern: "^.+@.+$"
                  }
               }
            },
            duration: {
               bsonType: "int",
               minimum: 1,
               maximum: 100
            },
            topics: {
               bsonType: "array",
               minItems: 1,
               items: { bsonType: "string" }
            }
         }
      }
   }
})

Este schema exige que cada documento tenha um title, instructor, duration e topics. Ele também define o tipo de dado para cada campo, incluindo regras aninhadas para o objeto instructor e o array topics.

Agora, tente inserir um documento que esteja em conformidade com essas regras. Esta operação deve ser bem-sucedida.

db.courses.insertOne({
   title: "MongoDB Advanced Techniques",
   instructor: {
      name: "Jane Smith",
      email: "jane.smith@example.com"
   },
   duration: 40,
   topics: ["Nested Documents", "Schema Validation"]
})

Em seguida, tente inserir um documento que viole as regras do schema. Este documento tem um tipo de dado incorreto para instructor.name, um formato de e-mail inválido, uma duration fora do intervalo permitido e um array topics vazio.

db.courses.insertOne({
   title: "Invalid Course",
   instructor: {
      name: 123,
      email: "invalid-email"
   },
   duration: 200,
   topics: []
})

Esta inserção falhará, e o MongoDB retornará um erro Document failed validation. Isso impede que dados inconsistentes sejam salvos e ajuda a manter a integridade do seu banco de dados.

Resumo

Neste laboratório, você aprendeu as técnicas fundamentais para gerenciar documentos embutidos no MongoDB. Você começou criando documentos com estruturas aninhadas complexas, incluindo objetos e arrays. Em seguida, praticou a atualização de campos específicos usando notação de ponto e operadores como $set e $push. Você também aprendeu como remover dados com $unset e $pull. Além disso, explorou como realizar consultas direcionadas em dados aninhados e, finalmente, como impor a integridade dos dados definindo e aplicando um validador JSON Schema a uma coleção. Essas habilidades são cruciais para construir aplicações que aproveitam efetivamente o modelo de documentos flexível do MongoDB.