Explore o novo chatbot do Developer Center! O MongoDB AI chatbot pode ser acessado na parte superior da sua navegação para responder a todas as suas perguntas sobre o MongoDB .

Junte-se a nós no Amazon Web Services re:Invent 2024! Saiba como usar o MongoDB para casos de uso de AI .
Desenvolvedor do MongoDB
Central de desenvolvedor do MongoDBchevron-right
Idiomaschevron-right
JavaScriptchevron-right

MongoDB e Node.js 3.3.2 Tutorial - Operações CRUD

Lauren Schaefer17 min read • Published Feb 04, 2022 • Updated Oct 01, 2024
Node.jsMongoDBJavaScript
Ícone do FacebookÍcone do Twitterícone do linkedin
Avalie esse Início rápido
star-empty
star-empty
star-empty
star-empty
star-empty
Logotipo do Início rápido em Node.js
Na primeira publicação desta série, mostrei como se conectar a um MongoDB database a partir de um script Node.js, recuperar uma lista de banco de dados e imprimir os resultados no console. Se você ainda não leu essa publicação, recomendo que o faça e depois volte aqui.
Esta publicação usa o MongoDB 4.0, Driver MongoDB Node.js 3.3.2 e Node.js 10.16.3.
Clique aqui para ver uma versão mais recente desta publicação que usa o MongoDB 4.4, Driver Node.js do MongoDB 3.6.4 e Node.js 14.15.4.
Agora que nos conectamos a um banco de dados, vamos começar com as operações CRUD (criar, ler, atualizar e excluir).
Se você preferir vídeo a texto, sem problemas. Confira o vídeo na seção abaixo. :-)
Comece hoje mesmo com um cluster M0 no Atlas. É gratuito para sempre e é a maneira mais fácil de experimentar as etapas desta série de blogs.
Este é um resumo do que abordaremos nesta publicação:

Aprenda por vídeo

Criei o vídeo abaixo para quem prefere aprender por vídeo em vez de texto. Este vídeo também pode ser útil se você tiver dúvidas ao tentar seguir as etapas das instruções em texto abaixo.
Aqui está um resumo do que o vídeo aborda:
  • Como se conectar a um MongoDB database hospedado no MongoDB Atlas de dentro de um script Node.js (00:40)
  • Como o MongoDB armazena dados em documentos e coleções (em vez de linhas e tabelas) (08:51)
  • Como criar documentos usando insertOne() e insertMany() (11:01)
  • Como ler documentos usando findOne() e find() (20:04)
  • Como atualizar documentos usando updateOne() com e sem upsert e também updateMany() (31:13)
  • Como excluir documentos usando deleteOne() e deleteMany() (46:07)
Observação: no vídeo, digito main().catch(console.err);, que está incorreto. Em vez disso, eu deveria ter digitado main().catch(console.error);.
Abaixo estão os links que mencionei no vídeo.

Como o MongoDB armazena dados

Antes de prosseguirmos, vamos dedicar um momento para entender como os dados são armazenados no MongoDB.
O MongoDB armazena dados em documentos BSON. BSON é uma representação binária de documentos JSON (JavaScript Object Notation). Ao ler a documentação do MongoDB, você verá com frequência o termo "documento", mas entenda documento simplesmente como um objeto JavaScript. Para quem é do mundo SQL, pense que um documento equivale aproximadamente a uma linha.
O MongoDB armazena grupos de documentos em coleções. Para aqueles com experiência em SQL, você pode pensar em uma coleção como sendo aproximadamente equivalente a uma tabela.
É necessário que todo documento tenha um campo chamado _id. O valor de _id deve ser exclusivo para cada documento em uma coleção, é imutável e pode ser de qualquer tipo que não seja uma array. O MongoDB criará automaticamente um índice no _id. Você pode optar por tornar o valor de _id significativo (em vez de um ObjectId um tanto aleatório ) se tiver um valor exclusivo para cada documento que gostaria de poder pesquisar rapidamente.
Nesta série do blog, usaremos o conjunto de dados de anúncios do Airbnb de amostra. O banco de dados sample_airbnb contém uma coleção: listingsAndReviews. Essa coleção contém documentos sobre os anúncios do Airbnb e suas avaliações.
Vejamos um documento na coleção listingsAndReviews. Veja abaixo parte de uma representação de JSON estendido de um documento BSON:
1{
2 "_id":"10057447",
3 "listing_url":"https://www.airbnb.com/rooms/10057447",
4 "name":"Modern Spacious 1 Bedroom Loft",
5 "summary":"Prime location, amazing lighting and no annoying neighbours. Good place to rent if you want a relaxing time in Montreal.",
6 "property_type":"Apartment",
7 "bedrooms":{"$numberInt":"1"},
8 "bathrooms":{"$numberDecimal":"1.0"},
9 "amenities":["Internet","Wifi","Kitchen","Heating","Family/kid friendly","Washer","Dryer","Smoke detector","First aid kit","Safety card","Fire extinguisher","Essentials","Shampoo","24-hour check-in","Hangers","Iron","Laptop friendly workspace"],
10}
Para obter mais informações sobre como o MongoDB armazena dados, consulte o Webinar MongoDB Back to Basics que co-organizei com Ken Alger.

criar

Agora que sabemos como se conectar a um MongoDB database e entendemos como os dados são armazenados em um MongoDB database, vamos criar alguns dados!

Criar um documento

Vamos começar criando um novo anúncio do Airbnb. Podemos fazer isso chamando insertOne() da coleção. insertOne() insere um único documento na coleção. O único parâmetro necessário é o novo documento (de objeto do tipo) que será inserido. Se nosso novo documento não contiver o campo _id, o driver MongoDB criará automaticamente um ID para o documento.
Nossa função para criar uma nova listagem será semelhante ao seguinte:
1async function createListing(client, newListing){
2 const result = await client.db("sample_airbnb").collection("listingsAndReviews").insertOne(newListing);
3 console.log(`New listing created with the following id: ${result.insertedId}`);
4}
Podemos chamar essa função passando um MongoClient conectado, bem como um objeto que contém informações sobre um anúncio.
1await createListing(client,
2 {
3 name: "Lovely Loft",
4 summary: "A charming loft in Paris",
5 bedrooms: 1,
6 bathrooms: 1
7 }
8 );
A saída seria algo como o seguinte:
1New listing created with the following id: 5d9ddadee415264e135ccec8
Observe que, como não incluímos um campo chamado _id no documento, o driver do MongoDB criou automaticamente um _id para nós. O _id do documento que você criar será diferente do mostrado acima. Para mais informações sobre como o MongoDB gera _id, consulte Início rápido: tipos de dados BSON - ObjectId.
Se você não curte copiar e colar, pode obter uma cópia completa do código acima no repositório GitHub de início rápido do Node.js.

Criar vários documentos

Às vezes, você quer mais de um documento por vez. Você pode optar por chamar repetidamente insertOne(). O problema é que, dependendo de como estruturou seu código, você pode acabar esperando o retorno de cada operação de inserção antes de iniciar a próxima, resultando em um código lento.
Em vez disso, você pode optar por chamar insertMany() da coleção. insertMany() inserirá um array de documentos em sua coleção.
Uma opção importante a ser observada para insertMany() é ordered. Se ordered estiver definido como true, os documentos serão inseridos na ordem fornecida na array. Se alguma das inserções falhar (por exemplo, se você tentar inserir um documento com um _id que já está sendo usado por outro documento na coleção), os documentos restantes não serão inseridos. Se ordenado estiver definido como false, os documentos não poderão ser inseridos na ordem fornecida na array. O MongoDB tentará inserir todos os documentos na array fornecida — independentemente de falha em alguma das outras inserções. Por padrão, ordered está configurado para true.
Vamos gravar uma função para criar vários anúncios no Airbnb.
1async function createMultipleListings(client, newListings){
2 const result = await client.db("sample_airbnb").collection("listingsAndReviews").insertMany(newListings);
3
4 console.log(`${result.insertedCount} new listing(s) created with the following id(s):`);
5 console.log(result.insertedIds);
6}
Podemos chamar essa função passando um MongoClient conectado e um array de objetos que contêm informações sobre anúncios.
1await createMultipleListings(client, [
2 {
3 name: "Infinite Views",
4 summary: "Modern home with infinite views from the infinity pool",
5 property_type: "House",
6 bedrooms: 5,
7 bathrooms: 4.5,
8 beds: 5
9 },
10 {
11 name: "Private room in London",
12 property_type: "Apartment",
13 bedrooms: 1,
14 bathroom: 1
15 },
16 {
17 name: "Beautiful Beach House",
18 summary: "Enjoy relaxed beach living in this house with a private beach",
19 bedrooms: 4,
20 bathrooms: 2.5,
21 beds: 7,
22 last_review: new Date()
23 }
24]);
Observe que todos os documentos não têm os mesmos campos, o que é correto. (Aqueles que vêm do mundo SQL devem achar isso muito desconfortável, mas vai dar tudo certo 😊.) Ao usar o MongoDB, você obtém muita flexibilidade na forma de estruturar seus documentos. Se, posteriormente, você decidir que deseja adicionar regras de validação de esquema para garantir que seus documentos tenham uma estrutura específica, poderá fazer isso.
A saída da chamada de createMultipleListings() seria algo assim:
13 new listing(s) created with the following id(s):
2{
3 '0': 5d9ddadee415264e135ccec9,
4 '1': 5d9ddadee415264e135cceca,
5 '2': 5d9ddadee415264e135ccecb
6}
Assim como o driver do MongoDB criou automaticamente o campo _id para nós quando chamamos insertOne(), o driver criou mais uma vez o campo _id para nós quando chamamos insertMany().
Se você não curte copiar e colar, pode obter uma cópia completa do código acima no repositório GitHub de início rápido do Node.js.

Leia

Agora que sabemos como criar documentos, vamos ler um!

Leia um documento

Vamos começar consultando um anúncio do Airbnb na coleção listingsAndReviews por nome.
Podemos fazer uma query para um documento chamando o findOne() de Coleção.findOne() retornará o primeiro documento que corresponde à query fornecida. Mesmo que mais de um documento corresponda à query, apenas um documento será retornado.
findOne() tem apenas um parâmetro necessário: uma query do tipo objeto. O objeto de query pode conter zero ou mais propriedades que o MongoDB usará para localizar um documento na coleção. Se quiser consultar todos os documentos de uma coleção sem restringir os resultados de forma alguma, basta enviar um objeto vazio.
Como queremos procurar um anúncio do Airbnb com um nome específico, incluiremos o campo de nome no objeto de query que passaremos para findOne():
1findOne({ name: nameOfListing })
Nossa função para encontrar uma listagem realizando a query do campo de nome pode ser assim:
1async function findOneListingByName(client, nameOfListing) {
2 const result = await client.db("sample_airbnb").collection("listingsAndReviews").findOne({ name: nameOfListing });
3
4 if (result) {
5 console.log(`Found a listing in the collection with the name '${nameOfListing}':`);
6 console.log(result);
7 } else {
8 console.log(`No listings found with the name '${nameOfListing}'`);
9 }
10}
Podemos chamar essa função passando um MongoClient conectado, bem como o nome de uma listagem que queremos encontrar. Vamos procurar uma listagem chamada "Infinite Views" que criamos em uma seção anterior.
1await findOneListingByName(client, "Infinite Views");
A saída deve ser algo como o seguinte.
1Found a listing in the collection with the name 'Infinite Views':
2{
3 _id: 5da9b5983e104518671ae128,
4 name: 'Infinite Views',
5 summary: 'Modern home with infinite views from the infinity pool',
6 property_type: 'House',
7 bedrooms: 5,
8 bathrooms: 4.5,
9 beds: 5
10}
Observe que o _id do documento no banco de dados não corresponde ao _id na saída de exemplo acima.
Se você não curte copiar e colar, pode obter uma cópia completa do código acima no repositório GitHub de início rápido do Node.js.

Leia vários documentos

Agora que você sabe como fazer query de um documento, vamos discutir como fazer query de vários documentos de uma só vez. Podemos fazer isso chamando o find() de Coleção.
Semelhante a findOne(), o primeiro parâmetro para find() é o objeto de query. Você pode incluir de zero a muitas propriedades no objeto de query.
Digamos que queremos pesquisar todos os anúncios do Airbnb que tenham um número mínimo de quartos e banheiros. Poderemos fazer isso fazendo uma chamada como a seguinte:
1const cursor = client.db("sample_airbnb").collection("listingsAndReviews").find(
2 {
3 bedrooms: { $gte: minimumNumberOfBedrooms },
4 bathrooms: { $gte: minimumNumberOfBathrooms }
5 }
6 );
Como você pode ver acima, temos duas propriedades em nosso objeto de query: uma para quartos e outra para banheiros. Podemos aproveitar o operador de query de comparação $gte para pesquisar documentos que tenham quartos maiores ou iguais a um determinado número. Podemos fazer o mesmo para satisfazer nosso requisito de número mínimo de banheiros. O MongoDB fornece uma variedade de outros operadores de query de comparação que você pode usar em suas queries. Consulte a documentação oficial para obter mais detalhes.
A query acima retornará um Cursor. Um Cursor permite percorrer o conjunto de resultados de uma query.
Você também pode usar as funções do cursor para modificar quais documentos são incluídos nos resultados. Por exemplo, digamos que queremos classificar nossos resultados para que aqueles com as avaliações mais recentes sejam retornados primeiro.Poderemos usar a funçãosort()do Cursor para classificar os resultados usando o campolast_review. Poderemos classificar os resultados em ordem decrescente (indicado ao passar -1 para sort()) para que os anúncios com as avaliações mais recentes sejam devolvidos primeiro. Agora podemos atualizar nossa query existente para ficar assim.
1const cursor = client.db("sample_airbnb").collection("listingsAndReviews").find(
2 {
3 bedrooms: { $gte: minimumNumberOfBedrooms },
4 bathrooms: { $gte: minimumNumberOfBathrooms }
5 }
6 ).sort({ last_review: -1 });
A query acima corresponde a 192 documentos em nossa coleção. Digamos que não queiramos processar tantos resultados dentro do nosso script. Em vez disso, queremos limitar nossos resultados a um número menor de documentos. Podemos encadear outra das funções sort() à nossa query existente: limit(). Como o nome indica, limit() definirá o limite para o cursor. Agora podemos atualizar nossa query para retornar apenas um determinado número de resultados.
1const cursor = client.db("sample_airbnb").collection("listingsAndReviews").find(
2 {
3 bedrooms: { $gte: minimumNumberOfBedrooms },
4 bathrooms: { $gte: minimumNumberOfBathrooms }
5 }
6 ).sort({ last_review: -1 })
7 .limit(maximumNumberOfResults);
Podemos optar por iterar sobre o cursor para obter os resultados um a um. Em vez disso, se quisermos recuperar todos os nossos resultados em uma array, podemos chamar a função toArray() do cursor. Agora, nosso código tem a seguinte aparência:
1const cursor = client.db("sample_airbnb").collection("listingsAndReviews").find(
2 {
3 bedrooms: { $gte: minimumNumberOfBedrooms },
4 bathrooms: { $gte: minimumNumberOfBathrooms }
5 }
6 ).sort({ last_review: -1 })
7 .limit(maximumNumberOfResults);
8const results = await cursor.toArray();
Agora que temos nossa query pronta, vamos colocá-la dentro de uma função assíncrona e adicionar funcionalidade para imprimir os resultados.
1async function findListingsWithMinimumBedroomsBathroomsAndMostRecentReviews(client, {
2 minimumNumberOfBedrooms = 0,
3 minimumNumberOfBathrooms = 0,
4 maximumNumberOfResults = Number.MAX_SAFE_INTEGER
5} = {}) {
6 const cursor = client.db("sample_airbnb").collection("listingsAndReviews")
7 .find({
8 bedrooms: { $gte: minimumNumberOfBedrooms },
9 bathrooms: { $gte: minimumNumberOfBathrooms }
10 }
11 )
12 .sort({ last_review: -1 })
13 .limit(maximumNumberOfResults);
14
15 const results = await cursor.toArray();
16
17 if (results.length > 0) {
18 console.log(`Found listing(s) with at least ${minimumNumberOfBedrooms} bedrooms and ${minimumNumberOfBathrooms} bathrooms:`);
19 results.forEach((result, i) => {
20 date = new Date(result.last_review).toDateString();
21
22 console.log();
23 console.log(`${i + 1}. name: ${result.name}`);
24 console.log(` _id: ${result._id}`);
25 console.log(` bedrooms: ${result.bedrooms}`);
26 console.log(` bathrooms: ${result.bathrooms}`);
27 console.log(` most recent review date: ${new Date(result.last_review).toDateString()}`);
28 });
29 } else {
30 console.log(`No listings found with at least ${minimumNumberOfBedrooms} bedrooms and ${minimumNumberOfBathrooms} bathrooms`);
31 }
32}
Podemos chamar essa função passando um MongoClient conectado, bem como um objeto com propriedades indicando o número mínimo de quartos, o número mínimo de banheiros e o número máximo de resultados.
1await findListingsWithMinimumBedroomsBathroomsAndMostRecentReviews(client, {
2 minimumNumberOfBedrooms: 4,
3 minimumNumberOfBathrooms: 2,
4 maximumNumberOfResults: 5
5});
Se você tiver criado os documentos conforme descrito na seção anterior, o resultado será algo assim:
1Found listing(s) with at least 4 bedrooms and 2 bathrooms:
2
31. name: Beautiful Beach House
4 _id: 5db6ed14f2e0a60683d8fe44
5 bedrooms: 4
6 bathrooms: 2.5
7 most recent review date: Mon Oct 28 2019
8
92. name: Spectacular Modern Uptown Duplex
10 _id: 582364
11 bedrooms: 4
12 bathrooms: 2.5
13 most recent review date: Wed Mar 06 2019
14
153. name: Grace 1 - Habitat Apartments
16 _id: 29407312
17 bedrooms: 4
18 bathrooms: 2.0
19 most recent review date: Tue Mar 05 2019
20
214. name: 6 bd country living near beach
22 _id: 2741869
23 bedrooms: 6
24 bathrooms: 3.0
25 most recent review date: Mon Mar 04 2019
26
275. name: Awesome 2-storey home Bronte Beach next to Bondi!
28 _id: 20206764
29 bedrooms: 4
30 bathrooms: 2.0
31 most recent review date: Sun Mar 03 2019
Se você não curte copiar e colar, pode obter uma cópia completa do código acima no repositório GitHub de início rápido do Node.js.

Atualização

Estamos na metade das operações CRUD. Agora que sabemos como criar e ler documentos, vamos descobrir como atualizá-los.

Atualizar um documento

Vamos começar atualizando um único anúncio do Airbnb na coleção listingsAndReviews .
Podemos atualizar um único documento chamando updateOne() de Coleção. updateOne() tem dois parâmetros obrigatórios:
  1. filter (objeto): o filtro usado para selecionar o documento a ser atualizado. Você pode pensar no filtro como essencialmente o mesmo que o parâmetro de query que usamos em findOne() para pesquisar um documento específico. Você pode incluir zero propriedades no filtro para pesquisar todos os documentos na coleção ou pode incluir uma ou mais propriedades para restringir sua pesquisa.
  2. update (objeto): as operações de atualização a serem aplicadas ao documento. O MongoDB tem uma variedade de operadores de atualização que você pode usar, como $inc, $currentDate, $set e $unset, entre outros. Consulte a documentação oficial para obter uma lista completa dos operadores de atualização e suas descrições.
updateOne() também tem um parâmetro options opcional. Consulte a documentação de updateOne() para obter mais informações sobre essas opções.
updateOne() atualizará o primeiro documento que corresponde à query fornecida. Mesmo que mais de um documento corresponda à query, somente um documento será atualizado.
Digamos que queremos atualizar um anúncio do Airbnb com um nome específico. Podemos usar updateOne() para isso. Incluiremos o nome do anúncio no parâmetro do filtro. Usaremos o operador de atualização $set para definir novos valores para campos novos ou existentes no documento que estamos atualizando. Quando usamos $set, passamos um documento que contém campos e valores que devem ser atualizados ou criados. O documento que passarmos para $set não substituirá o documento existente. Todos os campos que fazem parte do documento original, mas não fazem parte do documento que passamos para $set permanecerão como estão.
Nossa função para atualizar um anúncio com um nome específico seria semelhante à seguinte:
1async function updateListingByName(client, nameOfListing, updatedListing) {
2 const result = await client.db("sample_airbnb").collection("listingsAndReviews")
3 .updateOne({ name: nameOfListing }, { $set: updatedListing });
4
5 console.log(`${result.matchedCount} document(s) matched the query criteria.`);
6 console.log(`${result.modifiedCount} document(s) was/were updated.`);
7}
Digamos que queremos atualizar nosso anúncio do Airbnb que tem o nome de "Visualizações infinitas". Criamos esta listagem em uma seção anterior.
1{
2 _id: 5db6ed14f2e0a60683d8fe42,
3 name: 'Infinite Views',
4 summary: 'Modern home with infinite views from the infinity pool',
5 property_type: 'House',
6 bedrooms: 5,
7 bathrooms: 4.5,
8 beds: 5
9}
Podemos chamar updateListingByName() passando um MongoClient conectado, o nome do anúncio e um objeto contendo os campos que queremos atualizar e/ou criar.
1await updateListingByName(client, "Infinite Views", { bedrooms: 6, beds: 8 });
A execução deste comando resulta na seguinte saída.
11 document(s) matched the query criteria.
21 document(s) was/were updated.
Agora, nosso anúncio tem um número atualizado de quartos e camas.
1{
2 _id: 5db6ed14f2e0a60683d8fe42,
3 name: 'Infinite Views',
4 summary: 'Modern home with infinite views from the infinity pool',
5 property_type: 'House',
6 bedrooms: 6,
7 bathrooms: 4.5,
8 beds: 8
9}
Se você não curte copiar e colar, pode obter uma cópia completa do código acima no repositório GitHub de início rápido do Node.js.

Upsert um Documento

Uma das opções que você pode escolher para passar para updateOne() é upsert. O upsert é um recurso útil que permite atualizar um documento, se ele existir, ou inserir um documento, se ele não existir.
Por exemplo, digamos que você queira garantir que um anúncio do Airbnb com um nome específico tenha um determinado número de quartos e banheiros. Sem upsert, você primeiro usaria findOne() para verificar se o documento existe. Se o documento existisse, você usaria updateOne() para atualizá-lo. Se o documento não existisse, você usaria insertOne() para criar o documento. Ao usar upsert, você pode combinar toda essa funcionalidade em um único comando.
Nossa função para upsert um anúncio com um nome específico pode ser praticamente idêntica à função que escrevemos acima, com uma diferença fundamental: passaremos {upsert: true} no parâmetro options para updateOne().
1async function upsertListingByName(client, nameOfListing, updatedListing) {
2 const result = await client.db("sample_airbnb").collection("listingsAndReviews")
3 .updateOne({ name: nameOfListing },
4 { $set: updatedListing },
5 { upsert: true });
6 console.log(`${result.matchedCount} document(s) matched the query criteria.`);
7
8 if (result.upsertedCount > 0) {
9 console.log(`One document was inserted with the id ${result.upsertedId._id}`);
10 } else {
11 console.log(`${result.modifiedCount} document(s) was/were updated.`);
12 }
13}
Digamos que não temos certeza se um anúncio chamado "Cozy Cottage" está em nossa coleção ou, se existir, se contém dados antigos. De qualquer forma, queremos garantir que a listagem que existe em nossa coleção tenha os dados mais atualizados. Podemos chamar upsertListingByName() com um MongoClient conectado, o nome da listagem e um objeto contendo os dados atualizados que devem estar na listagem.
1await upsertListingByName(client, "Cozy Cottage", { name: "Cozy Cottage", bedrooms: 2, bathrooms: 1 });
Se o documento não existisse anteriormente, a saída da função seria algo como a seguinte:
10 document(s) matched the query criteria.
2One document was inserted with the id 5db9d9286c503eb624d036a1
Temos um novo documento na coleção listingsAndReviews:
1{
2 _id: 5db9d9286c503eb624d036a1,
3 name: 'Cozy Cottage',
4 bathrooms: 1,
5 bedrooms: 2
6}
Se descobrirmos mais informações sobre o anúncio "Chalé aconchegante", poderemos usar upsertListingByName() novamente.
1await upsertListingByName(client, "Cozy Cottage", { beds: 2 });
E veríamos o seguinte resultado.
11 document(s) matched the query criteria.
21 document(s) was/were updated.
Agora nosso documento tem um novo campo chamado "camas".
1{
2 _id: 5db9d9286c503eb624d036a1,
3 name: 'Cozy Cottage',
4 bathrooms: 1,
5 bedrooms: 2,
6 beds: 2
7}
Se você não curte copiar e colar, pode obter uma cópia completa do código acima no repositório GitHub de início rápido do Node.js.

Atualizar vários documentos

Às vezes, você deseja atualizar mais de um documento de cada vez. Nesse caso, você pode usar o updateMany() de Coleção. Como updateOne(), updateMany() exige que você passe um filtro do tipo de objeto e uma atualização do tipo de objeto. Você também pode optar por incluir opções do tipo de objeto.
Digamos que queremos garantir que cada documento tenha um campo chamado property_type. Podemos usar o operador property_typede query $exists para pesquisar documentos onde o campo não existe. Em seguida, podemos usar o operador de atualização $set para definir o property_type como "Desconhecido" para esses documentos. Nossa função será parecida com o seguinte.
1async function updateAllListingsToHavePropertyType(client) {
2 const result = await client.db("sample_airbnb").collection("listingsAndReviews")
3 .updateMany({ property_type: { $exists: false } },
4 { $set: { property_type: "Unknown" } });
5 console.log(`${result.matchedCount} document(s) matched the query criteria.`);
6 console.log(`${result.modifiedCount} document(s) was/were updated.`);
7}
Podemos chamar essa função com um MongoClient conectado.
1await updateAllListingsToHavePropertyType(client);
Abaixo está a saída da execução do comando anterior.
13 document(s) matched the query criteria.
23 document(s) was/were updated.
Agora, nosso documento "Chalé aconchegante" e todos os outros documentos da coleção do Airbnb têm o campo property_type.
1{
2 _id: 5db9d9286c503eb624d036a1,
3 name: 'Cozy Cottage',
4 bathrooms: 1,
5 bedrooms: 2,
6 beds: 2,
7 property_type: 'Unknown'
8}
Os anúncios que continham um property_type antes de chamarmos updateMany() permanecem como estavam. Por exemplo, o anúncio " Spectacular Modern Uptown Duplex " ainda tem property_type definido como Apartment.
1{
2 _id: '582364',
3 listing_url: 'https://www.airbnb.com/rooms/582364',
4 name: 'Spectacular Modern Uptown Duplex',
5 property_type: 'Apartment',
6 room_type: 'Entire home/apt',
7 bedrooms: 4,
8 beds: 7
9 ...
10}
Se você não curte copiar e colar, pode obter uma cópia completa do código acima no repositório GitHub de início rápido do Node.js.

Excluir

Agora que sabemos criar, ler e atualizar documentos, vamos enfrentar a operação CRUD final: excluir.

Excluir um documento

Vamos começar excluindo um único anúncio do Airbnb na coleção listingsAndReviews.
Podemos excluir um único documento chamando deleteOne() de Coleção. deleteOne() tem um parâmetro exigido: um filtro do tipo objeto. O filtro é usado para selecionar o documento a ser excluído. Você pode pensar no filtro como essencialmente o mesmo que o parâmetro de query que usamos em findOne() e o parâmetro de filtro que usamos em updateOne(). Você pode incluir zero propriedades no filtro para pesquisar todos os documentos na coleção ou pode incluir uma ou mais propriedades para restringir sua pesquisa.
deleteOne() também tem um parâmetro options opcional. Consulte os documentos deleteOne () para obter mais informações sobre essas opções.
deleteOne() excluirá o primeiro documento que corresponde à query fornecida. Mesmo que mais de um documento corresponda à query, apenas um será excluído. Se você não especificar um filtro, o primeiro documento encontrado em ordem natural será excluído.
Digamos que queremos excluir um anúncio do Airbnb com um nome específico. Podemos usar deleteOne() para isso. Incluiremos o nome do anúncio no parâmetro do filtro. Podemos criar uma função para excluir um anúncio com um nome específico.
1async function deleteListingByName(client, nameOfListing) {
2 const result = await client.db("sample_airbnb").collection("listingsAndReviews")
3 .deleteOne({ name: nameOfListing });
4 console.log(`${result.deletedCount} document(s) was/were deleted.`);
5}
Digamos que queremos excluir o anúncio do Airbnb que criamos em uma seção anterior que tem o nome "Chalé aconchegante". Podemos chamar deleteListingsByName() passando um MongoClient conectado e o nome "Chalé aconchegante".
1await deleteListingByName(client, "Cozy Cottage");
A execução do comando acima resulta na seguinte saída.
11 document(s) was/were deleted.
Se você não curte copiar e colar, pode obter uma cópia completa do código acima no repositório GitHub de início rápido do Node.js.

Excluir vários documentos

Às vezes, você quer excluir mais de um documento por vez. Nesse caso, você pode usar deleteMany() da coleção. Como deleteOne(), deleteMany() exige que você passe um filtro do tipo objeto. Você também pode optar por incluir opções do tipo de objeto.
Digamos que queremos remover documentos que não tenham sido atualizados recentemente. Podemos chamar deleteMany() com um filtro que pesquisar documentos que foram eliminados antes de uma determinada data. Nossa função será parecida com a seguinte.
1async function deleteListingsScrapedBeforeDate(client, date) {
2 const result = await client.db("sample_airbnb").collection("listingsAndReviews")
3 .deleteMany({ "last_scraped": { $lt: date } });
4 console.log(`${result.deletedCount} document(s) was/were deleted.`);
5}
Para excluir os anúncios que foram extraídos antes de 15 de fevereiro de 2019, podemos chamar deleteListingsScrapedBeforeDate() com um MongoClient conectado e uma instância de data que represente 15 fevereiro.
1await deleteListingsScrapedBeforeDate(client, new Date("2019-02-15"));
A execução do comando acima resultará na seguinte saída.
1606 document(s) was/were deleted.
Agora, apenas documentos recentemente extraídos estão em nossa coleção.
Se você não curte copiar e colar, pode obter uma cópia completa do código acima no repositório GitHub de início rápido do Node.js.

Encerrando

Cobrimos bastante conteúdo hoje! Vamos recapitular.
Começamos explorando como o MongoDB armazena dados em documentos e coleções. Em seguida, aprendemos o básico sobre criação, leitura, atualização e exclusão de dados.
Continue na próxima publicação desta série, onde discutiremos como você pode analisar e manipular dados usando o pipeline de agregação.
Comentários? Perguntas? Adoraríamos conversar com você na MongoDB Community.

Ícone do FacebookÍcone do Twitterícone do linkedin
Avalie esse Início rápido
star-empty
star-empty
star-empty
star-empty
star-empty
Relacionado
Tutorial

Introdução ao Deno 2.0 e MongoDB


Oct 22, 2024 | 13 min read
Tutorial

Simplificando o desenvolvimento nativo da nuvem com o Gitpod e o MongoDB Atlas


Apr 02, 2024 | 5 min read
Artigo

Usar o AWS Rekognition para analisar e marcar imagens carregadas


Sep 11, 2024 | 1 min read
Artigo

Projetar, desenvolver e analisar com o novo MongoDB Shell


Feb 03, 2023 | 4 min read
Sumário