MongoDB e Node.js 3.3.2 Tutorial - Operações CRUD
Avalie esse Início rápido
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).
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:
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)
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.
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.
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!
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:
1 async 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.
1 await 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:
1 New 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.
À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.
1 async 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.
1 await 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:1 3 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.
Agora que sabemos como criar documentos, vamos ler um!
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()
:1 findOne({ name: nameOfListing })
Nossa função para encontrar uma listagem realizando a query do campo de nome pode ser assim:
1 async 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.
1 await findOneListingByName(client, "Infinite Views");
A saída deve ser algo como o seguinte.
1 Found 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.
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:
1 const 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 campo
last_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.1 const 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.1 const 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:
1 const 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); 8 const 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.
1 async 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.
1 await 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:
1 Found listing(s) with at least 4 bedrooms and 2 bathrooms: 2 3 1. name: Beautiful Beach House 4 _id: 5db6ed14f2e0a60683d8fe44 5 bedrooms: 4 6 bathrooms: 2.5 7 most recent review date: Mon Oct 28 2019 8 9 2. 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 15 3. 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 21 4. 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 27 5. 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.
Estamos na metade das operações CRUD. Agora que sabemos como criar e ler documentos, vamos descobrir como atualizá-los.
Podemos atualizar um único documento chamando updateOne() de Coleção.
updateOne()
tem dois parâmetros obrigatórios: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.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:
1 async 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.1 await updateListingByName(client, "Infinite Views", { bedrooms: 6, beds: 8 });
A execução deste comando resulta na seguinte saída.
1 1 document(s) matched the query criteria. 2 1 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.
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()
.1 async 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.1 await 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:
1 0 document(s) matched the query criteria. 2 One 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.1 await upsertListingByName(client, "Cozy Cottage", { beds: 2 });
E veríamos o seguinte resultado.
1 1 document(s) matched the query criteria. 2 1 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.
À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_type
de 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.1 async 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.
1 await updateAllListingsToHavePropertyType(client);
Abaixo está a saída da execução do comando anterior.
1 3 document(s) matched the query criteria. 2 3 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.
Agora que sabemos criar, ler e atualizar documentos, vamos enfrentar a operação CRUD final: excluir.
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.1 async 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".1 await deleteListingByName(client, "Cozy Cottage");
A execução do comando acima resulta na seguinte saída.
1 1 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.
À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.1 async 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.1 await deleteListingsScrapedBeforeDate(client, new Date("2019-02-15"));
A execução do comando acima resultará na seguinte saída.
1 606 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.
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.