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 sobre 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 de que todos podemos concordar é que NoSQL é usado para executar operações em dados que são 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 oferece suporte a 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.

Relacionado: Como um banco de dados MongoDB pode organizar melhor seus dados

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 realizar qualquer operação CRUD no MongoDB, você precisará baixar e instalar o MongoDB em seu dispositivo (ou use uma versão de nuvem disponível), execute o servidor MongoDB, conecte-se a ele e, finalmente, crie um novo base de dados.

O servidor MongoDB pode ser baixado do site oficial Site 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": "REDE", "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": "REDE", "id": 23016, "ctx": "listener", "msg": "Aguardando conexões", "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 o seu objetivo é criar um usuário, você deve usar o insertOne método.

No entanto, se o objetivo for criar mais de um usuário por vez, então o insertMany método é uma opção melhor.

Exemplo de método insertOne do MongoDB

// importe mongodb e use a desestruturação para obter a função MongoClient
const {MongoClient} = require ("mongodb");
// o URL de conexão e o banco de dados ao qual pretendemos nos conectar
const connectionURL = 'mongodb: //127.0.0.1: 27017';
const databaseName = 'user-manager';
// usando a função de conexão no MongoClient para se conectar ao servidor MongoDB
MongoClient.connect (connectionURL, {useUnifiedTopology: true}, (erro, cliente) => {
// verifique se a conexão foi estabelecida
if (erro) {
return console.log ('Não foi possível conectar ao banco de dados');
}
// acesse o banco de dados do gerenciador de usuários
const db = client.db (databaseName);
// insira um usuário no banco de dados
db.collection ('usuários'). insertOne ({
nome: 'John Doe',
idade: '28'
}, (erro, resultado) => {
if (erro) {
return console.log ('Não foi possível criar o usuário');
}
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 insertOne método leva dois argumentos obrigatórios; o documento (o usuário) e uma função de retorno de chamada. Com o insertOne método, podemos inserir um usuário com o nome de Peter Davis com a idade de 32, 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:

[{nome: 'Peter Davis', idade: '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.

Relacionado: Como a modelagem de dados é diferente no MongoDB?

Ler um usuário no MongoDB

Os dois métodos principais usados ​​para ler documentos de um MongoDB são: achar e findOne. O achar método é usado para ler vários documentos de uma vez e o findOne método é usado para ler um único documento por vez.

Exemplo de método findOne do MongoDB

// importe mongodb e use a desestruturação para obter o método MongoClient
const {MongoClient} = require ("mongodb");
// o URL de conexão e o banco de dados ao qual pretendemos nos conectar
const connectionURL = 'mongodb: //127.0.0.1: 27017';
const databaseName = 'user-manager';
// usando a função de conexão no MongoClient para se conectar ao servidor MongoDB
MongoClient.connect (connectionURL, {useUnifiedTopology: true}, (erro, cliente) => {
// verifique se a conexão foi estabelecida
if (erro) {
return console.log ('Não foi possível conectar ao banco de dados');
}
// cria o banco de dados do gerenciador de usuários
const db = client.db (databaseName);
// encontrando um usuário no banco de dados
db.collection ('usuários'). findOne ({nome: 'Peter Davis'}, (erro, usuário) => {
if (erro) {
return console.log ('Não foi possível encontrar o usuário');
}
console.log (usuário);
})
});

É bom lembrar que você sempre precisará se conectar ao servidor MongoDB e ao banco de dados apropriado antes de executar qualquer operação CRUD (como visto em nosso exemplo acima).

O findOne método 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 findOne método é 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, nome: 'Peter Davis', idade: '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

// Atualizar a idade de um usuário
db.collection ('usuários'). updateOne ({nome: "Peter Davis"},
{
$ set: {
idade: '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 deleteOne método é usado para excluir um único documento, e o deleteMany método é usado para excluir vários documentos.

Exemplo de método deleteOne do MongoDB

// deleta um documento
db.collection ('usuários'). deleteOne ({nome: '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 a sigla 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 da imagem: Alexander Sosluev /WiKiMedia Commons

Como a modelagem de dados é diferente no MongoDB?

Está considerando uma abordagem diferente para bancos de dados? Veja como funciona a modelagem de dados no MongoDB.

Leia a seguir

Sobre o autor