Come gestire i documenti in MongoDB

Introduzione

Quando usi MongoDB, trascorrerai la maggior parte del tuo tempo a gestire i documenti in un modo o nell'altro. Sia che tu stia creando nuovi documenti e aggiungendoli a raccolte, recuperando documenti, aggiornando dati o eliminando elementi obsoleti, i documenti sono al centro del modello MongoDB.

In questa guida tratteremo cosa sono i documenti MongoDB e quindi le operazioni comuni che probabilmente dovrai conoscere per gestire un ambiente incentrato sui documenti.

Cosa sono i documenti MongoDB?

In MongoDB, tutti i dati all'interno di database e raccolte sono archiviati in documenti. Poiché le raccolte non specificano uno schema richiesto per impostazione predefinita, i documenti all'interno di una raccolta possono contenere una struttura arbitrariamente complessa e non è necessario che corrispondano al formato utilizzato dai documenti di pari livello. Ciò fornisce un'incredibile flessibilità e consente allo schema di svilupparsi in modo organico al variare dei requisiti dell'applicazione.

Gli stessi documenti MongoDB utilizzano il formato di serializzazione dei dati BSON, una rappresentazione binaria della notazione dell'oggetto JavaScript JSON. Ciò fornisce una struttura organizzata con tipi di dati definiti su cui è possibile eseguire query e utilizzare a livello di codice.

I documenti BSON sono rappresentati da una coppia di parentesi graffe ({} ) che contengono coppie chiave-valore. In BSON, questi distici di dati sono noti come campo e il suo valore . Il campo viene prima ed è rappresentato da una stringa. Il valore può essere qualsiasi tipo di dati BSON valido. I due punti (: ) separa il campo dal suo valore. Viene utilizzata una virgola per separare ogni campo e ogni coppia di valori l'uno dall'altro.

Ad esempio, ecco un documento BSON valido che MongoDB può comprendere:

{    _id: 80380,    vehicle_type: "car",    mileage: 7377.80,    color: "blue",    markets: [        "US",        "UK"    ],    options: {        transmission: "automatic",        num_doors: 4,        power_windows: true    }}
 

Qui possiamo vederne alcuni tipi:

• _id è un numero intero
• vehicle_type e color sono stringhe
• mileage è un galleggiante
• markets è un array di stringhe
• options contiene un documento nidificato con valori costituiti da una stringa, un intero e un booleano

Grazie a questa flessibilità, i documenti sono un mezzo abbastanza flessibile per l'archiviazione dei dati. È possibile aggiungere facilmente nuovi campi, incorporare documenti l'uno nell'altro e la complessità strutturale corrisponde esattamente ai dati archiviati.

Come creare nuovi documenti

Per creare un nuovo documento, passa a un database in cui desideri archiviare il documento creato. Useremo una school database a scopo dimostrativo in questo articolo:

use school
 

Dovrai anche scegliere la collezione in cui vuoi inserire i documenti. Come per i database, non è necessario creare esplicitamente la raccolta in cui si desidera inserire il documento. MongoDB lo creerà automaticamente quando vengono scritti i primi dati. Per questo esempio, utilizzeremo una raccolta chiamata students .

Ora che sai dove verrà archiviato il documento, puoi inserire un nuovo documento utilizzando uno dei seguenti metodi.

Utilizzo di insert() metodo

Il insert() permette di inserire uno o più documenti nella collezione a cui è chiamato.

Per inserire un singolo documento, passa il documento al metodo chiamandolo sulla raccolta. Qui inseriamo un nuovo documento per uno studente di nome Ashley:

db.students.insert(    {        first_name: "Ashley",        last_name: "Jenkins",        dob: new Date("January 08, 2003"),        grade_level: 8    })
 

WriteResult({ "nInserted" : 1 })
 

Se vuoi inserire più di un documento contemporaneamente, invece di passare un documento a insert() , passare una serie di documenti. Possiamo aggiungere due nuovi documenti per gli studenti di nome 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" : [ ]})
 

Poiché abbiamo eseguito un'operazione di scrittura in blocco, il nostro valore restituito è un BulkWriteResult invece di WriteResult oggetto che abbiamo visto prima.

Mentre insert() è flessibile, è stato deprecato in molti driver MongoDB a favore dei due metodi seguenti.

Utilizzo di insertOne() metodo

Il insertOne() può essere utilizzato per inserire un singolo documento. A differenza di insert() metodo, può inserire solo un documento alla volta, il che rende il suo comportamento un po' più prevedibile.

La sintassi è la stessa di quando usi insert() per aggiungere un unico documento. Possiamo aggiungere un'altra studentessa di nome Naomi:

db.students.insertOne(    {        first_name: "Naomi",        last_name: "Pyani"    })
 

{        "acknowledged" : true,        "insertedId" : ObjectId("60e877914655cbf49ff7cb86")}
 

Diversamente da insert() , il insertOne() restituisce un documento contenente alcune informazioni utili aggiuntive. Conferma che la scrittura è stata riconosciuta dal cluster e include l'ID oggetto assegnato al documento poiché non ne abbiamo fornito uno.

Utilizzo di insertMany() metodo

Per coprire gli scenari in cui desideri inserire più documenti contemporaneamente, insertMany() il metodo è ora consigliato. Proprio come quando si inseriscono più documenti con insert() , insertMany() prende una serie di documenti.

Possiamo aggiungere tre nuovi studenti di nome 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")        ]}
 

Come con insertOne() , insertMany() restituisce un documento che conferma la scrittura e fornisce un array contenente gli ID che sono stati assegnati ai documenti inseriti.

Come eseguire query per documenti esistenti

L'interrogazione dei documenti è un argomento abbastanza ampio che giustifica il proprio articolo. Puoi trovare dettagli su come formulare query per recuperare diversi tipi di documenti nella nostra guida sull'interrogazione dei dati all'interno di MongoDB.

Mentre è meglio lasciare i dettagli nell'articolo collegato sopra, possiamo almeno coprire i metodi forniti da MongoDB per interrogare i documenti. Il modo principale per recuperare i documenti da MongoDB è chiamare find() metodo sulla raccolta in questione.

Ad esempio, per raccogliere tutti i documenti dagli students , puoi chiamare find() senza argomenti:

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" }
 

Per rendere l'output più leggibile, puoi anche concatenare pretty() metodo dopo 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"}
 

Puoi vedere che un _id campo è stato aggiunto a ciascuno dei documenti. MongoDB richiede un _id univoco per ogni documento di una raccolta. Se non ne fornisci uno al momento della creazione dell'oggetto, ne aggiungerà uno per te. Puoi utilizzare questo ID per recuperare un singolo oggetto in modo affidabile:

db.students.find(    {        _id : ObjectId("60e8792d4655cbf49ff7cb89")    })
 

{ "_id" : ObjectId("60e8792d4655cbf49ff7cb89"), "first_name" : "Toni", "last_name" : "Fowler" }
 

Puoi trovare ulteriori informazioni sui vari modi per eseguire query sui dati con l'articolo collegato sopra.

Come aggiornare i documenti esistenti

Molti o la maggior parte dei casi d'uso per i database richiedono la possibilità di modificare i dati esistenti all'interno del database. Potrebbe essere necessario aggiornare un campo per riflettere un nuovo valore o potrebbe essere necessario aggiungere ulteriori informazioni a un documento esistente non appena diventa disponibile.

MongoDB utilizza alcuni metodi correlati per aggiornare i documenti esistenti:

• updateOne() :aggiorna un singolo documento all'interno di una raccolta in base al filtro fornito.
• updateMany() :aggiorna più documenti all'interno di una raccolta che corrispondono al filtro fornito.
• replaceOne() :sostituisce un intero documento in una raccolta in base al filtro fornito.

Tratteremo come utilizzare ciascuna di queste varietà per eseguire diversi tipi di aggiornamenti.

Operatori di aggiornamento

Prima di dare un'occhiata a ciascuno dei metodi per aggiornare i documenti, dovremmo esaminare alcuni degli operatori di aggiornamento disponibili.

• $currentDate :imposta il valore di un campo sulla data corrente, sia come tipo di data che di timestamp.
  • Sintassi:{ $currentDate: { <field>: <type>, ... } }
• $inc :Incrementa il valore di un campo di un importo impostato.
  • Sintassi:{ $inc: { <field>: <amount>, ... } }
• $min :aggiorna il valore di un campo se il valore specificato è inferiore al valore corrente.
  • Sintassi:{ $min: { <field>: <value>, ... } }
• $max :aggiorna il valore di un campo se il valore specificato è maggiore del valore corrente.
  • Sintassi:{ $max: { <field>: <value>, ... } }
• $mul :aggiorna il valore di un campo moltiplicandolo per il numero specificato.
  • Sintassi:{ $mul: { <field>: <value>, ... } }
• $rename :Rinomina il nome di un campo con un nuovo identificatore.
  • Sintassi:{ $rename: { <field>: <new_name>, ... } }
• $set :Sostituisce il valore di un campo con il valore specificato.
  • Sintassi:{ $set: { <field>: value, ... } }
• $setOnInsert :durante le operazioni di inserimento, imposta il valore di un campo se viene creato un nuovo documento e non esegue altrimenti.
  • Sintassi:{ $setOnInsert: { <field>: <value>, ... } }
• $unset :rimuove un campo dal documento.
  • Sintassi:{ $unset: { <field>: "", ... } }
• $ :un segnaposto per il primo elemento dell'array che soddisfa la query.
  • Sintassi:{ <update_operator>: {<array>.$: <value> } }
• $[] :un segnaposto per tutti gli elementi dell'array che soddisfano la query.
  • Sintassi:{ <update_operator>: { <array>.$[]: <value> } }
• $addToSet :Aggiunge valori all'array a meno che non siano già presenti.
  • Sintassi:{ $addToSet: { <field>: <value>, ... } }
• $pop :rimuove il primo o l'ultimo elemento di un array.
  • Sintassi:{ $pop: { <field>: (-1 or 1), ... } }
• $pull :rimuove tutti gli elementi di un array che soddisfano una condizione.
  • Sintassi:{ $pull: { <field>: <condition>, ... } }
• $push :Aggiunge un valore a una matrice.
  • Sintassi:{ $push: { <field>: <value>, ... } }
• $pullAll :rimuove tutti gli elementi specificati da un array.
  • Sintassi:{ $pullAll: { <field>: [ <value>, ... ], ...} }
• $each :Modifica $addToSet e $push operatori in modo che aggiungano ogni elemento di un array invece di un array come un singolo elemento.
  • Sintassi:{ <update_operator>: { <field>: { $each: [ <value>, ... ] }, ... } }
• $position :Usato con $each e specifica la posizione del $push l'operatore deve inserire at.
  • Sintassi:{ $push: { <field>: { $each: [ <value>, ... ], $position: <num> } } }
• $slice :Usato con $each e $push per limitare il numero di elementi totali nell'array.
  • Sintassi:{ $push: { <field>: { $each: [ <value>, ... ], $slice: <num> } } }
• $sort :Usato con $each e $push per ordinare gli elementi dell'array.
  • Sintassi:{ $push: { <field>: { $each: [ <value>, ... ], $sort: <sort_order> } } }

Questi vari operatori di aggiornamento ti consentono di aggiornare vari campi dei tuoi documenti in modi diversi.

Aggiornamento di un singolo documento in una raccolta

updateOne() di MongoDB viene utilizzato per aggiornare un singolo documento all'interno di una raccolta. Il metodo accetta due argomenti obbligatori e un documento che specifica argomenti facoltativi.

Il primo argomento è un documento che specifica le condizioni di filtro che verranno utilizzate per selezionare i documenti. Dal momento che updateOne() modifica al massimo un documento in una raccolta, verrà utilizzato il primo documento che soddisfa le condizioni di filtro.

Il secondo argomento specifica l'operazione di aggiornamento da eseguire. Le operazioni di aggiornamento sopra riportate possono essere specificate qui per alterare il contenuto del documento abbinato.

Il terzo argomento è un documento di varie opzioni per modificare il comportamento del metodo. I valori potenziali più importanti sono:

• upsert :Trasforma l'operazione in una procedura di inserimento inserendo un nuovo documento se il filtro non corrisponde a documenti esistenti.
• collation :un documento che definisce le regole specifiche della lingua che dovrebbero essere applicate per l'operazione.

Ad esempio, possiamo aggiornare un record di un singolo studente che filtriamo in base al _id campo per assicurarci di indirizzare il documento corretto. Possiamo impostare il grade_level a un nuovo valore:

db.students.updateOne(    { _id: ObjectId("60e8792d4655cbf49ff7cb89") },    { $set: { grade_level: 3 } })
 

{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
 

Aggiornamento di più documenti in una raccolta

updateMany() di MongoDB il metodo funziona in modo simile a updateOne() metodo, ma aggiorna invece qualsiasi documento che corrisponde al filtro specificato invece di interrompersi dopo la prima corrispondenza.

Il updateMany() la sintassi segue esattamente updateOne() sintassi, quindi l'unica differenza è l'ambito dell'operazione.

Ad esempio, se vogliamo cambiare tutte le istanze di "composizione" in "scrittura" nei subjects array nei nostri teachers documenti di raccolta, potremmo usare qualcosa del genere:

db.teachers.updateMany(    { subject: "composition" },    { $set: { "subjects.$": "writing" } })
 

{ "acknowledged" : true, "matchedCount" : 3, "modifiedCount" : 3 }
 

Se controlli i documenti, ogni istanza di "composizione" avrebbe dovuto essere sostituita con "scrittura":

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" ] }
 

Sostituzione di un documento

Il replaceOne() il metodo funziona in modo simile a updateOne() metodo, ma sostituisce l'intero documento invece di aggiornare i singoli campi. La sintassi è la stessa dei due comandi precedenti.

Ad esempio, se Nancy Smith lascia la tua scuola e la sostituisci con un'insegnante di nome Clara Newman che insegna letteratura, puoi digitare quanto segue:

db.teachers.replaceOne(    {        $and: [             { first_name: "Nancy" },            { last_name: "Smith" }        ]    },    {        first_name: "Clara",        last_name: "Newman",        subjects: [ "literature" ]    })
 

{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
 

Puoi vedere che il documento abbinato è stato rimosso e che il documento specificato lo ha sostituito:

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" ] }
 

Come eliminare i documenti

Anche la rimozione di documenti dalle raccolte fa parte del ciclo di vita del documento. Per rimuovere un documento, puoi utilizzare deleteOne() o deleteMany() metodi. Hanno la stessa sintassi e differiscono solo per il numero di documenti su cui operano.

Per la maggior parte, tutto ciò che devi fare per eliminare i documenti con uno di questi metodi è fornirgli un documento filtro che specifichi come desideri selezionare il documento da eliminare. Il deleteOne() il metodo cancellerà al massimo un documento (indipendentemente dal numero di corrispondenze prodotte dal filtro) mentre deleteMany() elimina tutti i documenti che soddisfano le condizioni del filtro.

Ad esempio, per eliminare un singolo studente, puoi fornire un _id per abbinarli esplicitamente:

db.students.deleteOne({    _id: ObjectId("60e8792d4655cbf49ff7cb87")})
 

{ "acknowledged" : true, "deletedCount" : 1 }
 

Se vogliamo eliminare uno studente a cui non è stato assegnato un livello di voto, possiamo utilizzare il deleteMany() metodo invece:

db.students.deleteMany({    grade_level: { $eq: null }})
 

{ "acknowledged" : true, "deletedCount" : 2 }
 

Se controlliamo, dovremmo vedere che a tutti gli studenti rimanenti è assegnato un livello di voto:

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 }
 

Conclusione

Imparare a creare, interrogare, aggiornare e rimuovere documenti ti dà le competenze necessarie per gestire efficacemente i documenti all'interno di MongoDB su base giornaliera. Conoscere i vari metodi di raccolta e documentazione e gli operatori che consentono di abbinare e modificare le informazioni consente di esprimere pensieri complessi che il sistema di database può comprendere.