MongoDB
 sql >> Base de Dados >  >> NoSQL >> MongoDB

Como gerenciar documentos no MongoDB


Introdução


Ao usar o MongoDB, você passará a maior parte do tempo gerenciando documentos de uma forma ou de outra. Esteja você criando novos documentos e adicionando-os a coleções, recuperando documentos, atualizando dados ou eliminando itens obsoletos, os documentos estão no centro do modelo MongoDB.

Neste guia, abordaremos o que são documentos do MongoDB e, em seguida, abordaremos as operações comuns que você provavelmente precisará conhecer para gerenciar um ambiente centrado em documentos.


O que são documentos do MongoDB?


No MongoDB, todos os dados em bancos de dados e coleções são armazenados em documentos. Como as coleções não especificam um esquema obrigatório por padrão, os documentos em uma coleção podem conter uma estrutura arbitrariamente complexa e não precisam corresponder ao formato usado pelos documentos irmãos. Isso fornece flexibilidade incrível e permite que o esquema se desenvolva organicamente à medida que os requisitos do aplicativo mudam.

Os próprios documentos do MongoDB usam o formato de serialização de dados BSON, uma representação binária da Notação de Objeto JavaScript JSON. Isso fornece uma estrutura organizada com tipos de dados definidos que podem ser consultados e operados programaticamente.

Os documentos BSON são representados por um par de chaves ({} ) que contêm pares de valores-chave. Em BSON, esses dísticos de dados são conhecidos como campo e seu valor . O campo vem primeiro e é representado por uma string. O valor pode ser qualquer tipo de dados BSON válido. Dois pontos (: ) separa o campo de seu valor. Uma vírgula é usada para separar cada campo e par de valor um do outro.

Como exemplo, aqui está um documento BSON válido que o MongoDB pode entender:
{    _id: 80380,    vehicle_type: "car",    mileage: 7377.80,    color: "blue",    markets: [        "US",        "UK"    ],    options: {        transmission: "automatic",        num_doors: 4,        power_windows: true    }}

Aqui, podemos ver alguns tipos:
  • _id é um número inteiro
  • vehicle_type e color são strings
  • mileage é um flutuador
  • markets é um array de strings
  • options contém um documento aninhado com valores que consistem em uma string, um inteiro e um booleano

Devido a essa flexibilidade, os documentos são um meio bastante flexível para armazenar dados. Novos campos podem ser adicionados facilmente, documentos podem ser incorporados uns aos outros e a complexidade estrutural corresponde exatamente aos dados armazenados.


Como criar novos documentos


Para criar um novo documento, mude para um banco de dados onde deseja armazenar o documento criado. Usaremos uma school banco de dados para fins de demonstração neste artigo:
use school

Você também desejará escolher a coleção onde deseja inserir os documentos. Assim como nos bancos de dados, você não precisa criar explicitamente a coleção na qual deseja inserir o documento. O MongoDB o criará automaticamente quando os primeiros dados forem gravados. Para este exemplo, usaremos uma coleção chamada students .

Agora que você sabe onde o documento será armazenado, você pode inserir um novo documento usando um dos seguintes métodos.

Usando o insert() método


O insert() O método permite que você insira um ou mais documentos na coleção em que é chamado.

Para inserir um único documento, passe o documento para o método chamando-o na coleção. Aqui, inserimos um novo documento para um aluno chamado Ashley:
db.students.insert(    {        first_name: "Ashley",        last_name: "Jenkins",        dob: new Date("January 08, 2003"),        grade_level: 8    })
 
WriteResult({ "nInserted" : 1 })

Se você deseja inserir mais de um documento ao mesmo tempo, em vez de passar um documento para insert() , passe uma matriz de documentos. Podemos adicionar dois novos documentos para alunos chamados Brian e Leah:
db.students.insert(    [        {            first_name: "Brian",            last_name: "McMantis",            dob: new Date("September 18, 2010"),            grade_level: 2        },        {            first_name: "Leah",            last_name: "Drake",            dob: new Date("October 03, 2009")        }    ])
 
BulkWriteResult({        "writeErrors" : [ ],        "writeConcernErrors" : [ ],        "nInserted" : 2,        "nUpserted" : 0,        "nMatched" : 0,        "nModified" : 0,        "nRemoved" : 0,        "upserted" : [ ]})

Como realizamos uma operação de gravação em massa, nosso valor de retorno é um BulkWriteResult em vez do WriteResult objeto que vimos antes.

Enquanto o insert() for flexível, foi preterido em muitos drivers do MongoDB em favor dos dois métodos a seguir.


Usando o insertOne() método


O insertOne() pode ser usado para inserir um único documento. Ao contrário do insert() método, ele só pode inserir um documento por vez, o que torna seu comportamento um pouco mais previsível.

A sintaxe é a mesma de quando você usa insert() para adicionar um único documento. Podemos adicionar outra aluna chamada Naomi:
db.students.insertOne(    {        first_name: "Naomi",        last_name: "Pyani"    })
 
{        "acknowledged" : true,        "insertedId" : ObjectId("60e877914655cbf49ff7cb86")}

Ao contrário de insert() , o insertOne() retorna um documento contendo algumas informações úteis adicionais. Ele confirma que a gravação foi reconhecida pelo cluster e inclui o ID do objeto que foi atribuído ao documento, pois não fornecemos um.


Usando o insertMany() método


Para cobrir cenários em que você deseja inserir vários documentos de uma só vez, o insertMany() método agora é recomendado. Assim como ao inserir vários documentos com insert() , insertMany() leva uma matriz de documentos.

Podemos adicionar três novos alunos chamados Jasmine, Michael e Toni:
db.students.insertMany(    [        {            first_name: "Jasmine",            last_name: "Took",            dob: new Date("April 11, 2011")        },        {            first_name: "Michael",            last_name: "Rodgers",            dob: new Date("February 25, 2008"),            grade_level: 6        },        {            first_name: "Toni",            last_name: "Fowler"        }    ])
 
{        "acknowledged" : true,        "insertedIds" : [                ObjectId("60e8792d4655cbf49ff7cb87"),                ObjectId("60e8792d4655cbf49ff7cb88"),                ObjectId("60e8792d4655cbf49ff7cb89")        ]}

Como com insertOne() , insertMany() retorna um documento que reconhece a gravação e fornece um array contendo os IDs que foram atribuídos aos documentos inseridos.



Como consultar documentos existentes


A consulta de documentos é um tópico bastante extenso que merece seu próprio artigo. Você pode encontrar detalhes sobre como formular consultas para recuperar diferentes tipos de documentos em nosso guia sobre como consultar dados no MongoDB.

Embora os detalhes sejam deixados no artigo vinculado acima, podemos pelo menos cobrir os métodos que o MongoDB fornece para consultar documentos. A principal maneira de buscar documentos do MongoDB é chamando o método find() método na coleção em questão.

Por exemplo, para coletar todos os documentos dos students , você pode chamar find() sem argumentos:
db.students.find()
 
{ "_id" : ObjectId("60e8743b4655cbf49ff7cb83"), "first_name" : "Ashley", "last_name" : "Jenkins", "dob" : ISODate("2003-01-08T00:00:00Z"), "grade_level" : 8 }{ "_id" : ObjectId("60e875d54655cbf49ff7cb84"), "first_name" : "Brian", "last_name" : "McMantis", "dob" : ISODate("2010-09-18T00:00:00Z"), "grade_level" : 2 }{ "_id" : ObjectId("60e875d54655cbf49ff7cb85"), "first_name" : "Leah", "last_name" : "Drake", "dob" : ISODate("2009-10-03T00:00:00Z") }{ "_id" : ObjectId("60e877914655cbf49ff7cb86"), "first_name" : "Naomi", "last_name" : "Pyani" }{ "_id" : ObjectId("60e8792d4655cbf49ff7cb87"), "first_name" : "Jasmine", "last_name" : "Took", "dob" : ISODate("2011-04-11T00:00:00Z") }{ "_id" : ObjectId("60e8792d4655cbf49ff7cb88"), "first_name" : "Michael", "last_name" : "Rodgers", "dob" : ISODate("2008-02-25T00:00:00Z"), "grade_level" : 6 }{ "_id" : ObjectId("60e8792d4655cbf49ff7cb89"), "first_name" : "Toni", "last_name" : "Fowler" }

Para tornar a saída mais legível, você também pode encadear o pretty() método após find() :
db.<collection>.find().pretty()
 
{        "_id" : ObjectId("60e8743b4655cbf49ff7cb83"),        "first_name" : "Ashley",        "last_name" : "Jenkins",        "dob" : ISODate("2003-01-08T00:00:00Z"),        "grade_level" : 8}{        "_id" : ObjectId("60e875d54655cbf49ff7cb84"),        "first_name" : "Brian",        "last_name" : "McMantis",        "dob" : ISODate("2010-09-18T00:00:00Z"),        "grade_level" : 2}{        "_id" : ObjectId("60e875d54655cbf49ff7cb85"),        "first_name" : "Leah",        "last_name" : "Drake",        "dob" : ISODate("2009-10-03T00:00:00Z")}{        "_id" : ObjectId("60e877914655cbf49ff7cb86"),        "first_name" : "Naomi",        "last_name" : "Pyani"}{        "_id" : ObjectId("60e8792d4655cbf49ff7cb87"),        "first_name" : "Jasmine",        "last_name" : "Took",        "dob" : ISODate("2011-04-11T00:00:00Z")}{        "_id" : ObjectId("60e8792d4655cbf49ff7cb88"),        "first_name" : "Michael",        "last_name" : "Rodgers",        "dob" : ISODate("2008-02-25T00:00:00Z"),       "grade_level" : 6}{        "_id" : ObjectId("60e8792d4655cbf49ff7cb89"),        "first_name" : "Toni",        "last_name" : "Fowler"}

Você pode ver que um _id campo foi adicionado a cada um dos documentos. O MongoDB requer um _id exclusivo para cada documento em uma coleção. Se você não fornecer um na criação do objeto, ele adicionará um para você. Você pode usar esse ID para recuperar um único objeto de forma confiável:
db.students.find(    {        _id : ObjectId("60e8792d4655cbf49ff7cb89")    })
 
{ "_id" : ObjectId("60e8792d4655cbf49ff7cb89"), "first_name" : "Toni", "last_name" : "Fowler" }

Você pode descobrir mais sobre várias maneiras de consultar dados com o artigo vinculado acima.


Como atualizar documentos existentes


Muitos ou a maioria dos casos de uso de bancos de dados exigem que você modifique os dados existentes no banco de dados. Um campo pode precisar ser atualizado para refletir um novo valor ou pode ser necessário anexar informações adicionais a um documento existente à medida que ele se torna disponível.

O MongoDB usa alguns métodos relacionados para atualizar documentos existentes:
  • updateOne() :atualiza um único documento em uma coleção com base no filtro fornecido.
  • updateMany() :atualiza vários documentos em uma coleção que correspondem ao filtro fornecido.
  • replaceOne() :substitui um documento inteiro em uma coleção com base no filtro fornecido.

Abordaremos como usar cada uma dessas variedades para realizar diferentes tipos de atualizações.

Atualizar operadores


Antes de dar uma olhada em cada um dos métodos para atualizar documentos, devemos examinar alguns dos operadores de atualização disponíveis.
  • $currentDate :define o valor de um campo para a data atual, seja como data ou tipo de carimbo de data/hora.
    • Sintaxe:{ $currentDate: { <field>: <type>, ... } }
  • $inc :incrementa o valor de um campo por um valor definido.
    • Sintaxe:{ $inc: { <field>: <amount>, ... } }
  • $min :atualiza o valor de um campo se o valor especificado for menor que o valor atual.
    • Sintaxe:{ $min: { <field>: <value>, ... } }
  • $max :atualiza o valor de um campo se o valor especificado for maior que o valor atual.
    • Sintaxe:{ $max: { <field>: <value>, ... } }
  • $mul :atualiza o valor de um campo multiplicando-o pelo número fornecido.
    • Sintaxe:{ $mul: { <field>: <value>, ... } }
  • $rename :renomeia um nome de campo para um novo identificador.
    • Sintaxe:{ $rename: { <field>: <new_name>, ... } }
  • $set :Substitui o valor de um campo pelo valor fornecido.
    • Sintaxe:{ $set: { <field>: value, ... } }
  • $setOnInsert :Durante as operações de upsert, define o valor de um campo se um novo documento está sendo criado e não faz nada de outra forma.
    • Sintaxe:{ $setOnInsert: { <field>: <value>, ... } }
  • $unset :Remove um campo do documento.
    • Sintaxe:{ $unset: { <field>: "", ... } }
  • $ :um espaço reservado para o primeiro elemento da matriz que satisfaz a consulta.
    • Sintaxe:{ <update_operator>: {<array>.$: <value> } }
  • $[] :um espaço reservado para todos os elementos da matriz que satisfazem a consulta.
    • Sintaxe:{ <update_operator>: { <array>.$[]: <value> } }
  • $addToSet :Adiciona valores ao array a menos que eles já estejam presentes.
    • Sintaxe:{ $addToSet: { <field>: <value>, ... } }
  • $pop :remove o primeiro ou o último elemento de um array.
    • Sintaxe:{ $pop: { <field>: (-1 or 1), ... } }
  • $pull :remove todos os elementos de uma matriz que correspondem a uma condição.
    • Sintaxe:{ $pull: { <field>: <condition>, ... } }
  • $push :Acrescenta um valor a uma matriz.
    • Sintaxe:{ $push: { <field>: <value>, ... } }
  • $pullAll :remove todos os elementos especificados de um array.
    • Sintaxe:{ $pullAll: { <field>: [ <value>, ... ], ...} }
  • $each :Modifica $addToSet e $push operadores para que eles adicionem cada elemento de um array em vez de um array como um único elemento.
    • Sintaxe:{ <update_operator>: { <field>: { $each: [ <value>, ... ] }, ... } }
  • $position :Usado com $each e especifica a posição do $push operador deve inserir at.
    • Sintaxe:{ $push: { <field>: { $each: [ <value>, ... ], $position: <num> } } }
  • $slice :Usado com $each e $push para limitar o número total de elementos no array.
    • Sintaxe:{ $push: { <field>: { $each: [ <value>, ... ], $slice: <num> } } }
  • $sort :Usado com $each e $push para ordenar os elementos do array.
    • Sintaxe:{ $push: { <field>: { $each: [ <value>, ... ], $sort: <sort_order> } } }

Esses vários operadores de atualização permitem atualizar vários campos de seus documentos de diferentes maneiras.


Atualizando um único documento em uma coleção


updateOne() do MongoDB é usado para atualizar um único documento dentro de uma coleção. O método recebe dois argumentos obrigatórios, bem como um documento especificando argumentos opcionais.

O primeiro argumento é um documento que especifica as condições de filtro que serão usadas para selecionar documentos. Desde o updateOne() modificar no máximo um documento em uma coleção, será usado o primeiro documento que satisfizer as condições do filtro.

O segundo argumento especifica a operação de atualização que deve ser executada. As operações de atualização fornecidas acima podem ser especificadas aqui para alterar o conteúdo do documento correspondente.

O terceiro argumento é um documento de várias opções para modificar o comportamento do método. Os valores potenciais mais importantes são:
  • upsert :transforma a operação em um procedimento upsert inserindo um novo documento se o filtro não corresponder a nenhum documento existente.
  • collation :um documento que define regras específicas do idioma que devem ser aplicadas à operação.

Como exemplo, podemos atualizar um único registro de aluno que filtramos pelo _id campo para garantir que segmentamos o documento correto. Podemos definir o grade_level para um novo valor:
db.students.updateOne(    { _id: ObjectId("60e8792d4655cbf49ff7cb89") },    { $set: { grade_level: 3 } })
 
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }


Atualizando vários documentos em uma coleção


updateMany() do MongoDB O método funciona de forma semelhante ao updateOne() mas atualiza qualquer documento que corresponda ao filtro fornecido em vez de parar após a primeira correspondência.

O updateMany() sintaxe segue exatamente o updateOne() sintaxe, então a única diferença é o escopo da operação.

Por exemplo, se quisermos alterar todas as instâncias de "composition" para "writing" nos subjects array em nossos teachers documentos de coleção, poderíamos usar algo assim:
db.teachers.updateMany(    { subject: "composition" },    { $set: { "subjects.$": "writing" } })
 
{ "acknowledged" : true, "matchedCount" : 3, "modifiedCount" : 3 }

Se você verificar os documentos, cada instância de "composição" deve ter sido substituída por "escrita":
db.teachers.find()
 
{ "_id" : ObjectId("60eddca65eb74f5c676f3baa"), "first_name" : "Nancy", "last_name" : "Smith", "subjects" : [ "vocabulary", "pronunciation" ] }{ "_id" : ObjectId("60eddca65eb74f5c676f3bab"), "first_name" : "Ronald", "last_name" : "Taft", "subjects" : [ "literature", "grammar", "writing" ] }{ "_id" : ObjectId("60eddca65eb74f5c676f3bac"), "first_name" : "Casey", "last_name" : "Meyers", "subjects" : [ "literature", "writing", "grammar" ] }{ "_id" : ObjectId("60eddca65eb74f5c676f3bad"), "first_name" : "Rebecca", "last_name" : "Carrie", "subjects" : [ "grammar", "literature" ] }{ "_id" : ObjectId("60eddca65eb74f5c676f3bae"), "first_name" : "Sophie", "last_name" : "Daggs", "subjects" : [ "literature", "writing", "grammar", "vocabulary", "pronunciation" ] }


Substituindo um documento


O replaceOne() O método funciona de forma semelhante ao updateOne() mas substitui todo o documento em vez de atualizar campos individuais. A sintaxe é a mesma dos dois comandos anteriores.

Por exemplo, se Nancy Smith deixar sua escola e você a substituir por uma professora chamada Clara Newman que ensina literatura, você pode digitar o seguinte:
db.teachers.replaceOne(    {        $and: [             { first_name: "Nancy" },            { last_name: "Smith" }        ]    },    {        first_name: "Clara",        last_name: "Newman",        subjects: [ "literature" ]    })
 
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }

Você pode ver que o documento correspondente foi removido e que o documento especificado o substituiu:
db.teachers.find()
 
{ "_id" : ObjectId("60eddca65eb74f5c676f3baa"), "first_name" : "Clara", "last_name" : "Newman", "subjects" : [ "literature" ] }{ "_id" : ObjectId("60eddca65eb74f5c676f3bab"), "first_name" : "Ronald", "last_name" : "Taft", "subjects" : [ "literature", "grammar", "writing" ] }{ "_id" : ObjectId("60eddca65eb74f5c676f3bac"), "first_name" : "Casey", "last_name" : "Meyers", "subjects" : [ "literature", "writing", "grammar" ] }{ "_id" : ObjectId("60eddca65eb74f5c676f3bad"), "first_name" : "Rebecca", "last_name" : "Carrie", "subjects" : [ "grammar", "literature" ] }{ "_id" : ObjectId("60eddca65eb74f5c676f3bae"), "first_name" : "Sophie", "last_name" : "Daggs", "subjects" : [ "literature", "writing", "grammar", "vocabulary", "pronunciation" ] }



Como excluir documentos


A remoção de documentos das coleções também faz parte do ciclo de vida do documento. Para remover um documento, você pode usar o deleteOne() ou deleteMany() métodos. Eles têm a mesma sintaxe e diferem apenas em quantos documentos operam.

Na maioria das vezes, tudo o que você precisa fazer para excluir documentos com qualquer um desses métodos é fornecer um documento de filtro que especifica como você deseja selecionar o documento a ser excluído. O deleteOne() O método excluirá no máximo um documento (independentemente de quantas correspondências o filtro produz) enquanto o deleteMany() O método exclui todos os documentos que correspondem às condições do filtro.

Por exemplo, para excluir um único aluno, você pode fornecer um _id para combiná-los explicitamente:
db.students.deleteOne({    _id: ObjectId("60e8792d4655cbf49ff7cb87")})
 
{ "acknowledged" : true, "deletedCount" : 1 }

Se quisermos excluir algum aluno que não tenha uma série atribuída, podemos usar o deleteMany() método em vez disso:
db.students.deleteMany({    grade_level: { $eq: null }})
 
{ "acknowledged" : true, "deletedCount" : 2 }

Se verificarmos, veremos que todos os alunos restantes têm uma série atribuída:
db.students.find()
 
{ "_id" : ObjectId("60e8743b4655cbf49ff7cb83"), "first_name" : "Ashley", "last_name" : "Jenkins", "dob" : ISODate("2003-01-08T00:00:00Z"), "grade_level" : 8 }{ "_id" : ObjectId("60e875d54655cbf49ff7cb84"), "first_name" : "Brian", "last_name" : "McMantis", "dob" : ISODate("2010-09-18T00:00:00Z"), "grade_level" : 2 }{ "_id" : ObjectId("60e8792d4655cbf49ff7cb88"), "first_name" : "Michael", "last_name" : "Rodgers", "dob" : ISODate("2008-02-25T00:00:00Z"), "grade_level" : 6 }{ "_id" : ObjectId("60e8792d4655cbf49ff7cb89"), "first_name" : "Toni", "last_name" : "Fowler", "grade_level" : 3 }


Conclusão


Aprender a criar, consultar, atualizar e remover documentos fornece as habilidades necessárias para gerenciar documentos com eficiência no MongoDB diariamente. Familiarizar-se com os vários métodos de documentos e coleta e os operadores que permitem combinar e modificar informações permite expressar pensamentos complexos que o sistema de banco de dados pode entender.