Introdução
Neste laboratório, você aprenderá a trabalhar com vários tipos de dados fundamentais no MongoDB. O laboratório abrange exemplos práticos de como armazenar, consultar e manipular dados usando números, strings, booleanos, datas e ObjectIds. Você ganhará experiência prática realizando operações comuns de banco de dados e compreendendo os casos de uso apropriados para cada tipo de dado. Ao final deste laboratório, você terá uma base sólida para modelar dados de forma eficaz no MongoDB.
Trabalhando com Números e Strings
Nesta primeira etapa, você aprenderá a usar os tipos de dados mais comuns: números e strings. Você iniciará o shell do MongoDB, criará um banco de dados e uma coleção e, em seguida, inserirá e consultará documentos contendo esses tipos.
Primeiro, abra seu terminal e inicie o shell do MongoDB. Este ambiente interativo permite que você execute comandos diretamente em seu banco de dados.
mongosh
Uma vez dentro do shell, você verá um prompt >. Vamos criar e alternar para um novo banco de dados chamado inventory. No MongoDB, um banco de dados é criado automaticamente quando você armazena dados nele pela primeira vez.
use inventory
Agora, crie uma coleção chamada products e insira um documento. Este documento conterá um campo de string (name) e dois campos numéricos (price e stock). O MongoDB usa tipos BSON (Binary JSON), onde os números podem ser inteiros ou de ponto flutuante (doubles).
db.products.insertOne({
name: "Laptop",
price: 1200.50,
stock: 50
})
Você deverá ver uma mensagem de confirmação com o ObjectId do documento recém-inserido.
Exemplo de Saída:
{
"acknowledged": true,
"insertedId": ObjectId("...")
}
Agora que o documento foi inserido, vamos consultar a coleção. Primeiro, encontre produtos com preço superior a 1000 usando o operador $gt (greater than - maior que).
db.products.find({ price: { $gt: 1000 } })
Exemplo de Saída:
[
{
_id: ObjectId("..."),
name: 'Laptop',
price: 1200.5,
stock: 50
}
]
Em seguida, execute uma consulta para encontrar um produto pelo seu nome exato, que é um valor de string. Esta é uma maneira comum de recuperar itens específicos.
db.products.find({ name: "Laptop" })
Este comando retornará o mesmo documento, demonstrando como consultar com base em campos de string.
Usando Valores Booleanos e Nulos
Nesta etapa, você explorará os tipos de dados booleanos e nulos. Booleanos são ideais para campos que representam um estado verdadeiro ou falso, como flags. O tipo nulo é usado para representar um campo sem valor.
Continuaremos usando o banco de dados inventory no shell mongosh. Insira um novo produto com os campos booleanos inStock e onSale, e um campo discontinuedDate definido como null.
db.products.insertOne({
name: "Wireless Mouse",
price: 25,
inStock: true,
onSale: false,
discontinuedDate: null
})
Exemplo de Saída:
{
"acknowledged": true,
"insertedId": ObjectId("...")
}
Agora você tem um documento com valores booleanos e nulos. Você pode consultá-los como qualquer outro tipo de dado. Vamos encontrar todos os produtos que estão atualmente em estoque consultando o valor booleano true.
db.products.find({ inStock: true })
Exemplo de Saída:
[
{
_id: ObjectId("..."),
name: 'Wireless Mouse',
price: 25,
inStock: true,
onSale: false,
discontinuedDate: null
}
]
Este comando recupera documentos onde o campo inStock é exatamente true. Em seguida, vamos encontrar produtos que não foram descontinuados procurando por um valor null no campo discontinuedDate. Observe que no MongoDB, consultar por null corresponde tanto a documentos onde o campo está explicitamente definido como null quanto a documentos onde o campo não existe.
db.products.find({ discontinuedDate: null })
Esta consulta retornará vários documentos: o "Wireless Mouse" (que tem discontinuedDate: null) e quaisquer outros produtos que não tenham um campo discontinuedDate (como "Laptop"). Se você quiser encontrar apenas documentos onde o campo está explicitamente definido como null, você precisará usar um padrão de consulta diferente.
Armazenando Datas e Timestamps
Esta etapa foca no tipo de dado Date, que é essencial para armazenar informações baseadas em tempo, como datas de criação, atualizações ou eventos. O MongoDB armazena datas como inteiros de 64 bits representando milissegundos desde a época Unix (1 de janeiro de 1970, UTC).
Vamos inserir um documento com campos de data. Você pode criar um objeto de data para o tempo atual usando new Date() ou para um tempo específico passando uma string de data ISO-8601.
db.products.insertOne({
name: "Smartwatch",
price: 250,
purchaseDate: new Date("2023-10-26T10:00:00Z"),
lastUpdated: new Date()
})
Exemplo de Saída:
{
"acknowledged": true,
"insertedId": ObjectId("...")
}
Agora, vamos consultar produtos com base em seus campos de data. Por exemplo, encontre todos os produtos comprados a partir do início de 2023. Você pode usar o operador $gte (greater than or equal to - maior ou igual a) com um objeto Date.
db.products.find({
purchaseDate: { $gte: new Date("2023-01-01") }
})
Exemplo de Saída:
[
{
_id: ObjectId("..."),
name: 'Smartwatch',
price: 250,
purchaseDate: ISODate('2023-10-26T10:00:00.000Z'),
lastUpdated: ISODate('...')
}
]
O MongoDB também fornece operadores de atualização para datas. O operador $currentDate é útil para definir um campo para a data atual do servidor. Vamos atualizar o campo lastUpdated para o documento "Laptop" que você criou anteriormente para rastrear quando ele foi modificado pela última vez.
db.products.updateOne(
{ name: "Laptop" },
{ $currentDate: { lastUpdated: true } }
)
Exemplo de Saída:
{
"acknowledged": true,
"insertedId": null,
"matchedCount": 1,
"modifiedCount": 1,
"upsertedCount": 0
}
Esta operação encontra o documento com o nome "Laptop" e atualiza seu campo lastUpdated para o timestamp atual.
Compreendendo ObjectIds e Arrays
Nesta etapa final, você aprenderá sobre dois tipos estruturais importantes: ObjectId e Array. Cada documento no MongoDB possui um campo _id único, que por padrão é um ObjectId se não for fornecido. Arrays permitem que você armazene listas de valores dentro de um único campo.
Primeiro, vamos inserir um documento com um campo array chamado tags. Isso é útil para armazenar várias categorias ou atributos.
db.products.insertOne({
name: "Mechanical Keyboard",
price: 75,
tags: ["gaming", "mechanical", "RGB"]
})
Exemplo de Saída:
{
"acknowledged": true,
"insertedId": ObjectId("...")
}
O insertedId é o ObjectId deste novo documento. É um valor de 12 bytes que garante a exclusividade. Você pode consultar um documento pelo seu _id. Primeiro, encontre o documento e armazene seu _id em uma variável.
const keyboard = db.products.findOne({ name: "Mechanical Keyboard" })
const keyboardId = keyboard._id
Agora, use esta variável keyboardId para buscar o documento novamente. Esta é a maneira mais eficiente de recuperar um único documento específico.
db.products.findOne({ _id: keyboardId })
Em seguida, vamos trabalhar com o array tags. Você pode consultar documentos onde o array contém um elemento específico. Por exemplo, para encontrar todos os produtos com a tag "gaming":
db.products.find({ tags: "gaming" })
Exemplo de Saída:
[
{
_id: ObjectId("..."),
name: 'Mechanical Keyboard',
price: 75,
tags: [ 'gaming', 'mechanical', 'RGB' ]
}
]
Este comando encontra eficientemente todos os documentos onde o array tags inclui a string "gaming". Arrays são um recurso poderoso para modelar relacionamentos dentro de um único documento. Para sair do shell do MongoDB, digite exit ou pressione Ctrl+D.
exit
Resumo
Neste laboratório, você aprendeu a trabalhar com os tipos de dados mais essenciais no MongoDB. Você começou usando números e strings para armazenar e consultar informações de produtos. Em seguida, explorou booleanos e o valor nulo para representar flags de status e dados ausentes. Você também aprendeu a lidar com dados temporais usando o tipo Date e seus operadores associados. Finalmente, você obteve uma compreensão do ObjectId como um identificador único e do tipo Array para armazenar listas de valores. Este conhecimento fornece uma base sólida para projetar e interagir com bancos de dados MongoDB para uma ampla gama de aplicações.
