Transformar Dados no MongoDB

Introdução

Neste laboratório, você aprenderá como transformar dados do MongoDB usando operações básicas de agregação. O laboratório cobre cinco etapas principais: seleção de campos de saída, renomeação de campos, cálculo de novos campos, formatação da saída e filtragem de resultados. Através dessas etapas, você obterá experiência prática em remodelar e analisar dados armazenados em coleções do MongoDB. O laboratório fornece um conjunto de dados de amostra de livros e demonstra como aproveitar o pipeline de agregação para extrair, manipular e apresentar os dados de uma maneira mais significativa.

Skills Graph

Selecionar Campos de Saída

Nesta etapa, aprenderemos como usar o pipeline de agregação do MongoDB para selecionar e transformar campos de saída. A agregação é uma maneira poderosa de processar e analisar dados no MongoDB.

Primeiro, vamos começar lançando o shell do MongoDB:

mongosh

Agora, vamos criar uma coleção de amostra de livros para trabalhar:

use bookstore

db.books.insertMany([
    {
        title: "MongoDB Basics",
        author: "Jane Smith",
        price: 29.99,
        pages: 250,
        categories: ["Database", "Programming"]
    },
    {
        title: "Python Deep Dive",
        author: "John Doe",
        price: 39.99,
        pages: 450,
        categories: ["Programming", "Python"]
    },
    {
        title: "Data Science Handbook",
        author: "Alice Johnson",
        price: 49.99,
        pages: 600,
        categories: ["Data Science", "Programming"]
    }
])

Agora, vamos usar o pipeline de agregação para selecionar campos de saída específicos:

db.books.aggregate([
  {
    $project: {
      _id: 0,
      bookTitle: "$title",
      bookAuthor: "$author"
    }
  }
]);

Exemplo de saída:

[
  { bookTitle: 'MongoDB Basics', bookAuthor: 'Jane Smith' },
  { bookTitle: 'Python Deep Dive', bookAuthor: 'John Doe' },
  { bookTitle: 'Data Science Handbook', bookAuthor: 'Alice Johnson' }
]

Vamos detalhar o que fizemos:

• $project é um estágio de agregação que remodela documentos
• _id: 0 exclui o ID do documento padrão do MongoDB
• bookTitle: "$title" renomeia o campo 'title' para 'bookTitle'
• bookAuthor: "$author" renomeia o campo 'author' para 'bookAuthor'

O $ antes dos nomes dos campos diz ao MongoDB para usar o valor desse campo.

Renomear Campos

Nesta etapa, exploraremos técnicas mais avançadas de renomeação de campos usando o pipeline de agregação do MongoDB. Vamos construir sobre a coleção de livros que criamos na etapa anterior.

Vamos continuar no shell do MongoDB:

mongosh

Primeiro, vamos mudar para o nosso banco de dados da livraria:

use bookstore

Agora, usaremos um estágio $project mais complexo para renomear e transformar vários campos:

db.books.aggregate([
  {
    $project: {
      _id: 0,
      bookInfo: {
        name: "$title",
        writer: "$author",
        bookLength: "$pages",
        pricing: "$price"
      },
      genres: "$categories"
    }
  }
]);

Exemplo de saída:

[
  {
    bookInfo: {
      name: 'MongoDB Basics',
      writer: 'Jane Smith',
      bookLength: 250,
      pricing: 29.99
    },
    genres: [ 'Database', 'Programming' ]
  },
  // ... other book documents
]

Vamos detalhar a técnica de renomeação:

• Criamos um objeto aninhado bookInfo com campos renomeados
• name substitui title
• writer substitui author
• bookLength substitui pages
• pricing substitui price
• Também preservamos as categories como genres

Você também pode usar o estágio $rename para renomeação de campos mais simples:

db.books.aggregate([
  {
    $rename: {
      title: "bookName",
      author: "bookWriter"
    }
  }
]);

Este estágio renomeia diretamente os campos nos documentos originais.

Calcular Novos Campos

Nesta etapa, aprenderemos como criar novos campos realizando cálculos usando o pipeline de agregação do MongoDB. Continuaremos trabalhando com nosso banco de dados da livraria.

Vamos começar lançando o shell do MongoDB:

mongosh

Mude para o banco de dados da livraria:

use bookstore

Usaremos o estágio $addFields para criar novos campos calculados:

db.books.aggregate([
  {
    $addFields: {
      totalValue: { $multiply: ["$price", 1.1] },
      discountedPrice: { $multiply: ["$price", 0.9] },
      pageCategories: {
        $concat: [
          { $toString: "$pages" },
          " page ",
          { $arrayElemAt: ["$categories", 0] }
        ]
      }
    }
  }
]);

Exemplo de saída:

[
  {
    _id: ObjectId("..."),
    title: "MongoDB Basics",
    author: "Jane Smith",
    price: 29.99,
    pages: 250,
    categories: ["Database", "Programming"],
    totalValue: 32.989,
    discountedPrice: 26.991,
    pageCategories: "250 page Database"
  },
  // ... other book documents
]

Vamos detalhar os cálculos:

• totalValue: Multiplica o preço por 1.1 (acréscimo de 10%)
• discountedPrice: Multiplica o preço por 0.9 (desconto de 10%)
• pageCategories: Combina o número de páginas com a primeira categoria usando $concat

Também podemos realizar cálculos mais complexos. Vamos calcular uma classificação de livro com base nas páginas:

db.books.aggregate([
  {
    $addFields: {
      bookRating: {
        $switch: {
          branches: [
            { case: { $lt: ["$pages", 300] }, then: "Short Book" },
            { case: { $lt: ["$pages", 500] }, then: "Medium Book" }
          ],
          default: "Long Book"
        }
      }
    }
  }
]);

Este exemplo usa $switch para categorizar livros com base na contagem de páginas.

Formatar Saída

Nesta etapa, exploraremos várias técnicas para formatar e transformar a saída usando o pipeline de agregação do MongoDB. Continuaremos trabalhando com nosso banco de dados da livraria.

Vamos começar lançando o shell do MongoDB:

mongosh

Mude para o banco de dados da livraria:

use bookstore

Primeiro, vamos usar $toUpper e $toLower para formatar campos de texto:

db.books.aggregate([
  {
    $project: {
      _id: 0,
      titleUpperCase: { $toUpper: "$title" },
      authorLowerCase: { $toLower: "$author" }
    }
  }
]);

Exemplo de saída:

[
  {
    titleUpperCase: 'MONGODB BASICS',
    authorLowerCase: 'jane smith'
  },
  // ... other book documents
]

Em seguida, vamos formatar valores numéricos usando $round e criar strings de preço formatadas:

db.books.aggregate([
  {
    $project: {
      _id: 0,
      title: 1,
      roundedPrice: { $round: ["$price", 1] },
      formattedPrice: {
        $concat: ["$", { $toString: { $round: ["$price", 2] } }]
      }
    }
  }
]);

Exemplo de saída:

[
  {
    title: 'MongoDB Basics',
    roundedPrice: 30,
    formattedPrice: '$29.99'
  },
  // ... other book documents
]

Também podemos formatar arrays e criar representações de strings complexas:

db.books.aggregate([
  {
    $project: {
      _id: 0,
      title: 1,
      categoriesSummary: {
        $reduce: {
          input: "$categories",
          initialValue: "",
          in: {
            $concat: [
              "$$value",
              { $cond: [{ $eq: ["$$value", ""] }, "", ", "] },
              "$$this"
            ]
          }
        }
      }
    }
  }
]);

Exemplo de saída:

[
  {
    title: 'MongoDB Basics',
    categoriesSummary: 'Database, Programming'
  },
  // ... other book documents
]

Este último exemplo usa $reduce para juntar elementos de array em uma string separada por vírgulas.

Filtrar Resultados

Nesta etapa final, exploraremos várias técnicas de filtragem usando o pipeline de agregação do MongoDB. Continuaremos trabalhando com nosso banco de dados da livraria para demonstrar diferentes maneiras de filtrar resultados.

Vamos começar lançando o shell do MongoDB:

mongosh

Mude para o banco de dados da livraria:

use bookstore

Primeiro, vamos filtrar livros usando operadores de comparação simples:

db.books.aggregate([
  {
    $match: {
      price: { $gt: 30 },
      pages: { $lt: 500 }
    }
  }
]);

Esta consulta filtra livros que:

• Têm um preço maior que 30
• Têm menos de 500 páginas

Exemplo de saída:

[
  {
    _id: ObjectId("..."),
    title: "Python Deep Dive",
    author: "John Doe",
    price: 39.99,
    pages: 450,
    categories: ["Programming", "Python"]
  }
]

Em seguida, vamos usar uma filtragem mais complexa com operações de array:

db.books.aggregate([
  {
    $match: {
      categories: { $in: ["Programming"] }
    }
  }
]);

Esta consulta encontra todos os livros que têm "Programming" em suas categorias.

Também podemos combinar múltiplas técnicas de filtragem:

db.books.aggregate([
  {
    $match: {
      $or: [{ pages: { $gt: 400 } }, { categories: { $in: ["Database"] } }]
    }
  },
  {
    $project: {
      title: 1,
      pages: 1,
      categories: 1
    }
  }
]);

Esta consulta mais complexa:

• Encontra livros com mais de 400 páginas OU na categoria "Database"
• Projeta apenas campos específicos na saída

Exemplo de saída:

[
  {
    _id: ObjectId("..."),
    title: "Data Science Handbook",
    pages: 600,
    categories: ["Data Science", "Programming"]
  },
  {
    _id: ObjectId("..."),
    title: "MongoDB Basics",
    pages: 250,
    categories: ["Database", "Programming"]
  }
]

Resumo

Neste laboratório, você aprendeu como usar o pipeline de agregação do MongoDB para selecionar e transformar campos de saída. Você começou criando uma coleção de amostra de livros e, em seguida, usou o estágio $project para selecionar campos específicos e renomeá-los. Você também explorou técnicas mais avançadas de renomeação de campos, incluindo o uso de expressões computadas e campos aninhados. Por fim, você aprendeu como calcular novos campos, formatar a saída e filtrar os resultados. Essas habilidades são essenciais para processar e analisar dados de forma eficiente no MongoDB.