Gerenciar Documentos Embutidos no MongoDB

Introdução

Neste laboratório, você aprenderá como gerenciar efetivamente documentos embutidos do MongoDB. O laboratório cobre uma variedade de técnicas, incluindo a criação de documentos aninhados, atualização de campos aninhados, remoção de elementos aninhados, consulta de dados aninhados e validação da estrutura do documento. Essas habilidades são essenciais para trabalhar com dados complexos e hierárquicos no MongoDB, permitindo que você construa aplicações robustas e eficientes. As instruções passo a passo fornecem um guia abrangente para dominar o gerenciamento de documentos embutidos em seus projetos MongoDB.

Skills Graph

Criar Documentos Aninhados

Nesta etapa, você aprenderá como criar documentos aninhados no MongoDB, o que permite armazenar dados complexos e hierárquicos dentro de um único documento. Documentos aninhados são poderosos para representar relacionamentos e informações estruturadas.

Primeiro, vamos iniciar o shell do MongoDB:

mongosh

Agora, vamos criar um banco de dados para nosso exemplo:

use bookstore

Criaremos uma coleção chamada books com documentos aninhados representando detalhes do livro:

db.books.insertOne({
    title: "Advanced MongoDB",
    author: {
        name: "Jane Smith",
        contact: {
            email: "[email protected]",
            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" }
    ]
})

Vamos detalhar este documento:

• O documento tem um campo principal title
• author é um documento aninhado com sub-documentos name e contact
• published é outro documento aninhado com detalhes da publicação
• chapters é um array de documentos aninhados representando os capítulos do livro

Para visualizar o documento que acabamos de criar, use:

db.books.find()

Exemplo de saída:

[
  {
    _id: ObjectId("..."),
    title: 'Advanced MongoDB',
    author: {
      name: 'Jane Smith',
      contact: {
        email: '[email protected]',
        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

Nesta etapa, você aprenderá como atualizar campos aninhados em documentos MongoDB. Com base na etapa anterior, usaremos o documento do livro que criamos para demonstrar várias técnicas de atualização para documentos aninhados.

Primeiro, certifique-se de estar no shell do MongoDB:

mongosh

Mude para o banco de dados bookstore:

use bookstore

Vamos atualizar as informações de contato do autor usando o operador $set:

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" nos permite direcionar com precisão os campos aninhados. Vamos verificar a atualização:

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

Agora, vamos atualizar um array aninhado. Adicionaremos um novo capítulo ao array chapters:

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

O operador $push adiciona um novo elemento a um array. Vamos verificar a atualização:

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

Também podemos atualizar um elemento específico do array aninhado usando o operador posicional $. Vamos atualizar o primeiro capítulo:

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

A saída de exemplo mostrará o documento atualizado com campos aninhados modificados e o capítulo adicionado.

Remover Elementos Aninhados

Nesta etapa, você aprenderá como remover elementos aninhados de documentos MongoDB usando vários operadores. Continuaremos trabalhando com o documento do livro das etapas anteriores.

Primeiro, certifique-se de estar no shell do MongoDB:

mongosh

Mude para o banco de dados bookstore:

use bookstore

Vamos remover um campo específico das informações de contato aninhadas usando o operador $unset:

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

O operador $unset remove o campo especificado completamente. Vamos verificar a atualização:

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

Agora, vamos remover um elemento específico do array chapters usando o operador $pull:

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

O operador $pull remove todas as instâncias de um elemento correspondente de um array. Vamos verificar:

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

Também podemos remover todo o objeto de contato aninhado:

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

A saída de exemplo mostrará o documento com elementos aninhados removidos.

Consultar Dados Aninhados

Nesta etapa, você aprenderá como consultar documentos e arrays aninhados no MongoDB. Exploraremos diferentes técnicas para filtrar e recuperar dados aninhados específicos.

Primeiro, vamos redefinir nosso banco de dados com alguns dados de exemplo para demonstrar a consulta:

mongosh

Mude para o banco de dados bookstore:

use bookstore

Vamos inserir vários livros com estruturas aninhadas:

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 }
        ]
    }
])

Consultar um livro por um campo aninhado:

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

Consultar usando notação de ponto para objetos aninhados:

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

Consultar usando array contains (contém):

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

Consultar elementos de array aninhados:

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

O operador $gt significa "maior que", então isso encontra livros com capítulos com mais de 40 páginas.

Consulta complexa combinando condições de objeto aninhado e array:

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

Isso encontra livros de autores com 5 ou mais anos de experiência e marcados como "advanced".

Validar a Estrutura do Documento

Nesta etapa, você aprenderá como validar estruturas de documentos no MongoDB usando a validação de esquema JSON (JSON Schema). Isso garante que seus documentos mantenham uma estrutura consistente e previsível.

Primeiro, vamos iniciar o shell do MongoDB:

mongosh

Mude para o banco de dados bookstore:

use bookstore

Criaremos uma nova coleção com um validador de esquema JSON:

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",
                     description: "must be a string and is required"
                  },
                  email: {
                     bsonType: "string",
                     pattern: "^.+@.+$",
                     description: "must be a valid email address"
                  }
               }
            },
            duration: {
               bsonType: "int",
               minimum: 1,
               maximum: 100,
               description: "must be an integer between 1 and 100"
            },
            topics: {
               bsonType: "array",
               minItems: 1,
               items: {
                  bsonType: "string"
               },
               description: "must be an array of strings with at least one item"
            }
         }
      }
   }
})

Vamos tentar inserir um documento válido:

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

Agora, vamos tentar um documento inválido que será rejeitado:

db.courses.insertOne({
   title: "Invalid Course",
   instructor: {
      name: 123,  // Invalid: should be a string
      email: "invalid-email"  // Invalid email format
   },
   duration: 200,  // Out of range
   topics: []  // Empty topics array
})

Esta inserção falhará devido às regras de validação.

Para ver as regras de validação de uma coleção:

db.getCollectionInfos({ name: "courses" })

A saída de exemplo mostrará a configuração de validação do esquema JSON.

Resumo

Neste laboratório, você aprenderá como gerenciar documentos embutidos (embedded documents) no MongoDB. Primeiro, você criará documentos aninhados, o que permite armazenar dados complexos e hierárquicos dentro de um único documento. Isso é poderoso para representar relacionamentos e informações estruturadas. Em seguida, você atualizará campos aninhados, removerá elementos aninhados, consultará dados aninhados e validará a estrutura do documento. Essas técnicas demonstram a flexibilidade e o poder do modelo de dados orientado a documentos do MongoDB para trabalhar com estruturas de dados complexas e aninhadas.