Como realizar operações CRUD no MongoDB
O MongoDB fornece a seus usuários a capacidade de criar bancos de dados modernos que são facilmente acessados e manipulados.
MongoDB é um banco de dados NoSQL de código aberto que está disponível para uso em todos os sistemas operacionais.
Se você aprendeu design de banco de dados na escola, é provável que não tenha aprendido a usar MongoDB ou tenha adquirido muita experiência com bancos de dados NoSQL. Isso não é surpresa – até 1998, muitas pessoas nem tinham ouvido falar do NoSQL, e não foi até 2009 que os bancos de dados NoSQL começaram a ganhar força.
O que é NoSQL?
A sigla SQL significa "linguagem de consulta estruturada". SQL é usado para realizar operações matemáticas em dados mantidos em bancos de dados que são rigidamente estruturados por linhas e colunas (tabelas).
A sigla NoSQL, dependendo de quem você perguntar, significa "não apenas SQL" ou "não SQL". No entanto, o único fato com o qual todos podem concordar é que o NoSQL é usado para executar operações em dados mantidos em bancos de dados não estruturados por linhas e colunas.
Existem alguns bancos de dados NoSQL, mas o nome que fica acima do resto é MongoDB. Na verdade, algumas pessoas pensam que o MongoDB é o único banco de dados desse tipo.
O que é MongoDB?
NoSQL suporta quatro tipos diferentes de bancos de dados: documento, armazenamentos de valores-chave, orientado a colunas e gráfico. O MongoDB é um banco de dados de documentos porque armazena dados em um documento do tipo JSON e, como todos os bancos de dados, oferece suporte a todas as operações CRUD essenciais.
O que são operações CRUD?
A sigla CRUD significa "criar, ler, atualizar e excluir". CRUD representa os quatro requisitos funcionais básicos de todos os bancos de dados. Se você estiver usando um banco de dados que não permite criar, ler, atualizar ou excluir registros, então não é um banco de dados.
Baixe o MongoDB
Antes de executar qualquer operação CRUD no MongoDB, você precisará baixar e instalar o MongoDB em seu dispositivo (ou usar uma versão de nuvem disponível), executar o servidor MongoDB, conectar-se a ele e, finalmente, criar um novo banco de dados.
O servidor MongoDB pode ser baixado do site oficial do MongoDB .
Executando o servidor MongoDB
Execute o servidor MongoDB a partir do console do seu IDE.
/Users/Administrator/mongodb/bin/mongod.exe --dbpath=/Users/Administrator/mongodb-data
O código acima executa o servidor MongoDB. A primeira metade fornece o caminho direto para o arquivo executável MongoDB (mongod.exe) que está armazenado em seu dispositivo. O nome do caminho no seu dispositivo deve ser diferente, mas o objetivo é acessar o arquivo mongod.exe na pasta bin.
A segunda metade do código (que é separada pela barra de espaço) é outro nome de caminho. Esse caminho leva a “mongodb-data”, que é um arquivo que você precisa criar por conta própria. Este arquivo conterá todos os dados que são criados em nosso banco de dados.
Nosso arquivo é chamado de “mongodb-data”, mas o nome pode ser o que você achar adequado.
Executar o código acima deve produzir várias linhas de código, mas as duas linhas que você precisa prestar atenção podem ser vistas abaixo:
{"t":{"$date":"2021-04-14T18:10:11.779-05:00"},"s":"I", "c":"NETWORK", "id":23015, "ctx":"listener","msg":"Listening on","attr":{"address":"127.0.0.1"}}
{"t":{"$date":"2021-04-14T18:10:11.797-05:00"},"s":"I", "c":"NETWORK", "id":23016, "ctx":"listener","msg":"Waiting for connections","attr":{"port":27017,"ssl":"off"}}
Essas duas linhas contêm o localhost e a porta padrão do servidor MongoDB, respectivamente. Esses dois números são necessários para criar posteriormente uma conexão com o servidor MongoDB para que possamos realizar nossas operações CRUD.
Executando Operações CRUD
Agora que nosso servidor MongoDB está instalado e funcionando, podemos nos conectar a ele (usando o driver apropriado) e começar a executar as operações CRUD. Para este artigo, criaremos um banco de dados de usuário simples que armazenará os nomes e idades de nossos usuários.
Criação de um usuário
Existem duas maneiras principais de inserir usuários em um banco de dados MongoDB. Ambos os métodos são bastante semelhantes, mas o método que você deve escolher depende do número de usuários que deseja criar em uma instância específica. Se seu objetivo é criar um usuário, você deve usar o método insertOne .
No entanto, se o objetivo é criar mais de um usuário por vez, o método insertMany é uma opção melhor.
Exemplo de método insertOne do MongoDB
// import mongodb and use destructuring to get the MongoClient function
const { MongoClient } = require("mongodb");
//the connection URL and the database that we intend to connect to
const connectionURL = 'mongodb://127.0.0.1:27017';
const databaseName = 'user-manager';
//using the connect function on the MongoClient to connect to the MongoDB server
MongoClient.connect(connectionURL, { useUnifiedTopology: true }, (error, client) =>{
//check if connection was established
if (error){
return console.log('Could not connect to database');
}
//access the user-manager database
const db = client.db(databaseName);
//insert one user into the database
db.collection('users').insertOne({
name: 'John Doe',
age: '28'
}, (error,result) =>{
if (error){
return console.log('Could not create user');
}
console.log(result.ops);
})
})
Antes de podermos criar qualquer usuário, uma conexão deve ser estabelecida com o servidor MongoDB usando o driver MongoDB do idioma que você está usando. O driver mais popular, e aquele que estamos usando neste tutorial, é o driver NodeJS.
Com a primeira linha de nosso código acima, podemos usar o método de desestruturação para recuperar a função MongoClient de nosso servidor.
O MongoClient aceita três argumentos:
- Um URL (usado para se conectar ao servidor MongoDB)
- Opções / Configurações (que neste caso é definir a variável "useUnifiedTopology" como true, para facilitar o uso do novo mecanismo de descoberta e monitoramento do servidor)
- Uma função de retorno de chamada que leva dois argumentos (erro e cliente)
Na função de retorno de chamada do método MongoClient, podemos finalmente inserir um usuário em nosso banco de dados. Mas antes de chegarmos a esse ponto, precisamos obter acesso ao banco de dados do gerenciador de usuários.
Uma das vantagens de usar o MongoDB é que não há necessidade de criar explicitamente um banco de dados. Uma vez que uma referência a um determinado banco de dados é gerada usando o argumento “cliente” (como visto no código acima), você está livre para começar a manipulá-lo.
A referência ao banco de dados do gerenciador de usuários que geramos é armazenada na variável “db”, que usaremos para inserir nosso primeiro usuário no banco de dados.
Usando a referência “db”, podemos criar uma nova coleção, à qual atribuímos o nome de "usuário".
O método insertOne leva dois argumentos obrigatórios; o documento (o usuário) e uma função de retorno de chamada. Com o método insertOne , podemos inserir um usuário de nome Peter Davis com 32 anos de idade em nosso banco de dados.
A função de retorno de chamada leva dois argumentos (erro e resultado). A função de resultado contém um método ops que usamos para ver o usuário que acabamos de criar em nosso banco de dados. Isso produz a seguinte saída no console, depois que o código acima é executado:
[ { name: 'Peter Davis', age: '32', _id: 60772f869475e84740003c45 } ]
Embora tenhamos fornecido apenas dois campos ao criar um usuário, você pode ver na saída acima que um terceiro campo foi gerado. Essa é outra coisa legal sobre o MongoDB; ele gera automaticamente um id único para cada documento que cria.
Ler um usuário no MongoDB
Os dois métodos principais usados para ler documentos de um MongoDB são: find e findOne . O método find é usado para ler vários documentos de uma vez e o método findOne é usado para ler um único documento por vez.
Exemplo de método findOne do MongoDB
// import mongodb and use destructuring to get the MongoClient method
const { MongoClient } = require("mongodb");
//the connection URL and the database that we intend to connect to
const connectionURL = 'mongodb://127.0.0.1:27017';
const databaseName = 'user-manager';
//using the connect function on the MongoClient to connect to the MongoDB server
MongoClient.connect(connectionURL, { useUnifiedTopology: true }, (error, client) =>{
//check if connection was established
if (error){
return console.log('Could not connect to database') ;
}
//create the user-manager database
const db = client.db(databaseName);
//finding one user into the database
db.collection('users').findOne({name: 'Peter Davis'}, (error, user) => {
if (error){
return console.log('Could not find user');
}
console.log(user);
})
});
É bom lembrar que você sempre precisará se conectar ao servidor MongoDB e ao banco de dados apropriado antes de realizar qualquer operação CRUD (como visto em nosso exemplo acima).
O método findOne leva dois argumentos obrigatórios. O primeiro argumento contém os critérios de pesquisa; você pode pesquisar um documento usando qualquer nome de variável que seja exclusivo dele. Em nosso exemplo acima, usamos o nome “Peter Davis”.
O segundo argumento do método findOne é a função de retorno de chamada que recebe dois argumentos; o primeiro é um erro se o documento não puder ser localizado, e o segundo é o documento (que chamamos de "usuário").
Executar o código acima produzirá o seguinte resultado no console:
{ _id: 60772f869475e84740003c45, name: 'Peter Davis', age: '32' }
Atualizar um usuário no MongoDB
Existem dois métodos disponíveis para atualizar documentos no MongoDB. Embora a estrutura de ambos seja muito semelhante, updateOne é usado para atualizar um documento por vez e updateMany é usado para atualizar muitos documentos de uma vez.
Exemplo de método MongoDB updateOne
//Update a user's age
db.collection('users').updateOne({ name: "Peter Davis"},
{
$set: {
age: '24'
}
})
Com o código acima, podemos atualizar a idade de Peter Davis para 24 anos.
Exclusão de um usuário no MongoDB
Existem dois métodos disponíveis para excluir um documento do MongoDB. O método deleteOne é usado para excluir um único documento e o método deleteMany é usado para excluir vários documentos.
Exemplo de método deleteOne do MongoDB
//delete a document
db.collection('users').deleteOne({ name: 'Peter Davis'})
A operação de exclusão é a operação CRUD mais simples que pode ser executada no MongoDB. Como você pode ver no exemplo acima (sem incluir o código de conexão necessário e a função de retorno de chamada), leva apenas uma linha de código.
Agora você pode realizar operações CRUD no MongoDB
Agora você tem conhecimento básico de MongoDB e sabe o que significa NoSQL. Você também sabe o que significa o acrônimo CRUD e por que essas operações são qualidades essenciais de todo banco de dados.
Este artigo fornece todas as ferramentas necessárias para realizar as quatro operações CRUD básicas no MongoDB. Agora que você está equipado com o know-how de operações CRUD, pode começar a aprender a melhor forma de modelar seus dados usando o MongoDB.
Crédito de imagem: Alexander Sosluev / WiKiMedia Commons
