Importar Dados do MongoDB

Introdução

Neste laboratório, você aprenderá as habilidades essenciais para importar dados para um banco de dados MongoDB. Você trabalhará com dois formatos de dados comuns: JSON e CSV. Você usará a ferramenta de linha de comando mongoimport para carregar dados de arquivos em coleções do MongoDB. O laboratório irá guiá-lo através da importação de dados, especificação de tipos de dados durante a importação e verificação de que os dados foram carregados corretamente usando consultas e a ferramenta mongoexport.

Importar Dados de um Arquivo JSON

Nesta primeira etapa, você importará dados de um arquivo JSON para uma coleção do MongoDB. JSON (JavaScript Object Notation) é um formato nativo para o MongoDB, o que torna o processo de importação direto. Usaremos a utilidade mongoimport, uma ferramenta de linha de comando projetada para este fim.

Um arquivo de exemplo chamado books.json foi criado para você no diretório ~/project. Primeiro, inspecione seu conteúdo a partir do seu terminal.

cat ~/project/books.json

Você deverá ver a seguinte saída, que é um array de documentos JSON:

[
  {
    "_id": 1,
    "title": "MongoDB Basics",
    "author": "Jane Smith",
    "year": 2023,
    "tags": ["mongodb", "database", "nosql"]
  },
  {
    "_id": 2,
    "title": "Python Programming",
    "author": "John Doe",
    "year": 2022,
    "tags": ["python", "programming"]
  },
  {
    "_id": 3,
    "title": "Data Science Handbook",
    "author": "Alice Johnson",
    "year": 2021,
    "tags": ["data science", "python", "machine learning"]
  }
]

Agora, importe esses dados para um novo banco de dados chamado library_db e uma coleção chamada books.

mongoimport --db library_db --collection books --file ~/project/books.json --jsonArray

Vamos detalhar as opções do comando:

• --db library_db: Especifica o banco de dados de destino.
• --collection books: Especifica a coleção de destino dentro do banco de dados.
• --file ~/project/books.json: Fornece o caminho para o arquivo de entrada.
• --jsonArray: Informa ao mongoimport que o arquivo contém um único array JSON, onde cada elemento é um documento a ser inserido.

Você verá uma saída indicando o progresso e a conclusão da importação:

2025-08-27T15:10:40.411+0800    connected to: mongodb://localhost/
2025-08-27T15:10:40.417+0800    3 document(s) imported successfully. 0 document(s) failed to import.

Para verificar se os dados foram importados corretamente, você agora se conectará ao MongoDB usando o MongoDB Shell, mongosh.

mongosh

Uma vez dentro do shell, mude para o banco de dados library_db:

use library_db

Agora, conte os documentos na coleção books para confirmar que todos os três registros foram importados.

db.books.countDocuments()

A saída deverá ser 3. Você também pode visualizar um dos documentos importados para verificar sua estrutura.

db.books.findOne()

Isso exibirá o primeiro documento da coleção. Finalmente, saia do MongoDB Shell para retornar ao seu terminal.

exit

Importar Dados de um Arquivo CSV

Em seguida, você importará dados de um arquivo CSV (Comma-Separated Values). CSV é um formato comum para dados tabulares, e mongoimport pode facilmente convertê-lo em documentos do MongoDB.

Um arquivo CSV de exemplo chamado library_members.csv foi preparado para você. Dê uma olhada em seu conteúdo.

cat ~/project/library_members.csv

O arquivo contém uma linha de cabeçalho e três linhas de dados:

name,age,membership_status
John Doe,35,active
Jane Smith,28,active
Mike Johnson,42,expired

Agora, use mongoimport para carregar esses dados em uma nova coleção chamada members no mesmo banco de dados library_db.

mongoimport --db library_db --collection members --type csv --file ~/project/library_members.csv --headerline

Aqui estão as novas opções usadas para a importação CSV:

• --type csv: Especifica que o formato do arquivo de entrada é CSV.
• --headerline: Informa ao mongoimport para usar a primeira linha do arquivo como os nomes dos campos para os documentos.

A saída confirmará a importação bem-sucedida:

2025-08-27T15:11:33.553+0800    connected to: mongodb://localhost/
2025-08-27T15:11:33.558+0800    3 document(s) imported successfully. 0 document(s) failed to import.

Vamos verificar a importação. Conecte-se ao MongoDB Shell e verifique a coleção members. Você pode especificar o banco de dados diretamente ao iniciar o mongosh para economizar uma etapa.

mongosh library_db

Agora, conte os documentos na coleção members.

db.members.countDocuments()

O resultado deverá ser 3. Em seguida, inspecione um dos documentos para ver como o mongoimport converteu a linha CSV em um documento BSON.

db.members.findOne()

Você verá um documento semelhante a este. Observe que todos os valores, incluindo a age, são importados como strings por padrão.

{
  _id: ObjectId("..."),
  name: 'John Doe',
  age: '35',
  membership_status: 'active'
}

Você aprenderá como lidar com tipos de dados na próxima etapa. Por enquanto, saia do shell.

exit

Tratamento de Tipos de Dados Durante a Importação CSV

Ao importar de um arquivo CSV, o mongoimport trata todos os valores como strings por padrão. Isso pode ser um problema se você precisar realizar operações numéricas ou baseadas em datas. Nesta etapa, você aprenderá como importar dados CSV e, em seguida, converter tipos de dados no MongoDB.

Vamos reimportar os dados de library_members.csv para uma nova coleção chamada typed_members e, em seguida, converter o campo age para um inteiro.

Primeiro, crie um arquivo CSV sem cabeçalhos, pois definiremos os nomes dos campos explicitamente:

tail -n +2 ~/project/library_members.csv > ~/project/library_members_no_header.csv

Agora importe os dados com nomes de campos explícitos:

mongoimport --db library_db --collection typed_members --type csv --file ~/project/library_members_no_header.csv --fields "name,age,membership_status"

Após a importação, precisamos converter o campo age de string para inteiro usando a operação de atualização do MongoDB:

mongosh library_db --eval "db.typed_members.updateMany({}, [{ \$set: { age: { \$toInt: \"\$age\" } } }])"

Este comando usa o pipeline de agregação do MongoDB dentro de uma operação de atualização para converter todos os valores de age de strings para inteiros usando o operador $toInt.

Agora vamos verificar o resultado conectando-nos ao mongosh e inspecionando os tipos de dados na coleção typed_members.

mongosh library_db

Primeiro, encontre um documento na coleção para ver os dados convertidos:

db.typed_members.findOne()

A saída deverá mostrar o campo age como um número:

{
  _id: ObjectId("..."),
  name: 'Jane Smith',
  age: 28,
  membership_status: 'active'
}

Você pode verificar explicitamente o tipo do campo age usando o operador typeof do JavaScript dentro do mongosh:

typeof db.typed_members.findOne().age

A saída deverá ser number, confirmando que a conversão do tipo de dado foi bem-sucedida. Isso permite que você realize consultas numéricas, como encontrar todos os membros com mais de 30 anos:

db.typed_members.find({ age: { $gt: 30 } })

Esta consulta agora funcionará como esperado e retornará dois documentos. Saia do shell para prosseguir para a próxima etapa:

exit

Verificação de Dados com Consultas e Exportações

A etapa final em qualquer processo de importação de dados é a verificação completa. Isso envolve não apenas a verificação de contagens de documentos, mas também a execução de consultas para amostrar os dados e garantir sua integridade. Você também pode exportar os dados para um arquivo externo para análise posterior.

Primeiro, conecte-se ao seu banco de dados com mongosh.

mongosh library_db

Você pode listar todas as coleções no banco de dados para ver os resultados do seu trabalho até agora.

show collections

Você deverá ver books, members e typed_members. Agora, vamos executar algumas consultas para validar os dados. Para a coleção books, encontre todos os livros que possuem a tag "python".

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

Esta consulta demonstra a busca dentro de um campo de array. Você deverá ver dois livros retornados. Para a coleção typed_members, encontre todos os membros com o status de associação "active".

db.typed_members.find({ membership_status: "active" })

Isso deverá retornar dois membros. Essas consultas simples ajudam a confirmar que os dados estão estruturados como esperado.

Outra ferramenta de verificação poderosa é o mongoexport, que faz o inverso do mongoimport. Ele exporta uma coleção para um arquivo. Vamos exportar a coleção books para um novo arquivo JSON. Saia do shell primeiro.

exit

Agora, execute o comando mongoexport do seu terminal.

mongoexport --db library_db --collection books --out ~/project/exported_books.json

O sinalizador --out especifica o caminho para o arquivo de saída. Este comando criará um arquivo chamado exported_books.json em seu diretório de projeto. Você pode visualizar seu conteúdo para verificar a exportação.

cat ~/project/exported_books.json

Cada linha no arquivo de saída é um documento JSON autônomo de sua coleção. Este arquivo pode ser usado para backups, migração ou análise com outras ferramentas.

Resumo

Neste laboratório, você aprendeu a importar dados para o MongoDB a partir de arquivos JSON e CSV usando o utilitário mongoimport. Você praticou a importação de um array JSON para uma coleção e verificou o resultado usando mongosh. Em seguida, importou dados de um arquivo CSV, primeiro com tipos de string padrão e, depois, especificando tipos de dados para campos como números. Finalmente, você aprendeu a verificar a integridade dos seus dados importados executando consultas no mongosh e exportando uma coleção de volta para um arquivo usando mongoexport. Estas são habilidades fundamentais para gerenciar dados em qualquer projeto MongoDB.