Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Cos'è un database di documenti?
Alcuni sviluppatori non pensano al proprio modello di dati in termini di righe e colonne normalizzate. Tipicamente, nel livello dell'applicazione, i dati sono rappresentati come un documento JSON perché è più intuitivo per gli sviluppatori pensare al proprio modello di dati come a un documento.
La popolarità dei database di documenti è aumentata perché consentono di rendere permanenti i dati in un database utilizzando lo stesso formato del modello di documento utilizzato nel codice dell'applicazione. I database di documenti offrono funzionalità potenti e intuitive APIs per uno sviluppo flessibile e agile.
**Topics**
+ [Casi d’uso](document-database-use-cases.md)
+ [Comprendere i documenti](document-database-documents-understanding.md)
+ [Utilizzo dei documenti](document-database-working-with-documents.md)
# Casi di utilizzo dei database di documenti
Il tuo caso d'uso riguarda situazioni in cui hai bisogno di un database di documenti o di altri tipi di database per gestire i dati. I database di documenti sono utili per i carichi di lavoro che richiedono uno schema flessibile per uno sviluppo rapido e iterativo. Di seguito sono elencati alcuni esempi di casi d'uso per i quali i database di documenti possono offrire notevoli vantaggi:
**Topics**
+ [Profili utente](#document-databases-use-cases.user-profiles)
+ [Big data in tempo reale](#document-databases-use-cases.big-data)
+ [Gestione dei contenuti](#document-databases-use-cases.content-management)
## Profili utente
Poiché i database di documenti si basano su uno schema flessibile, possono archiviare documenti con diversi attributi e valori dei dati. I database di documenti rappresentano sono una soluzione pratica per i profili online in cui più utenti forniscono tipi di informazioni diversi. Con un database di documenti puoi archiviare ogni profilo utente in modo efficiente archiviando solo gli attributi specifici per il singolo utente.
Supponiamo che un utente decida di aggiungere o rimuovere delle informazioni dal profilo. In questo caso, il documento può essere facilmente sostituito con una versione aggiornata che contiene tutti i dati e gli attributi aggiunti di recente o che omette attributi e dati rimossi di recente. I database di documenti consentono di gestire più facilmente questo livello di individualità e fluidità.
## Big data in tempo reale
Storicamente, la capacità di estrarre informazioni dai dati operativi era ostacolata dal fatto che i database operativi e i database analitici venivano mantenuti in ambienti diversi, operativi e rispettivamente. business/reporting La possibilità di estrarre informazioni operative in tempo reale è fondamentale in un ambiente aziendale altamente competitivo. Utilizzando i database di documenti, un'azienda può archiviare e gestire i dati operativi da qualsiasi origine e, allo stesso tempo, inviare i dati al motore BI preferito per analizzarli. La presenza di due ambienti non è obbligatoria.
## Gestione dei contenuti
Per gestire in modo efficiente i contenuti, devi poterli raccogliere e aggregare da diverse origini e quindi inviarli al cliente. Grazie al loro schema flessibile, i database di documenti sono perfetti per raccogliere e archiviare qualsiasi tipo di dati. Puoi utilizzarli per creare e integrare nuovi tipi di contenuti, inclusi quelli generati dagli utenti, come immagini, commenti e video.
# Comprensione dei documenti
I database di documenti vengono utilizzati per archiviare dati semistrutturati come documento, anziché normalizzare i dati su più tabelle, ognuna con una struttura unica e fissa, come in un database relazionale. I documenti archiviati in un database di documenti utilizzano coppie chiave-valore nidificate per fornire la struttura o lo schema del documento. Tuttavia, nello stesso database di documenti possono essere archiviati diversi tipi di documenti, rispettando così il requisito che prevede l'elaborazione di dati simili in formati diversi. Ad esempio, visto che ogni documento è autodescrittivo, i documenti codificati con JSON per uno store online descritti in questo argomento [Documenti di esempio in un database di documenti](#document-database-documents) possono essere archiviati nello stesso database di documenti.
**Topics**
+ [SQL e terminologia non relazionale](#document-database-sql-vs-nosql-terms)
+ [Documenti semplici](#document-database-documents-simple)
+ [Documenti incorporati](#document-database-documents-embeded)
+ [Documenti di esempio in un database di documenti](#document-database-documents)
+ [Comprendere la normalizzazione in un database di documenti](#document-database-normalization)
## SQL e terminologia non relazionale
Nella tabella seguente viene confrontata la terminologia utilizzata dai database di documenti (MongoDB) con quella utilizzata dai database SQL.
| SQL | MongoDB |
| --- | --- |
| Tabella | Raccolta |
| Riga | Documento |
| Colonna | Campo |
| Chiave primaria | ObjectId |
| Indice | Indice |
| Vista | Vista |
| Oggetto o tabella annidata | Documento incorporato |
| Array | Array |
## Documenti semplici
Tutti i documenti in un database di documenti sono autodescrittivi. In questa documentazione utilizziamo documenti con formattazione simile a JSON, anche se puoi utilizzare altri mezzi di codifica.
Un documento semplice ha uno o più campi, tutti allo stesso livello all'interno del documento. In questo esempio i campi `SSN`, `LName`, `FName`, `DOB`, `Street`, `City`, `State-Province`, `PostalCode` e `Country` sono tutti di pari livello all'interno del 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 le informazioni vengono organizzate in un documento semplice, ogni campo viene gestito individualmente. Per recuperare l'indirizzo di una persona, devi recuperare `Street`, `City`, `State-Province`, `PostalCode` e `Country` come singoli elementi dati.
## Documenti incorporati
Un documento complesso organizza i propri dati creando documenti incorporati nel documento stesso. I documenti incorporati consentono di gestire i dati in gruppi e come singoli elementi, in base alla soluzione più efficace in un determinato caso. Utilizzando l'esempio precedente, puoi incorporare un documento `Address` nel documento principale. In questo modo si otterrà la struttura del documento seguente:
```
{
"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"
}
}
```
È ora possibile accedere ai dati del documento come campi singoli (`"SSN":`), come documento incorporato (`"Address":`) o come membro di un documento incorporato (`"Address":{"Street":}`).
## Documenti di esempio in un database di documenti
Come indicato in precedenza, ogni documento in un database di documenti è autodescrittivo, quindi la struttura dei documenti all'interno di un database di documenti può essere diversa. I due documenti seguenti, uno relativo a un manuale e l'altro a un periodico, sono strutturalmente differenti. Tuttavia, entrambi possono essere inclusi nello stesso database di documenti.
Di seguito è riportato un documento di esempio per un libro:
```
{
"_id" : "9876543210123",
"Type": "book",
"ISBN": "987-6-543-21012-3",
"Author":
{
"LName":"Roe",
"MI": "T",
"FName": "Richard"
},
"Title": "Understanding Document Databases"
}
```
Di seguito è riportato un documento di esempio per un periodico con due articoli:
```
{
"_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"
}
```
Confronta la struttura di questi due documenti. Con un database relazionale, devi avere tabelle separate per "periodico" e "libri" oppure una singola tabella con campi inutilizzati, ad esempio "Pubblicazione", "Numero", "Articoli" e "MI", come valori `null`. Poiché i database di documenti sono semistrutturati e ogni documento definisce autonomamente la propria struttura, questi due documenti possono coesistere nello stesso database di documenti senza alcun campo `null`. I database di documenti sono uno strumento efficace per gestire i dati di tipo sparse.
L'utilizzo di un database di documenti consente uno sviluppo rapido e iterativo. Il motivo è che puoi modificare la struttura dei dati di un documento in modo dinamico, senza dover modificare lo schema per l'intera raccolta. I database di documenti sono particolarmente adatti per lo sviluppo agile e gli ambienti che evolvono dinamicamente.
## Comprendere la normalizzazione in un database di documenti
I database di documenti non sono normalizzati. I dati nel documento possono essere ripetuti in un altro documento. Inoltre, possono esistere delle discrepanze nei dati dei documenti. Ad esempio, considera uno scenario in cui puoi effettuare acquisti in uno store online e tutti i dettagli dei tuoi acquisti vengono archiviati in un singolo documento. Il documento può essere simile al documenti JSON seguente:
```
{
"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"
}
```
Tutte le informazioni vengono archiviate sotto forma di documento in una raccolta di transazioni. Successivamente, ti accorgi di aver dimenticato di acquistare un articolo. Accedi di nuovo allo stesso store ed effettui un altro acquisto, che a sua volta viene archiviato come documento nella raccolta di transazioni.
```
{
"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"
}
```
Nota la ridondanza tra questi due documenti: il tuo nome e l'ID acquirente (e, se hai usato la stessa carta di credito, i dati della carta di credito). Tuttavia, la procedura non presenta problemi perché lo storage è economico e ogni documento registra completamente una singola transazione che può essere recuperata rapidamente con una semplice query chiave-valore che non richiede join.
C'è anche un'apparente discrepanza tra i due documenti: i dati della tua carta di credito. Si tratta di una discrepanza solo apparente perché è probabile che hai semplicemente utilizzato due carte diverse per gli acquisti. Ogni documento contiene tutti i dati corretti per la transazione documentata.
# Utilizzo dei documenti
Essendo un database di documenti, Amazon DocumentDB semplifica l'archiviazione, l'interrogazione e l'indicizzazione dei dati JSON. In Amazon DocumentDB, una raccolta è analoga a una tabella in un database relazionale, tranne per il fatto che non esiste un unico schema applicato a tutti i documenti. Le raccolte consentono di raggruppare documenti simili mantenendoli comunque nello stesso database, senza richiedere che siano identici a livello di struttura.
Utilizzando i documenti di esempio delle sezioni precedenti, è probabile che tu disponga di raccolte per `reading_material` e `office_supplies`. È responsabilità del software stabilire a quale raccolta appartenga un documento.
Gli esempi seguenti utilizzano l'API MongoDB per mostrare come aggiungere, eseguire query, aggiornare ed eliminare i documenti.
**Topics**
+ [Aggiungere documenti](#document-database-adding-documents)
+ [Interrogazione di documenti](#document-database-queries)
+ [Aggiornamento dei documenti](#document-database-updating)
+ [Eliminazione di documenti](#document-database-deleting)
## Aggiungere documenti
In Amazon DocumentDB, un database viene creato quando si aggiunge per la prima volta un documento a una raccolta. In questo esempio, viene creata una raccolta denominata `example` nel database `test`, che è il database predefinito quando ci si connette a un cluster. Poiché la raccolta viene creata implicitamente quando viene inserito il primo documento, non viene effettuato alcun controllo degli errori sul nome della raccolta. Di conseguenza, un errore di battitura nel nome della raccolta, ad esempio `eexample` anziché `example`, creerà e aggiungerà il documento alla raccolta `eexample` anziché la raccolta desiderata. Il controllo degli errori deve essere gestito dall'applicazione.
Gli esempi seguenti utilizzano l'API MongoDB per aggiungere documenti.
**Topics**
+ [Aggiungere un singolo documento](#document-database-adding-documents-single)
+ [Aggiungere più documenti](#document-database-adding-documents-multiple)
### Aggiungere un singolo documento
Per aggiungere un singolo documento a una raccolta, utilizza l'operazione `insertOne( {} )` con il documento da aggiungere alla raccolta.
```
db.example.insertOne(
{
"Item": "Ruler",
"Colors": ["Red","Green","Blue","Clear","Yellow"],
"Inventory": {
"OnHand": 47,
"MinOnHand": 40
},
"UnitPrice": 0.89
}
)
```
L'aspetto dell'output di questa operazione è simile al seguente (formato JSON).
```
{
"acknowledged" : true,
"insertedId" : ObjectId("5bedafbcf65ff161707de24f")
}
```
### Aggiungere più documenti
Per aggiungere più documenti a una raccolta, utilizza l'operazione `insertMany( [{},...,{}] )` con un elenco di documenti da aggiungere alla raccolta. Anche se i documenti in questo specifico elenco hanno schemi diversi, ciascuno può essere aggiunto alla stessa raccolta.
```
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
}
}
]
)
```
L'aspetto dell'output di questa operazione è simile al seguente (formato JSON).
```
{
"acknowledged" : true,
"insertedIds" : [
ObjectId("5bedb07941ca8d9198f5934c"),
ObjectId("5bedb07941ca8d9198f5934d"),
ObjectId("5bedb07941ca8d9198f5934e")
]
}
```
## Interrogazione di documenti
A volte, potrebbe essere necessario cercare nell'inventario dello store online, in modo che i clienti possano vedere e acquistare ciò che vendi. Eseguire query su una raccolta è relativamente semplice, sia per le ricerche su tutti i documenti della raccolta che per quelle solo sui documenti che soddisfano un determinato criterio.
Per eseguire una query per i documenti, utilizza l'operazione `find()`. Il comando `find()` ha un parametro per documenti singoli che definisce i criteri da utilizzare nella scelta dei documenti da restituire. L'output di `find()` è un documento formattato su una sola riga di testo senza interruzioni di riga. Per formattare il documento di output per facilitare la lettura, utilizza `find().pretty()`. Tutti gli esempi di questo argomento utilizzano `.pretty()` per formattare l'output.
Usa i quattro documenti che hai inserito nella `example` raccolta nei due esercizi precedenti: `insertOne()` e. `insertMany()`
**Topics**
+ [Recupero di tutti i documenti di una raccolta](#document-database-queries-all-documents)
+ [Recupero di documenti che corrispondono a un valore di campo](#document-database-queries-match-criteria)
+ [Recupero di documenti che corrispondono a un documento incorporato](#document-database-queries-entire-embedded-document)
+ [Recupero di documenti che corrispondono a un valore di campo in un documento incorporato](#document-database-queries-embeded-document-field)
+ [Recupero di documenti che corrispondono a un array](#document-database-queries-array-match)
+ [Recupero di documenti che corrispondono a un valore in una matrice](#document-database-queries-array-value-match)
+ [Recupero di documenti tramite operatori](#document-database-query-operators)
### Recupero di tutti i documenti di una raccolta
Per recuperare tutti i documenti nella raccolta, usa l'operazione `find()` con un documento di query vuoto.
La query seguente restituisce tutti i documenti della raccolta `example`.
```
db.example.find( {} ).pretty()
```
### Recupero di documenti che corrispondono a un valore di campo
Per recuperare tutti i documenti che corrispondono a un campo e a un valore, usa l'operazione `find()` con un documento di query che identifica i campi e i valori per la corrispondenza.
Usando i documenti precedenti, questa query restituisce tutti i documenti in cui il campo "Item" è uguale a "Pen".
```
db.example.find( { "Item": "Pen" } ).pretty()
```
### Recupero di documenti che corrispondono a un documento incorporato
Per trovare tutti i documenti che corrispondono a un documento incorporato, utilizza l'operazione `find()` con un documento di query che specifica il nome del documento incorporato e tutti i campi e i valori per quel documento incorporato.
Quando si esegue il confronto di un documento incorporato, il documento incorporato del documento deve avere lo stesso nome che ha nella query. Inoltre, i campi e i valori nel documento incorporato devono corrispondere alla query.
La seguente query restituisce solo il documento "Poster Paint". Questo perché "Pen" ha valori diversi per "`OnHand`" e "`MinOnHand`" e "Spray Paint" ha un ulteriore campo (`OrderQnty`) rispetto al documento di query.
```
db.example.find({"Inventory": {
"OnHand": 47,
"MinOnHand": 50 } } ).pretty()
```
### Recupero di documenti che corrispondono a un valore di campo in un documento incorporato
Per trovare tutti i documenti che corrispondono a un documento incorporato, utilizza l'operazione `find()` con un documento di query che specifica il nome del documento incorporato e tutti i campi e i valori per quel documento incorporato.
Considerati i documenti precedenti, la seguente query utilizza la "dot notation" (notazione col punto) per specificare il documento incorporato e i campi di interesse. Vengono restituiti tutti i documenti che corrispondono a questi campi, indipendentemente da quali altri campi possono essere presenti nel documento incorporato. La query restituisce "Poster Paint" e "Spray Paint" perché entrambi corrispondono ai campi e ai valori specificati.
```
db.example.find({"Inventory.OnHand": 47, "Inventory.MinOnHand": 50 }).pretty()
```
### Recupero di documenti che corrispondono a un array
Per trovare tutti i documenti che corrispondono a una matrice, utilizzare l'operazione `find()` con il nome della matrice richiesta e tutti i valori in quella matrice. La query restituisce tutti i documenti che hanno una matrice con quel nome in cui i valori della matrice sono identici e nello stesso ordine rispetto alla query.
La seguente query restituisce solo "Pen" perché" Poster Paint" ha un ulteriore colore (White) mentre "Spray Paint" ha i colori in un ordine diverso.
```
db.example.find( { "Colors": ["Red","Green","Blue","Black"] } ).pretty()
```
### Recupero di documenti che corrispondono a un valore in una matrice
Per trovare tutti i documenti che hanno un valore specifico di matrice, utilizza l'operazione `find()` con il nome della matrice e il valore richiesto.
```
db.example.find( { "Colors": "Red" } ).pretty()
```
L'operazione precedente restituisce tutti e tre i documenti, in quanto ciascuno di essi dispone di una matrice denominata `Colors` e del valore "`Red`" all'interno della matrice. Se si specifica il valore "`White`", la query restituisce solo "Poster Paint".
### Recupero di documenti tramite operatori
La seguente query restituisce tutti i documenti in cui il valore "`Inventory.OnHand`" è inferiore a 50.
```
db.example.find(
{ "Inventory.OnHand": { $lt: 50 } } )
```
Per un elenco degli operatori di query supportati, consulta [Operatori di interrogazione e proiezione](mongo-apis.md#mongo-apis-query).
## Aggiornamento dei documenti
In genere, i documenti non sono statici e vengono aggiornati come parte dei flussi di lavoro dell'applicazione. Gli esempi seguenti mostrano alcune opzioni di aggiornamento dei documenti.
Per aggiornare un documento esistente, utilizza l'operazione `update()`. L'operazione `update()` presenta due parametri del documento. Il primo documento identifica il documento o i documenti da aggiornare. Il secondo documento specifica gli aggiornamenti da eseguire.
Quando si aggiorna un campo esistente, che si tratti di un campo semplice, di un array o di un documento incorporato, si specifica il nome del campo e i relativi valori. Al termine dell'operazione è come se il campo nel documento precedente fosse stato sostituito dal campo e dai valori nuovi.
**Topics**
+ [Aggiornamento dei valori di un campo esistente](#document-database-updating-existing-fields)
+ [Aggiungere un nuovo campo](#document-database-updating-adding-field)
+ [Sostituzione di un documento incorporato](#document-database-replacing-embedded-document)
+ [Inserimento di nuovi campi in un documento incorporato](#document-database-updating-adding-field-embedded)
+ [Rimuovere un campo da un documento](#document-database-remove-field)
+ [Rimuovere un campo da più documenti](#document-database-remove-field-all)
### Aggiornamento dei valori di un campo esistente
Utilizza i seguenti quattro documenti aggiunti in precedenza per le seguenti operazioni di aggiornamento.
```
{
"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
}
}
```
**Per aggiornare un campo semplice**
Per aggiornare un campo semplice, utilizza `update()` con `$set` per specificare il nome del campo e il nuovo valore. L'esempio seguente modifica l'elemento `Item` da "Pen" a "Gel Pen".
```
db.example.update(
{ "Item" : "Pen" },
{ $set: { "Item": "Gel Pen" } }
)
```
L'aspetto dei risultati di questa operazione è simile al seguente.
```
{
"Item": "Gel Pen",
"Colors": ["Red","Green","Blue","Black"],
"Inventory": {
"OnHand": 244,
"MinOnHand": 72
}
}
```
**Per aggiornare una matrice**
L'esempio seguente sostituisce la matrice esistente di colori con una nuova matrice che comprende `Orange` e rimuove `White` dall'elenco dei colori. Il nuovo elenco di colori è nell'ordine specificato nell'operazione `update()`.
```
db.example.update(
{ "Item" : "Poster Paint" },
{ $set: { "Colors": ["Red","Green","Blue","Orange","Black"] } }
)
```
L'aspetto dei risultati di questa operazione è simile al seguente.
```
{
"Item": "Poster Paint",
"Colors": ["Red","Green","Blue","Orange","Black"],
"Inventory": {
"OnHand": 47,
"MinOnHand": 50
}
}
```
### Aggiungere un nuovo campo
Per modificare un documento aggiungendo uno o più nuovi campi, utilizza l'operazione `update()` con un documento di query che identifica il documento in cui inserire i dati e i nuovi campi e valori da inserire utilizzando l'operatore `$set`.
L'esempio seguente aggiunge il campo `UnitPrice` con il valore `3.99` al documento Spray Paints. Si noti che il valore `3.99` è numerico e non una stringa.
```
db.example.update(
{ "Item": "Spray Paint" },
{ $set: { "UnitPrice": 3.99 } }
)
```
I risultati di questa operazione sono simili ai seguenti (formato JSON).
```
{
"Item": "Spray Paint",
"Colors": ["Black","Red","Green","Blue"],
"Inventory": {
"OnHand": 47,
"MinOnHand": 50,
"OrderQnty": 36
},
"UnitPrice": 3.99
}
```
### Sostituzione di un documento incorporato
Per modificare un documento sostituendo un documento incorporato, utilizza l'operazione `update()` con i documenti che identificano il documento incorporato e i nuovi campi e valori utilizzando l'operatore `$set`.
Considerato il seguente documento.
```
db.example.insert({
"DocName": "Document 1",
"Date": {
"Year": 1987,
"Month": 4,
"Day": 18
}
})
```
**Per sostituire un documento incorporato**
L'esempio seguente sostituisce l'attuale documento Date con uno nuovo che ha solo i campi `Month` e `Day`, mentre `Year` è stato eliminato.
```
db.example.update(
{ "DocName" : "Document 1" },
{ $set: { "Date": { "Month": 4, "Day": 18 } } }
)
```
L'aspetto dei risultati di questa operazione è simile al seguente.
```
{
"DocName": "Document 1",
"Date": {
"Month": 4,
"Day": 18
}
}
```
### Inserimento di nuovi campi in un documento incorporato
**Per aggiungere campi a un documento incorporato**
Per modificare un documento aggiungendo uno o più campi nuovi a un documento incorporato, utilizza l'operazione `update()` con i documenti che identificano il documento incorporato e la "dot notation" per specificare il documento incorporato e i nuovi campi e valori da inserire utilizzando l'operatore `$set`.
Considerato il seguente documento, il codice seguente usa la "dot notation" per inserire i campi `Year` e `DoW` nel documento incorporato `Date` e `Words` nel documento padre.
```
{
"DocName": "Document 1",
"Date": {
"Month": 4,
"Day": 18
}
}
```
```
db.example.update(
{ "DocName" : "Document 1" },
{ $set: { "Date.Year": 1987,
"Date.DoW": "Saturday",
"Words": 2482 } }
)
```
L'aspetto dei risultati di questa operazione è simile al seguente.
```
{
"DocName": "Document 1",
"Date": {
"Month": 4,
"Day": 18,
"Year": 1987,
"DoW": "Saturday"
},
"Words": 2482
}
```
### Rimuovere un campo da un documento
Per modificare un documento rimuovendo un campo, utilizza l'operazione `update()` con un documento di query che identifica il documento da cui rimuovere il campo e l'operatore `$unset` per specificare il campo da rimuovere.
L'esempio seguente rimuove il campo `Words` dal documento precedente.
```
db.example.update(
{ "DocName" : "Document 1" },
{ $unset: { Words:1 } }
)
```
L'aspetto dei risultati di questa operazione è simile al seguente.
```
{
"DocName": "Document 1",
"Date": {
"Month": 4,
"Day": 18,
"Year": 1987,
"DoW": "Saturday"
}
}
```
### Rimuovere un campo da più documenti
Per modificare un documento rimuovendo un campo da più documenti, utilizza l'operazione `update()` con l'operatore `$unset` e l'opzione `multi` impostata su `true`.
L'esempio seguente rimuove il campo `Inventory` da tutti i documenti della raccolta di esempi. Se un documento non contiene il campo `Inventory`, non viene eseguita alcuna azione. Se `multi: true` viene omesso, l'azione viene eseguita solo nel primo documento che soddisfa il criterio.
```
db.example.update(
{},
{ $unset: { Inventory:1 } },
{ multi: true }
)
```
## Eliminazione di documenti
Per rimuovere un documento dal database, utilizza l'operazione `remove()`, specificando il documento da rimuovere. Il codice seguente rimuove "Gel Pen" dalla raccolta `example`.
```
db.example.remove( { "Item": "Gel Pen" } )
```
Per rimuovere tutti i documenti dal database, utilizzate l'`remove()`operazione con una query vuota.
```
db.example.remove( { } )
```