As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# O que é um banco de dados de documentos?
Alguns desenvolvedores não pensam em seu modelo de dados em termos de linhas e colunas normalizadas. Normalmente, na camada da aplicação, os dados são representados como um documento JSON, pois é mais intuitivo para os desenvolvedores pensarem em seu modelo de dados como um documento.
A popularidade dos bancos de dados de documentos cresceu porque eles permitem que você mantenha a persistência dos dados em um banco de dados usando o mesmo formato de modelo de documento usado no código da aplicação. Os bancos de dados de documentos fornecem recursos poderosos e intuitivos APIs para um desenvolvimento flexível e ágil.
**Topics**
+ [Casos de uso](document-database-use-cases.md)
+ [Noções básicas sobre documentos](document-database-documents-understanding.md)
+ [Trabalhar com documentos](document-database-working-with-documents.md)
# Casos de uso do banco de dados de documentos
Seu caso de uso indica se você precisa de um banco de dados de documentos ou algum outro tipo de banco de dados para gerenciar os dados. Os bancos de dados de documentos são úteis para workloads que exigem um esquema flexível para desenvolvimento rápido e iterativo. A seguir estão alguns exemplos de casos de uso para os quais os bancos de dados de documentos podem fornecer vantagens significativas:
**Topics**
+ [Perfis de usuário](#document-databases-use-cases.user-profiles)
+ [Big data em tempo real](#document-databases-use-cases.big-data)
+ [Gerenciamento de conteúdo](#document-databases-use-cases.content-management)
## Perfis de usuário
Como os bancos de dados de documentos têm um esquema flexível, eles podem armazenar documentos com atributos e valores de dados diferentes. Os bancos de dados de documentos são uma solução prática para perfis online nos quais usuários diferentes fornecem tipos de informações diferentes. Usando um banco de dados de documentos, você pode armazenar o perfil de cada usuário de forma eficiente, armazenando apenas os atributos específicos de cada usuário.
Suponha que um usuário opte por adicionar ou remover informações do perfil. Nesse caso, o documento pode ser facilmente substituído por uma versão atualizada que contenha quaisquer atributos e dados adicionados recentemente ou que omita quaisquer atributos e dados omitidos recentemente. Os bancos de dados de documentos gerenciam facilmente esse nível de individualidade e fluidez.
## Big data em tempo real
Historicamente, a capacidade de extrair informações de dados operacionais era prejudicada pelo fato de bancos de dados operacionais e bancos de dados analíticos serem mantidos em ambientes diferentes — operacionais e, respectivamente. business/reporting A capacidade de extrair informações operacionais em tempo real é fundamental em um ambiente de negócios altamente competitivo. Ao usar bancos de dados de documentos, uma empresa pode armazenar e gerenciar dados operacionais de qualquer origem e, simultaneamente, alimentar os dados para o mecanismo de BI escolhido para análise. Não há necessidade de ter dois ambientes.
## Gerenciamento de conteúdo
Para gerenciar o conteúdo com eficiência, é necessário coletar e agregar o conteúdo de várias fontes e, em seguida, enviá-lo ao cliente. Devido ao esquema flexível, os bancos de dados de documentos são perfeitos para coletar e armazenar qualquer tipo de dados. É possível usá-los para criar e incorporar novos tipos de conteúdo, incluindo conteúdo gerado pelo usuário, como imagens, comentários e vídeos.
# Noções básicas sobre documentos
Os bancos de dados de documentos são usados para armazenar dados semiestruturados como um documento em vez de normalizar dados em várias tabelas, cada uma com uma estrutura única e fixa, como em um banco de dados relacional. Os documentos armazenados em um banco de dados de documentos usam pares de chave/valor aninhados para fornecer a estrutura ou o esquema do documento. No entanto, diferentes tipos de documentos podem ser armazenados no mesmo banco de dados de documentos, atendendo assim ao requisito de processamento de dados semelhantes em formatos diferentes. Por exemplo, como cada documento é autodescritivo, os documentos codificados em JSON de um armazenamento on-line descritos no tópico [Exemplo de documentos em um banco de dados de documentos](#document-database-documents) podem ser armazenados no mesmo banco de dados de documentos.
**Topics**
+ [Terminologia do SQL versus não relacional](#document-database-sql-vs-nosql-terms)
+ [Documentos simples](#document-database-documents-simple)
+ [Documentos incorporados](#document-database-documents-embeded)
+ [Exemplo de documentos em um banco de dados de documentos](#document-database-documents)
+ [Noções básicas sobre normalização em um banco de dados de documentos](#document-database-normalization)
## Terminologia do SQL versus não relacional
A tabela a seguir compara a terminologia usada pelos bancos de dados de documentos (MongoDB) com a terminologia usada pelos bancos de dados SQL.
| SQL | MongoDB |
| --- | --- |
| Tabela | Coleta |
| Linha | Documento |
| Coluna | Campo |
| Chave primária | ObjectId |
| Índice | Índice |
| Visualizar | Visualizar |
| Tabela ou objeto aninhado | Documento incorporado |
| Array | Array |
## Documentos simples
Todos os documentos em um banco de dados de documentos são autodescritivos. Esta documentação usa documentos formatados como JSON, embora você possa usar outros meios de codificação.
Um documento simples tem um ou mais campos que estão todos no mesmo nível no documento. No exemplo a seguir, os campos `SSN`, `LName`, `FName`, `DOB`, `Street`, `City`, `State-Province`, `PostalCode` e `Country` são todos irmãos no documento.
```
{
"SSN": "123-45-6789",
"LName": "Rivera",
"FName": "Martha",
"DOB": "1992-11-16",
"Street": "125 Main St.",
"City": "Anytown",
"State-Province": "WA",
"PostalCode": "98117",
"Country": "USA"
}
```
Quando as informações são organizadas em um documento simples, cada campo é gerenciado individualmente. Para recuperar o endereço de uma pessoa, é necessário recuperar `Street`, `City`, `State-Province`, `PostalCode` e `Country` como itens de dados individuais.
## Documentos incorporados
Um documento complexo organiza os dados criando documentos incorporados no documento. Documentos incorporados ajudam a gerenciar dados em agrupamentos e como itens de dados individuais, o que for mais eficiente em um determinado caso. Usando o exemplo anterior, você poderia incorporar um documento `Address` no documento principal. Isso resulta na estrutura do documento a seguir:
```
{
"SSN": "123-45-6789",
"LName": "Rivera",
"FName": "Martha",
"DOB": "1992-11-16",
"Address":
{
"Street": "125 Main St.",
"City": "Anytown",
"State-Province": "WA",
"PostalCode": "98117",
"Country": "USA"
}
}
```
Agora, você pode acessar os dados no documento como campos individuais (`"SSN":`), como um documento incorporado (`"Address":`) ou como membro de um documento incorporado (`"Address":{"Street":}`).
## Exemplo de documentos em um banco de dados de documentos
Como afirmado anteriormente, como cada documento em um banco de dados de documentos é autodescritivo, a estrutura dos documentos em um banco de dados de documentos pode ser diferente. Os dois documentos seguintes, um de um livro e o outro de um periódico, são estruturalmente diferentes. No entanto, ambos podem estar no mesmo banco de dados de documentos.
Veja a seguir um exemplo de documento de livro:
```
{
"_id" : "9876543210123",
"Type": "book",
"ISBN": "987-6-543-21012-3",
"Author":
{
"LName":"Roe",
"MI": "T",
"FName": "Richard"
},
"Title": "Understanding Document Databases"
}
```
Veja a seguir um exemplo de documento de periódico com dois artigos:
```
{
"_id" : "0123456789012",
"Publication": "Programming Today",
"Issue":
{
"Volume": "14",
"Number": "09"
},
"Articles" : [
{
"Title": "Is a Document Database Your Best Solution?",
"Author":
{
"LName": "Major",
"FName": "Mary"
}
},
{
"Title": "Databases for Online Solutions",
"Author":
{
"LName": "Stiles",
"FName": "John"
}
}
],
"Type": "periodical"
}
```
Compare a estrutura desses dois documentos. Com um banco de dados relacional, você precisa de tabelas de "periódico" e de "livros" separadas ou de uma única tabela com campos não utilizados, como "Publicação", "Problema", "Artigos" e "MI", como valores `null`. Como os bancos de dados de documentos são semiestruturados, com cada documento definindo a própria estrutura, esses dois documentos podem coexistir no mesmo banco de dados de documentos sem campos `null`. Bancos de dados de documentos são ideais para lidar com dados esparsos.
O desenvolvimento em um banco de dados de documentos permite um desenvolvimento rápido e interativo. Isso ocorre porque você pode alterar a estrutura de dados de um documento dinamicamente, sem precisar alterar o esquema para toda a coleção. Os bancos de dados de documentos são adequados para o desenvolvimento ágil e para ambientes que mudam dinamicamente.
## Noções básicas sobre normalização em um banco de dados de documentos
Bancos de dados de documentos não são normalizados; os dados encontrados em um documento podem ser repetidos em outro documento. Além disso, algumas discrepâncias de dados podem existir entre documentos. Por exemplo, considere o cenário em que você faz uma compra em um armazenamento on-line e todos os detalhes de suas compras são armazenados em um único documento. O documento pode ser semelhante ao documento JSON a seguir:
```
{
"DateTime": "2018-08-15T12:13:10Z",
"LName" : "Santos",
"FName" : "Paul",
"Cart" : [
{
"ItemId" : "9876543210123",
"Description" : "Understanding Document Databases",
"Price" : "29.95"
},
{
"ItemId" : "0123456789012",
"Description" : "Programming Today",
"Issue": {
"Volume": "14",
"Number": "09"
},
"Price" : "8.95"
},
{
"ItemId": "234567890-K",
"Description": "Gel Pen (black)",
"Price": "2.49"
}
],
"PaymentMethod" :
{
"Issuer" : "MasterCard",
"Number" : "1234-5678-9012-3456"
},
"ShopperId" : "1234567890"
}
```
Todas essas informações são armazenadas como um documento em uma coleção de transações. Mais tarde, você percebe que esqueceu de comprar um item. Então, você faz logon novamente na mesma loja e faz outra compra, que também é armazenada como outro documento na coleção de transações.
```
{
"DateTime": "2018-08-15T14:49:00Z",
"LName" : "Santos",
"FName" : "Paul",
"Cart" : [
{
"ItemId" : "2109876543210",
"Description" : "Document Databases for Fun and Profit",
"Price" : "45.95"
}
],
"PaymentMethod" :
{
"Issuer" : "Visa",
"Number" : "0987-6543-2109-8765"
},
"ShopperId" : "1234567890"
}
```
Observe a redundância entre esses dois documentos seu nome e ID de comprador (e, se você usou o mesmo cartão de crédito, suas informações de cartão de crédito). Mas não tem problema, porque o armazenamento é barato e cada documento registra completamente uma única transação que pode ser recuperada rapidamente com uma consulta simples de chave/valor que não requer junções.
Existe também uma aparente discrepância entre os dois documentos as informações do seu cartão de crédito. Essa é apenas uma discrepância aparente porque é provável que você tenha usado um cartão de crédito diferente para cada compra. Cada documento é preciso em relação à transação que ele documenta.
# Trabalhar com documentos
Como um banco de dados de documentos, o Amazon DocumentDB facilita o armazenamento, a consulta e a indexação de dados JSON. No Amazon DocumentDB, uma coleção de banco de dados de documentos é semelhante a uma tabela em um banco de dados relacional, exceto pelo fato de não haver um único esquema aplicado a todos os documentos. As coleções permitem agrupar documentos semelhantes, mantendo-os todos no mesmo banco de dados, sem exigir que eles tenham a estrutura idêntica.
Usando os exemplos de documentos das seções anteriores, é provável que você tenha coleções de `reading_material` e `office_supplies`. É função do software impor a que coleção um documento pertence.
Os exemplos a seguir usam a API do MongoDB para mostrar como adicionar, consultar, atualizar e excluir documentos.
**Topics**
+ [Adicionar documentos](#document-database-adding-documents)
+ [Consultar documentos](#document-database-queries)
+ [Como atualizar documentos](#document-database-updating)
+ [Como excluir documentos](#document-database-deleting)
## Adicionar documentos
No Amazon DocumentDB, um banco de dados é criado quando você adiciona um documento a uma coleção. Neste exemplo, você está criando uma coleção chamada `example` no banco de dados `test`, que é o banco de dados padrão quando ao conectar-se a um cluster. Como a coleção é criada implicitamente quando o primeiro documento é inserido, não há erro ao verificar o nome da coleção. Portanto, um erro de digitação no nome da coleção, como `eexample` em vez de `example`, criará e adicionará o documento à coleção `eexample` em vez de à coleção pretendida. A verificação de erros deve ser processada pela sua aplicação.
Os exemplos a seguir usam a API do MongoDB para adicionar documentos.
**Topics**
+ [Adicionar um único documento](#document-database-adding-documents-single)
+ [Adicionar diversos documentos](#document-database-adding-documents-multiple)
### Adicionar um único documento
Para adicionar um único documento a uma coleção, use a operação `insertOne( {} )` com o documento que você deseja adicionar à coleção.
```
db.example.insertOne(
{
"Item": "Ruler",
"Colors": ["Red","Green","Blue","Clear","Yellow"],
"Inventory": {
"OnHand": 47,
"MinOnHand": 40
},
"UnitPrice": 0.89
}
)
```
A saída dessa operação é semelhante ao seguinte (formato JSON).
```
{
"acknowledged" : true,
"insertedId" : ObjectId("5bedafbcf65ff161707de24f")
}
```
### Adicionar diversos documentos
Para adicionar diversos documentos a uma coleção, use a operação `insertMany( [{},...,{}] )` com uma lista dos documentos que você deseja adicionar à coleção. Embora os documentos nessa lista específica tenham esquemas diferentes, todos eles podem ser adicionados à mesma coleção.
```
db.example.insertMany(
[
{
"Item": "Pen",
"Colors": ["Red","Green","Blue","Black"],
"Inventory": {
"OnHand": 244,
"MinOnHand": 72
}
},
{
"Item": "Poster Paint",
"Colors": ["Red","Green","Blue","Black","White"],
"Inventory": {
"OnHand": 47,
"MinOnHand": 50
}
},
{
"Item": "Spray Paint",
"Colors": ["Black","Red","Green","Blue"],
"Inventory": {
"OnHand": 47,
"MinOnHand": 50,
"OrderQnty": 36
}
}
]
)
```
A saída dessa operação é semelhante ao seguinte (formato JSON).
```
{
"acknowledged" : true,
"insertedIds" : [
ObjectId("5bedb07941ca8d9198f5934c"),
ObjectId("5bedb07941ca8d9198f5934d"),
ObjectId("5bedb07941ca8d9198f5934e")
]
}
```
## Consultar documentos
Às vezes, pode ser necessário examinar o inventário da sua loja online para que os clientes possam visualizar e comprar o que você está vendendo. Consultar uma coleção é relativamente fácil, quer você queira todos os documentos na coleção ou apenas os documentos que satisfazem a um critério específico.
Para consultar documentos, use a operação `find()`. O comando `find()` tem um único parâmetro do documento que define os critérios a serem usados na escolha dos documentos a serem retornados. A saída de `find()` é um documento formatado como uma única linha de texto sem quebras de linha. Para formatar o documento de saída para facilitar a leitura, use `find().pretty()`. Todos os exemplos deste tópico usam `.pretty()` para formatar a saída.
Use os quatro documentos inseridos na coleção `example` nos últimos dois exercícios - `insertOne()` e `insertMany()`.
**Topics**
+ [Recuperar todos os documentos em uma coleção](#document-database-queries-all-documents)
+ [Recuperar documentos que correspondem a um valor de campo](#document-database-queries-match-criteria)
+ [Recuperar documentos que correspondem a um documento incorporado](#document-database-queries-entire-embedded-document)
+ [Recuperar documentos que correspondem a um valor de campo em um documento incorporado](#document-database-queries-embeded-document-field)
+ [Recuperar documentos que correspondem a uma matriz](#document-database-queries-array-match)
+ [Recuperar documentos que correspondem a um valor em uma matriz](#document-database-queries-array-value-match)
+ [Recuperar documentos usando operadores](#document-database-query-operators)
### Recuperar todos os documentos em uma coleção
Para recuperar todos os documentos em sua coleção, use a operação `find()` com um documento de consulta vazio.
A consulta a seguir retorna todos os documentos da coleção `example`.
```
db.example.find( {} ).pretty()
```
### Recuperar documentos que correspondem a um valor de campo
Para recuperar todos os documentos que correspondem a um campo e valor, use a operação `find()` com um documento de consulta que identifica os campos e valores a serem correspondidos.
Usando documentos anteriores, essa consulta retorna todos os documentos em que o campo "Item" será igual a "Pen".
```
db.example.find( { "Item": "Pen" } ).pretty()
```
### Recuperar documentos que correspondem a um documento incorporado
Para localizar todos os documentos que correspondem a um documento incorporado, use a operação `find()` com um documento de consulta que especifica o nome do documento incorporado e todos os campos e valores desse documento incorporado.
Ao vincular um documento incorporado, o documento incorporado do documento deve ter o mesmo nome que na consulta. Além disso, os campos e os valores no documento incorporado devem corresponder à consulta.
A consulta a seguir retorna apenas o documento "Poster Paint". Isso ocorre porque a "Caneta" tem valores diferentes para "`OnHand`" e "`MinOnHand`", e a "Tinta spray" tem um campo a mais (`OrderQnty`) que o documento de consulta.
```
db.example.find({"Inventory": {
"OnHand": 47,
"MinOnHand": 50 } } ).pretty()
```
### Recuperar documentos que correspondem a um valor de campo em um documento incorporado
Para localizar todos os documentos que correspondem a um documento incorporado, use a operação `find()` com um documento de consulta que especifica o nome do documento incorporado e todos os campos e valores desse documento incorporado.
Considerando os documentos anteriores, a consulta a seguir usa "notação de pontos" para especificar o documento incorporado e os campos de interesse. Qualquer documento que seja correspondente será retornado, independentemente de quais outros campos possam estar presentes no documento incorporado. A consulta retorna "Poster Paint" e "Spray Paint", pois ambos correspondem aos campos e valores especificados.
```
db.example.find({"Inventory.OnHand": 47, "Inventory.MinOnHand": 50 }).pretty()
```
### Recuperar documentos que correspondem a uma matriz
Para localizar todos os documentos que correspondem a uma matriz, use a operação `find()` com o nome da matriz de interesse e todos os valores na matriz. A consulta retorna todos os documentos que têm uma matriz com esse nome, com valores idênticos aos da matriz, e na mesma ordem que na consulta.
A consulta a seguir retorna apenas o documento "Pen", pois o "Poster Paint" tem uma cor adicional (White), e "Spray Paint" tem as cores em ordem diferente.
```
db.example.find( { "Colors": ["Red","Green","Blue","Black"] } ).pretty()
```
### Recuperar documentos que correspondem a um valor em uma matriz
Para localizar todos os documentos que possuem um valor de matriz específico, use a operação `find()` com o valor e o nome da matriz de interesse.
```
db.example.find( { "Colors": "Red" } ).pretty()
```
A operação anterior retorna todos os três documentos, pois cada um deles tem uma matriz chamada `Colors` e o valor `Red` em algum lugar da matriz. Se você especificar o valor "`White`", a consulta retornará apenas "Tinta de cartaz".
### Recuperar documentos usando operadores
A consulta a seguir retorna todos os documentos em que o valor "`Inventory.OnHand`" é inferior a 50.
```
db.example.find(
{ "Inventory.OnHand": { $lt: 50 } } )
```
Para obter uma lista de operadores de consulta compatíveis, consulte [Operadores de consulta e projeção](mongo-apis.md#mongo-apis-query).
## Como atualizar documentos
Normalmente, seus documentos não são estáticos e são atualizados como parte de seus fluxos de trabalho de aplicações. Os exemplos a seguir mostram algumas maneiras de como atualizar documentos.
Para atualizar um documento existente, use a operação `update()`. A operação `update()` tem dois parâmetros de documento. O primeiro documento identifica qual(is) documento(s) atualizar. O segundo documento especifica as atualizações a fazer.
Ao atualizar um campo existente - seja esse campo um campo simples, uma matriz ou um documento incorporado - você especifica o nome do campo e seus valores. No final da operação, é como se o campo no documento antigo tivesse sido substituído pelo novo campo e por novos valores.
**Topics**
+ [Atualizar os valores de um campo existente](#document-database-updating-existing-fields)
+ [Adição de um novo campo](#document-database-updating-adding-field)
+ [Substituir um documento incorporado](#document-database-replacing-embedded-document)
+ [Inserir novos campos em um documento incorporado](#document-database-updating-adding-field-embedded)
+ [Remover um campo de um documento](#document-database-remove-field)
+ [Remover um campo de vários documentos](#document-database-remove-field-all)
### Atualizar os valores de um campo existente
Use os quatro documentos a seguir, que você adicionou anteriormente, para as seguintes operações de atualização.
```
{
"Item": "Ruler",
"Colors": ["Red","Green","Blue","Clear","Yellow"],
"Inventory": {
"OnHand": 47,
"MinOnHand": 40
},
"UnitPrice": 0.89
},
{
"Item": "Pen",
"Colors": ["Red","Green","Blue","Black"],
"Inventory": {
"OnHand": 244,
"MinOnHand": 72
}
},
{
"Item": "Poster Paint",
"Colors": ["Red","Green","Blue","Black","White"],
"Inventory": {
"OnHand": 47,
"MinOnHand": 50
}
},
{
"Item": "Spray Paint",
"Colors": ["Black","Red","Green","Blue"],
"Inventory": {
"OnHand": 47,
"MinOnHand": 50,
"OrderQnty": 36
}
}
```
**Para atualizar um campo simples**
Para atualizar um campo simples, use `update()` com `$set` para especificar o nome e o novo valor do campo. O exemplo a seguir altera o `Item` de "Pen" para "Gel Pen".
```
db.example.update(
{ "Item" : "Pen" },
{ $set: { "Item": "Gel Pen" } }
)
```
Os resultados dessa operação são semelhantes ao seguinte.
```
{
"Item": "Gel Pen",
"Colors": ["Red","Green","Blue","Black"],
"Inventory": {
"OnHand": 244,
"MinOnHand": 72
}
}
```
**Para atualizar uma matriz**
O exemplo a seguir substitui a matriz de cores existente por uma nova matriz que inclui `Orange` e descarta `White` da lista de cores. A nova lista de cores está na ordem especificada na operação `update()`.
```
db.example.update(
{ "Item" : "Poster Paint" },
{ $set: { "Colors": ["Red","Green","Blue","Orange","Black"] } }
)
```
Os resultados dessa operação são semelhantes ao seguinte.
```
{
"Item": "Poster Paint",
"Colors": ["Red","Green","Blue","Orange","Black"],
"Inventory": {
"OnHand": 47,
"MinOnHand": 50
}
}
```
### Adição de um novo campo
Para modificar um documento adicionando um ou mais novos campos, use a operação `update()` com um documento de consulta que identifica o documento a ser inserido e os novos campos e valores a serem inseridos usando o operador `$set`.
O exemplo a seguir adiciona o campo `UnitPrice` com o valor `3.99` para o documento Spray Paints. Observe que o valor `3.99` é numérico, e não uma string.
```
db.example.update(
{ "Item": "Spray Paint" },
{ $set: { "UnitPrice": 3.99 } }
)
```
Os resultados dessa operação são semelhantes ao seguinte (formato JSON).
```
{
"Item": "Spray Paint",
"Colors": ["Black","Red","Green","Blue"],
"Inventory": {
"OnHand": 47,
"MinOnHand": 50,
"OrderQnty": 36
},
"UnitPrice": 3.99
}
```
### Substituir um documento incorporado
Para modificar um documento substituindo um documento incorporado, use a operação `update()` com documentos que identificam o documento incorporado e seus novos campos e valores com o uso do operador `$set`.
Considerando o seguinte documento.
```
db.example.insert({
"DocName": "Document 1",
"Date": {
"Year": 1987,
"Month": 4,
"Day": 18
}
})
```
**Substituir um documento incorporado**
O exemplo a seguir substitui o documento de data atual por um novo que tem somente os campos `Month` e `Day`. O campo `Year` foi eliminado.
```
db.example.update(
{ "DocName" : "Document 1" },
{ $set: { "Date": { "Month": 4, "Day": 18 } } }
)
```
Os resultados dessa operação são semelhantes ao seguinte.
```
{
"DocName": "Document 1",
"Date": {
"Month": 4,
"Day": 18
}
}
```
### Inserir novos campos em um documento incorporado
**Como adicionar campos a um documento incorporado**
Para modificar um documento adicionando um ou mais novos campos a um documento incorporado, use a operação `update()` com documentos que identificam o documento incorporado e "notação de pontos" para especificar o documento incorporado e os novos campos e valores a serem inseridos usando o operador `$set`.
Considerando o documento a seguir, o código usa a "notação de pontos" para inserir os campos `Year` e `DoW` no documento `Date` incorporado, e `Words` no documento pai.
```
{
"DocName": "Document 1",
"Date": {
"Month": 4,
"Day": 18
}
}
```
```
db.example.update(
{ "DocName" : "Document 1" },
{ $set: { "Date.Year": 1987,
"Date.DoW": "Saturday",
"Words": 2482 } }
)
```
Os resultados dessa operação são semelhantes ao seguinte.
```
{
"DocName": "Document 1",
"Date": {
"Month": 4,
"Day": 18,
"Year": 1987,
"DoW": "Saturday"
},
"Words": 2482
}
```
### Remover um campo de um documento
Para modificar um documento removendo um campo do documento, use a operação `update()` com um documento de consulta que identifica o campo a ser removido do documento e o operador `$unset` para especificar o campo a ser removido.
O exemplo a seguir remove o campo `Words` do documento anterior.
```
db.example.update(
{ "DocName" : "Document 1" },
{ $unset: { Words:1 } }
)
```
Os resultados dessa operação são semelhantes ao seguinte.
```
{
"DocName": "Document 1",
"Date": {
"Month": 4,
"Day": 18,
"Year": 1987,
"DoW": "Saturday"
}
}
```
### Remover um campo de vários documentos
Para modificar um documento removendo um campo de vários documentos, use a operação `update()` com o operador `$unset` e a opção `multi` definida como `true`.
O exemplo a seguir remove o campo `Inventory` de todos os documentos na coleção de exemplo. Se um documento não tiver o campo `Inventory`, nenhuma ação será executada nesse documento. Se `multi: true` for omitido, a ação será executada apenas no primeiro documento que atenda ao critério.
```
db.example.update(
{},
{ $unset: { Inventory:1 } },
{ multi: true }
)
```
## Como excluir documentos
Para remover um documento do banco de dados, use a operação `remove()`, especificando qual documento remover. O código a seguir remove "Gel Pen" da sua coleção `example`.
```
db.example.remove( { "Item": "Gel Pen" } )
```
Para remover todos os documentos do seu banco de dados, use a operação `remove()` com uma consulta vazia.
```
db.example.remove( { } )
```