Operações do MongoDB CRUD

Índice

• Definição básica de operação CRUD
• Exemplos de operações básicas
• O que é CRUD no MongoDB?
• Como realizar operações CRUD
• Desempenho CRUD em relacional vs não relacional
• Resumo
• Perguntas frequentes

Definição básica de operação CRUD

A maioria das interações transacionais que um usuário tem com uma plataforma digital, como um website ou aplicação web, inclui solicitações para quatro operações básicas:

• Criar algo novo (por exemplo, um perfil de cliente).
• Leitura (como buscar detalhes do pedido para um usuário).
• Atualização de informações (como o número de celular ou endereço de e-mail de um usuário).
• Exclusão (por exemplo, um número de telefone comercial).

O CRUD é orientado a dados e é padronizado de acordo com os verbos de ação HTTP. O front-end de um aplicativo captura as informações e as envia como uma solicitação HTTP para o middleware, que chama as funções de banco de dados apropriadas para concluir a tarefa. Essas quatro funções básicas são chamadas coletivamente de CRUD, o acrônimo para create, read, update e delete.

Exemplos de operações básicas

Os métodos CRUD são as principais maneiras de gerenciar os dados em seus bancos de dados. Seja uma operação em massa ou individual, as operações CRUD são essenciais para todo aplicativo.

Alguns exemplos de uma operação de criação são a criação de um novo perfil de usuário no banco de dados, a criação de um carrinho de compras para o usuário e a criação de um novo catálogo de livros (inserção em massa).

Alguns exemplos de operações de leitura são a obtenção de detalhes do produto para um determinado critério de pesquisa do usuário, como quando um usuário pesquisa um telefone celular da marca "Apple"; a exibição de todos os modelos do iPhone; a exibição das informações do carrinho de produtos do usuário; e a exibição dos detalhes do funcionário no portal.

Exemplos de operações de atualização incluem a atualização de informações pessoais de um usuário, informações do carrinho, endereço de cobrança, carimbo de data/hora ou o número de série de uma determinada gama de produtos (atualização em massa).

Alguns exemplos de operações de exclusão são a exclusão de produtos do carrinho de compras de um usuário, a exclusão de um livro dos favoritos e a exclusão de todos os registros mais antigos que um determinado período (exclusão em massa).

Vamos explorar mais a definição de CRUD e examinar como executar operações CRUD do MongoDB usando a MongoDB Query Language (MQL).

O que é CRUD no MongoDB?

As operações CRUD descrevem as convenções de uma interface de usuário que permite aos usuários visualizar, pesquisar e modificar partes do banco de dados. O MongoDB fornece uma maneira elegante de executar operações CRUD com a linguagem de programação de sua escolha por meio de seus drivers.

Os documentos MongoDB são modificados conectando-se a um servidor, consultando os documentos apropriados e, em seguida, alterando as propriedades de configuração antes de enviar os dados de volta ao banco de dados para serem atualizados.

Quando se trata de operações CRUD individuais:

• A operação create é usada para inserir novos documentos no banco de dados MongoDB.
• A operação read é usada para fazer query de um documento no banco de dados.
• A operação atualizar é usada para modificar documentos existentes no banco de dados.
• A operação delete é usada para remover documentos do banco de dados.

Como realizar operações CRUD

Agora que definimos as operações CRUD do MongoDB, podemos dar uma olhada em como realizar as operações individuais e manipular documentos em um banco de banco de dados MongoDB. Vamos entrar nos processos de criação, leitura, atualização e exclusão de documentos, analisando uma operação por vez.

Criar operação

Para o MongoDB CRUD, se a coleção especificada não existir, a operação criar criará a coleção quando ela for executada. As operações de criação no MongoDB têm como alvo uma única coleção, não várias coleções. As operações de inserção no MongoDB são atômicas em um único nível documento .

O MongoDB fornece duas operações de criação diferentes que você pode usar para inserir documentos em uma coleção:

• db.collection.insertOne()
• db.collection.insertMany()

insertOne()

Como o nome indica, insertOne() permite que você insira um documento na coleção. Para este exemplo, trabalharemos com uma coleção chamada RecordsDB. Podemos inserir uma única entrada em nossa coleção chamando o método insertOne() no RecordsDB. Em seguida, fornecemos as informações que queremos inserir na forma de pares de valores-chave, estabelecendo o esquema.

db.RecordsDB.insertOne({
    name: "Marsh",
    age: "6 years",
    species: "Dog",
    ownerAddress: "380 W. Fir Ave",
    chipped: true
})

Se a operação de criação for bem-sucedida, um novo documento será criado. A função retornará um objeto em que “acknowledged“ é “true“ e “insertID“ é o “ObjectId“ recém-criado.

> db.RecordsDB.insertOne({
... name: "Marsh",
... age: "6 years",
... species: "Dog",
... ownerAddress: "380 W. Fir Ave",
... chipped: true
... })
{
        "acknowledged" : true,
        "insertedId" : ObjectId("5fd989674e6b9ceb8665c57d")
}

insertMany()

É possível inserir vários itens de uma vez chamando o método insertMany() na coleção desejada. Nesse caso, passamos vários itens para nossa coleção escolhida (RecordsDB) e os separamos por vírgulas. Dentro dos parênteses, usamos colchetes para indicar que estamos passando uma lista de múltiplas entradas. Isso é comumente chamado de método aninhado.

 db.RecordsDB.insertMany([{
    name: "Marsh",
    age: "6 years",
    species: "Dog",
    ownerAddress: "380 W. Fir Ave",
    chipped: true},
      {name: "Kitana", 
      age: "4 years", 
      species: "Cat", 
      ownerAddress: "521 E. Cortland", 
      chipped: true}])

 db.RecordsDB.insertMany([{ name: "Marsh", age: "6 years", species: "Dog", 
ownerAddress: "380 W. Fir Ave", chipped: true}, {name: "Kitana", age: "4 years", 
species: "Cat", ownerAddress: "521 E. Cortland", chipped: true}])
{
        "acknowledged" : true,
        "insertedIds" : [
                ObjectId("5fd98ea9ce6e8850d88270b4"),
                ObjectId("5fd98ea9ce6e8850d88270b5")
        ]
}

Operações de leitura

As operações ler permitem que você forneça filtros de queries e critérios especiais que permitem especificar quais documentos você deseja. A documentação do MongoDB contém mais informações sobre os filtros de queries disponíveis filters. Os modificadores de query também podem ser usados para alterar quantos resultados são retornados.

O MongoDB tem dois métodos de leitura de documentos de uma coleção:

• db.collection.find()
• db.collection.findOne()

find()

Para obter todos os documentos de uma coleção, podemos simplesmente usar o método find() em nossa coleção escolhida. Executar apenas o método find() sem argumentos retornará todos os registros atualmente na coleção.

Db. RegistrosDB.find()

{ "_id" : ObjectId("5fd98ea9ce6e8850d88270b5"), "name" : "Kitana", "age" : "4 years", "species" : "Cat", "ownerAddress" : "521 E. Cortland", "chipped" : true }
{ "_id" : ObjectId("5fd993a2ce6e8850d88270b7"), "name" : "Marsh", "age" : "6 years", "species" : "Dog", "ownerAddress" : "380 W. Fir Ave", "chipped" : true }
{ "_id" : ObjectId("5fd993f3ce6e8850d88270b8"), "name" : "Loo", "age" : "3 years", "species" : "Dog", "ownerAddress" : "380 W. Fir Ave", "chipped" : true }
{ "_id" : ObjectId("5fd994efce6e8850d88270ba"), "name" : "Kevin", "age" : "8 years", "species" : "Dog", "ownerAddress" : "900 W. Wood Way", "chipped" : true }

No resultado, podemos ver todos os registros presentes na coleção. Observe que cada registro tem um “ObjectId“ atribuído mapeado para a chave “_id“.

Se você quiser ser mais específico com uma operação de leitura e encontrar uma subseção desejada dos registros, poderá usar os critérios de filtro mencionados anteriormente para escolher quais resultados devem ser retornados. Uma das formas mais comuns de filtrar os resultados é pesquisar por valor.

Db. RegistrosDB.find({"species":"Cat"})

{ "_id" : ObjectId("5fd98ea9ce6e8850d88270b5"), "name" : "Kitana", "age" : "4 years", "species" : "Cat", "ownerAddress" : "521 E. Cortland", "chipped" : true }

findOne()

Para obter um documento que satisfaça os critérios de pesquisa, podemos simplesmente usar o método findOne() em nossa coleção escolhida. Se vários documentos satisfizerem a query, esse método retornará o primeiro documento de acordo com a ordem natural que reflete a ordem dos documentos no disco. Se nenhum documento atender aos critérios de pesquisa, a função retornará nula. A função assume a seguinte forma de sintaxe.

Db.{collection}.findOne({query}, {projection})

Vamos usar a seguinte coleção — digamos, RecordsDB, como exemplo.

{ "_id" : ObjectId("5fd98ea9ce6e8850d88270b5"), "name" : "Kitana", "age" : "8 years", "species" : "Cat", "ownerAddress" : "521 E. Cortland", "chipped" : true }
{ "_id" : ObjectId("5fd993a2ce6e8850d88270b7"), "name" : "Marsh", "age" : "6 years", "species" : "Dog", "ownerAddress" : "380 W. Fir Ave", "chipped" : true }
{ "_id" : ObjectId("5fd993f3ce6e8850d88270b8"), "name" : "Loo", "age" : "3 years", "species" : "Dog", "ownerAddress" : "380 W. Fir Ave", "chipped" : true }
{ "_id" : ObjectId("5fd994efce6e8850d88270ba"), "name" : "Kevin", "age" : "8 years", "species" : "Dog", "ownerAddress" : "900 W. Wood Way", "chipped" : true }

E executamos a seguinte linha de código:

Db. RegistrosDB.find({"age":"8 years"})

Obteríamos o seguinte resultado:

{ "_id" : ObjectId("5fd98ea9ce6e8850d88270b5"), "name" : "Kitana", "age" : "8 years", "species" : "Cat", "ownerAddress" : "521 E. Cortland", "chipped" : true }

Observe que, embora dois documentos atendam aos critérios de pesquisa, somente o primeiro documento que corresponder à condição de pesquisa será retornado.

Operações de atualização

Como operações de criação, atualizar as operações operam em uma única coleção e são atômicas em um único nível de documento. Uma operação de atualização utiliza filtros e critérios para selecionar os documentos que você deseja atualizar.

Você deve ter cuidado ao atualizar documentos, pois as atualizações são permanentes e não podem ser revertidas. Isso também se aplica às operações de exclusão.

Para o MongoDB CRUD, existem três métodos diferentes de atualização de documentos:

• db.collection.updateOne()
• db.collection.updateMany()
• db.collection.replaceOne()

updateOne()

Podemos atualizar um registro existente no momento e alterar um único documento com uma operação de atualização. Para fazer isso, usamos o método updateOne() em uma coleção escolhida, que aqui é “RecryptsDB“. Para atualizar um documento, fornecemos ao método dois argumentos: um filtro de atualização e uma ação de atualização.

O filtro de atualização define quais itens queremos atualizar, e a ação de atualização define como atualizar esses itens. Primeiro, passamos pelo filtro de atualização. Em seguida, usamos a chave “$set” e fornecemos os campos que queremos atualizar como um valor. Este método atualizará o primeiro registro que corresponder ao filtro fornecido.

db.RecordsDB.updateOne({name: "Marsh"}, {$set:{ownerAddress: "451 W. Coffee St. A204"}})

{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }

{ "_id" : ObjectId("5fd993a2ce6e8850d88270b7"), "name" : "Marsh", "age" : "6 years", "species" : "Dog", "ownerAddress" : "451 W. Coffee St. A204", "chipped" : true }

updateMany( )

updateMany() nos permite atualizar vários itens passando uma lista de itens, assim como fizemos ao inserir vários itens. Esta operação de atualização usa a mesma sintaxe para atualizar um único documento.

db.RecordsDB.updateMany({species:"Dog"}, {$set: {age: "5"}})

{ "acknowledged" : true, "matchedCount" : 3, "modifiedCount" : 3 }

> db.RedocsDB.find()
{ "_id" : ObjectId("5fd98ea9ce6e8850d88270b5"), "name" : "Kitana", "age" : "4 years", "species" : "Cat", "ownerAddress" : "521 E. Cortland", "chipped" : true }
{ "_id" : ObjectId("5fd993a2ce6e8850d88270b7"), "name" : "Marsh", "age" : "5", "species" : "Dog", "ownerAddress" : "451 W. Coffee St. A204", "chipped" : true }
{ "_id" : ObjectId("5fd993f3ce6e8850d88270b8"), "name" : "Loo", "age" : "5", "species" : "Dog", "ownerAddress" : "380 W. Fir Ave", "chipped" : true }
{ "_id" : ObjectId("5fd994efce6e8850d88270ba"), "name" : "Kevin", "age" : "5", "species" : "Dog", "ownerAddress" : "900 W. Wood Way", "chipped" : true }

replaceOne()

O método replaceOne() substitui um único documento na coleção especificada. replaceOne() substitui o documento inteiro, o que significa que os campos do documento antigo que não estejam no novo serão perdidos.

 db.RecordsDB.replaceOne({name: "Kevin"}, {name: "Maki"})

{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }

 > db.RecordsDB.find()
{ "_id" : ObjectId("5fd98ea9ce6e8850d88270b5"), "name" : "Kitana", "age" : "4 years", "species" : "Cat", "ownerAddress" : "521 E. Cortland", "chipped" : true }
{ "_id" : ObjectId("5fd993a2ce6e8850d88270b7"), "name" : "Marsh", "age" : "5", "species" : "Dog", "ownerAddress" : "451 W. Coffee St. A204", "chipped" : true }
{ "_id" : ObjectId("5fd993f3ce6e8850d88270b8"), "name" : "Loo", "age" : "5", "species" : "Dog", "ownerAddress" : "380 W. Fir Ave", "chipped" : true }
{ "_id" : ObjectId("5fd994efce6e8850d88270ba"), "name" : "Maki" }

Excluir operações

Excluir as operações operam em uma única coleção, como operações de atualização e criação. As operações de exclusão também são atômicas para um único documento. Você pode fornecer operações de exclusão com filtros e critérios para especificar quais documentos você deseja excluir de uma coleção. As opções de filtro dependem da mesma sintaxe que as operações de leitura utilizam.

O MongoDB tem dois métodos diferentes para excluir registros de uma coleção:

• db.collection.deleteOne()
• db.collection.deleteMany()

deleteOne()

deleteOne() remove um documento de uma coleção especificada no servidor MongoDB. Um critério de filtro é usado para especificar o item a ser excluído. Ele exclui o primeiro registro que corresponde ao filtro fornecido.

 db.RecordsDB.deleteOne({name:"Maki"})

{ "acknowledged" : true, "deletedCount" : 1 }

 > db.RecordsDB.find()
{ "_id" : ObjectId("5fd98ea9ce6e8850d88270b5"), "name" : "Kitana", "age" : "4 years", "species" : "Cat", "ownerAddress" : "521 E. Cortland", "chipped" : true }
{ "_id" : ObjectId("5fd993a2ce6e8850d88270b7"), "name" : "Marsh", "age" : "5", "species" : "Dog", "ownerAddress" : "451 W. Coffee St. A204", "chipped" : true }
{ "_id" : ObjectId("5fd993f3ce6e8850d88270b8"), "name" : "Loo", "age" : "5", "species" : "Dog", "ownerAddress" : "380 W. Fir Ave", "chipped" : true }

deleteMany()

deleteMany() is é um método usado para excluir vários documentos de uma coleção desejada com uma única operação de exclusão. Uma lista é passada para o método e os itens individuais são definidos com critérios de filtro como em deleteOne().

 db.RecordsDB.deleteMany({species:"Dog"})

{ "acknowledged" : true, "deletedCount" : 2 }

 > db.RecordsDB.find()
{ "_id" : ObjectId("5fd98ea9ce6e8850d88270b5"), "name" : "Kitana", "age" : "4 years", "species" : "Cat", "ownerAddress" : "521 E. Cortland", "chipped" : true }

Desempenho de CRUD em bancos de dados relacionais versus não relacionais

Os bancos de dados NoSQL são mais bem otimizados para operações de criação e leitura e oferecem mais escalabilidade. Portanto, eles são adequados para cargas mais altas (lidam com mais operações CRUD). Eles também são flexíveis em termos de armazenamento de informações.

Em um experimento detalhado conduzido pela ResearchGate sobre operações CRUD realizadas com diferentes tipos de bancos de dados NoSQL e SQL, concluiu-se que os bancos de dados NoSQL tiveram um desempenho significativamente melhor do que os bancos de dados SQL em todas as operações CRUD, especialmente quando o número de operações era alto. Por exemplo, o MongoDB se destacou na busca de dados (operações de leitura), com um tempo médio de desempenho de 43,5 ms para 100.000 operações de leitura (localizar/selecionar). O MongoDB também tem a vantagem de fornecer atualizações atômicas (atualizações em nível de campo), o que consome mais tempo em qualquer outro banco de dados orientado a documentos.

Recursos

Este artigo abordou informações básicas sobre CRUD com alguns exemplos de como as operações CRUD são feitas no MongoDB. O MongoDB Atlas oferece uma maneira simples de realizar operações CRUD usando a IU. Você pode conferir o manual do MongoDB para aprender mais sobre para desenvolver aplicativos de alto desempenho e escaláveis.

Conteúdo relacionado:

• Curso da MongoDB University - M201: MongoDB Performance
• O que é replicação no MongoDB?
• Guia para iniciantes: noções básicas do MongoDB
• Como usar transações ACID no MongoDB
• Como incorporar documentos no MongoDB
• Exemplos do MongoDB
• As cinco melhores práticas recomendadas para a segurança do MongoDB