Seu primeiro laboratório de MongoDB

Introdução

Bem-vindo ao LabEx! Este é o seu primeiro laboratório de MongoDB. Não se preocupe se você nunca usou um banco de dados antes: vamos orientar você em todas as etapas.

Primeiro, vamos entender o que é o MongoDB: o MongoDB é um sistema de banco de dados que armazena dados em um formato flexível baseado em documentos. Diferentemente das planilhas tradicionais, o MongoDB permite organizar os dados de uma maneira mais natural, semelhante à forma como você pode organizar arquivos em pastas no computador.

Neste laboratório, você aprenderá a:

1. Iniciar o shell do MongoDB e entender o que ele é
2. Criar seu primeiro banco de dados e sua primeira coleção
3. Adicionar e visualizar dados no MongoDB
4. Consultar, atualizar e remover dados

Essas habilidades formarão a base da sua jornada com o MongoDB. Vamos começar!

Clique no botão Continue abaixo para iniciar o laboratório.

Iniciar o shell do MongoDB

Nesta etapa, você abrirá um terminal e iniciará o shell do MongoDB na sua VM do LabEx.

Recomendamos a Terminal Interface pela velocidade e facilidade de uso. Essa é a interface padrão dos laboratórios relacionados ao MongoDB.

Se preferir uma experiência de terminal mais tradicional, use a Desktop Interface. No lado esquerdo da área de trabalho, clique no ícone chamado Xfce Terminal.

Os dois métodos funcionam igualmente bem: são apenas formas diferentes de acessar o mesmo ambiente de laboratório. Escolha o que preferir!

Agora, vamos iniciar o shell do MongoDB, que funciona como um painel de controle do banco de dados. Pense no shell como uma forma de se comunicar diretamente com o MongoDB: você digita comandos, e o MongoDB responde.

Para iniciar o MongoDB Shell, digite o comando a seguir no terminal e pressione Enter:

mongosh

Você verá uma mensagem de conexão indicando que se conectou com sucesso à instância local do MongoDB. A saída será semelhante a esta:

Current Mongosh Log ID: 65a7f3e5f1a1234567890abc
Connecting to:          mongodb://127.0.0.1:27017/?directConnection=true&serverSelectionTimeoutMS=2000&appName=mongosh+x.y.z
Using MongoDB:          X.X.X
Using Mongosh:          X.X.X

For mongosh info, see: https://docs.mongodb.com/mongodb-shell/

test>

O prompt test> indica que você está dentro do shell mongosh e conectado ao banco de dados padrão test.

Vamos listar todos os bancos de dados existentes no servidor. Digite o comando a seguir no shell mongosh:

show dbs

Você verá uma lista dos bancos de dados padrão usados internamente pelo MongoDB:

admin     40.00 KiB
config   112.00 KiB
local     40.00 KiB

Na próxima etapa, você criará seu próprio banco de dados.

Criar um banco de dados e inserir um documento

Nesta etapa, você criará um banco de dados e inserirá seu primeiro documento. No MongoDB, não é necessário criar um banco de dados explicitamente. Ele é criado automaticamente quando você armazena dados nele pela primeira vez. Para mudar para um novo banco de dados, use o comando use.

Vamos mudar para um banco de dados chamado mylab_database. No shell mongosh, digite:

use mylab_database

O shell responderá com switched to db mylab_database. Embora o banco de dados ainda não tenha sido criado, você já está trabalhando no contexto dele.

Os dados do MongoDB são armazenados em coleções, que são grupos de documentos. Um documento é um conjunto de pares de chave e valor. Vamos criar uma coleção users inserindo nosso primeiro documento.

Use o método insertOne() para adicionar um único documento à coleção users:

db.users.insertOne({ name: "JohnDoe", age: 30, city: "NewYork" })

Veja o que cada parte desse comando representa:

• db: representa o banco de dados atual (mylab_database).
• users: é o nome da coleção. Ela será criada automaticamente.
• insertOne(): é o método usado para inserir um documento.
• {...}: é o próprio documento, contendo campos como name, age e city.

O MongoDB confirmará a inserção e retornará o _id exclusivo gerado para o documento:

{
  acknowledged: true,
  insertedId: ObjectId("...")
}

O ObjectId é um identificador exclusivo atribuído automaticamente a cada documento.

Agora, vamos verificar se o documento foi adicionado. Use o método find() para visualizar todos os documentos da coleção users:

db.users.find()

A saída exibirá o documento que você acabou de inserir:

[
  {
    _id: ObjectId("..."),
    name: 'JohnDoe',
    age: 30,
    city: 'NewYork'
  }
]

Inserir vários documentos

Nesta etapa, você adicionará vários documentos de uma só vez. O método insertMany() recebe como argumento um array de documentos.

Vamos criar uma nova coleção books e adicionar três livros a ela com um único comando.

db.books.insertMany([
    { title: "MongoDBBasics", author: "JaneSmith", year: 2023 },
    { title: "PythonProgramming", author: "JohnDoe", year: 2022 },
    { title: "DataScienceHandbook", author: "AliceJohnson", year: 2021 }
])

Observe os colchetes [ ], que definem um array. Cada objeto {...} dentro do array é um documento separado.

O MongoDB confirmará a operação e retornará os valores de _id de todos os documentos inseridos:

{
  acknowledged: true,
  insertedIds: {
    '0': ObjectId("..."),
    '1': ObjectId("..."),
    '2': ObjectId("...")
  }
}

Para ver todos os documentos da nova coleção books, use novamente o método find():

db.books.find()

A saída listará os três documentos de livros que você acabou de adicionar.

Consultar e contar documentos

Nesta etapa, você recuperará e contará os dados inseridos.

Para contar o número total de documentos em uma coleção, use o método countDocuments(). Vamos contar os livros da coleção books:

db.books.countDocuments()

O comando retornará a contagem total:

3

Para encontrar documentos específicos, passe um filtro de consulta ao método find(). Um filtro de consulta é um documento que especifica as condições da busca.

Por exemplo, para encontrar todos os livros escritos por "JohnDoe", use a consulta a seguir:

db.books.find({ author: "JohnDoe" })

O filtro { author: "JohnDoe" } informa ao MongoDB para retornar somente os documentos cujo campo author tenha o valor "JohnDoe".

Você também pode fazer consultas com base em valores numéricos. Vamos encontrar todos os livros publicados no ano de 2023:

db.books.find({ year: 2023 })

Isso retornará o livro "MongoDBBasics". O método find() é uma ferramenta poderosa para recuperar exatamente os dados de que você precisa.

Atualizar e remover documentos

Nesta etapa, você atualizará e removerá documentos de uma coleção.

Para alterar um documento existente, use o método updateOne(). Ele recebe um filtro que seleciona o documento e um documento de atualização que descreve a alteração. O operador $set altera somente o campo especificado.

Vamos atualizar o ano de publicação do livro "PythonProgramming" de 2022 para 2024:

db.books.updateOne(
    { title: "PythonProgramming" },
    { $set: { year: 2024 } }
)

O MongoDB confirmará que encontrou e modificou um documento:

{
  acknowledged: true,
  insertedId: null,
  matchedCount: 1,
  modifiedCount: 1,
  upsertedCount: 0
}

Verifique o documento atualizado:

db.books.find({ title: "PythonProgramming" })

Agora, o resultado mostrará year: 2024 para o livro "PythonProgramming".

Em seguida, remova documentos da coleção.

Para remover um único documento que corresponda a uma condição específica, use o método deleteOne(). Vamos remover o livro com o título "MongoDBBasics":

db.books.deleteOne({ title: "MongoDBBasics" })

O shell confirmará que um documento foi excluído:

{ acknowledged: true, deletedCount: 1 }

Para remover vários documentos que correspondam a uma condição, use deleteMany(). Esse método aceita operadores de consulta para criar condições mais complexas. Por exemplo, $lt significa "menor que".

Vamos remover todos os livros publicados antes do ano de 2022:

db.books.deleteMany({ year: { $lt: 2022 } })

Esse comando exclui todos os documentos cujo campo year seja menor que 2022. Neste caso, ele removerá "DataScienceHandbook".

Para ver quais livros restaram, execute o comando find() uma última vez:

db.books.find()

Somente o livro "PythonProgramming" deverá permanecer na coleção.

Agora você praticou as operações básicas de CRUD (Create, Read, Update, Delete) no MongoDB. Para sair do shell mongosh, digite:

exit

Resumo

Parabéns por concluir seu primeiro laboratório de MongoDB! Você aprendeu e praticou com sucesso as principais operações de gerenciamento de dados em um banco de dados MongoDB.

Neste laboratório, você aprendeu a:

• Iniciar o shell mongosh para interagir com um servidor MongoDB.
• Usar o comando use para mudar de banco de dados.
• Inserir documentos únicos e múltiplos usando insertOne() e insertMany().
• Recuperar documentos usando find() com e sem filtros de consulta.
• Contar documentos em uma coleção com countDocuments().
• Atualizar um documento usando updateOne() e o operador $set.
• Remover documentos usando deleteOne() e deleteMany().

Essas habilidades fundamentais são a base para desenvolver aplicações avançadas com MongoDB. A prática é essencial, então sinta-se à vontade para experimentar mais com os comandos que aprendeu.