Come eseguire operazioni CRUD in MongoDB

MongoDB offre ai suoi utenti la possibilità di creare database moderni facilmente accessibili e manipolabili.

MongoDB è un database open source NoSQL disponibile per l'uso su tutti i sistemi operativi.

Se hai imparato la progettazione di database a scuola, è probabile che non hai imparato a utilizzare MongoDB o hai acquisito molta esperienza con i database NoSQL. Ciò non sorprende: fino al 1998 molte persone non avevano nemmeno sentito parlare di NoSQL, e solo nel 2009 i database NoSQL hanno iniziato a guadagnare terreno.

Cos'è NoSQL?

L'acronimo SQL sta per "linguaggio di query strutturato". SQL viene utilizzato per eseguire operazioni matematiche sui dati contenuti in database strutturati rigidamente da righe e colonne (tabelle).

L'acronimo NoSQL, a seconda di chi chiedi, sta per "not only SQL" o "non SQL". Tuttavia, l'unico fatto che tutti può essere d'accordo è che NoSQL viene utilizzato per eseguire operazioni sui dati che si trovano in database non strutturati da righe e colonne.

Esistono alcuni database NoSQL, ma il nome che sta sopra il resto è MongoDB. In effetti, alcune persone pensano che MongoDB sia l'unico database nel suo genere.

Cos'è MongoDB?

NoSQL supporta quattro diversi tipi di database: documento, archivi di valori-chiave, orientato alle colonne e grafico. MongoDB è un database di documenti perché memorizza i dati in un documento simile a JSON e, come tutti i database, supporta tutte le operazioni CRUD essenziali.

Relazionato: Come un database MongoDB può organizzare meglio i tuoi dati

Cosa sono le operazioni CRUD?

L'acronimo CRUD sta per "creare, leggere, aggiornare ed eliminare". CRUD rappresenta i quattro requisiti funzionali di base di tutti i database. Se utilizzi un database che non ti consente di creare, leggere, aggiornare o eliminare record, non si tratta di un database.

Scarica MongoDB

Prima di poter eseguire qualsiasi operazione CRUD in MongoDB, devi scaricare e installare MongoDB sul tuo file dispositivo (o usa una versione cloud disponibile), esegui il server MongoDB, connettiti ad esso e infine crea un nuovo file Banca dati.

Il server MongoDB può essere scaricato dal sito ufficiale Sito Web MongoDB.

Esecuzione del server MongoDB

Esegui MongoDB Server dalla console del tuo IDE.

/Users/Administrator/mongodb/bin/mongod.exe --dbpath = / Users / Administrator / mongodb-data

Il codice sopra esegue il server MongoDB. La prima metà fornisce il percorso diretto al file eseguibile MongoDB (mongod.exe) archiviato sul dispositivo. Il percorso sul tuo dispositivo dovrebbe essere diverso, ma l'obiettivo è raggiungere il file mongod.exe nella cartella bin.

La seconda metà del codice (che è separata dalla barra spaziatrice) è un altro percorso. Questo percorso porta a "mongodb-data", che è un file che dovrai creare da solo. Questo file conterrà tutti i dati che vengono creati nel nostro database.

Il nostro file si chiama "mongodb-data", ma il nome può essere quello che ritieni adatto.

L'esecuzione del codice precedente dovrebbe produrre diverse righe di codice, ma le due righe a cui è necessario prestare molta attenzione possono essere visualizzate di seguito:

{"t": {"$ date": "2021-04-14T18: 10: 11.779-05: 00"}, "s": "I", "c": "NETWORK", "id": 23015, "ctx": "listener", "msg": "Listening on", "attr": {"address": "127.0.0.1"}}
{"t": {"$ date": "2021-04-14T18: 10: 11.797-05: 00"}, "s": "I", "c": "NETWORK", "id": 23016, "ctx": "listener", "msg": "In attesa di connessioni", "attr": {"port": 27017, "ssl": "off"}}

Queste due righe contengono rispettivamente l'host locale e la porta predefinita del server MongoDB. Questi due numeri sono necessari per creare successivamente una connessione al server MongoDB in modo da poter eseguire le nostre operazioni CRUD.

Esecuzione di operazioni CRUD

Ora che il nostro server MongoDB è attivo e funzionante, possiamo collegarci ad esso (utilizzando il driver appropriato) e iniziare a eseguire operazioni CRUD. Per questo articolo, creeremo un semplice database utente che memorizzerà i nomi e l'età dei nostri utenti.

Creazione di un utente

Esistono due modi principali per inserire utenti in un database MongoDB. Entrambi i metodi sono abbastanza simili, ma il metodo da scegliere dipende dal numero di utenti che desideri creare in un'istanza specifica. Se il tuo obiettivo è creare un utente, dovresti utilizzare il file insertOne metodo.

Tuttavia, se l'obiettivo è creare più di un utente alla volta, il file insertMany è un'opzione migliore.

Esempio di metodo MongoDB insertOne

// importa mongodb e usa la destrutturazione per ottenere la funzione MongoClient
const {MongoClient} = require ("mongodb");
// l'URL di connessione e il database a cui intendiamo connetterci
const connectionURL = 'mongodb: //127.0.0.1: 27017';
const databaseName = 'user-manager';
// utilizzando la funzione di connessione su MongoClient per connettersi al server MongoDB
MongoClient.connect (connectionURL, {useUnifiedTopology: true}, (errore, client) => {
// controlla se la connessione è stata stabilita
if (errore) {
return console.log ("Impossibile connettersi al database");
}
// accede al database del gestore utenti
const db = client.db (databaseName);
// inserisce un utente nel database
db.collection ('users'). insertOne ({
nome: "John Doe",
età: "28"
}, (errore, risultato) => {
if (errore) {
return console.log ('Impossibile creare l'utente');
}
console.log (result.ops);
})
})

Prima di poter creare qualsiasi utente, è necessario stabilire una connessione con il server MongoDB utilizzando il driver MongoDB della lingua che stai utilizzando. Il driver più popolare e quello che stiamo usando in questo tutorial è il driver NodeJS.

Con la prima riga del nostro codice sopra, siamo in grado di utilizzare il metodo di destrutturazione per recuperare la funzione MongoClient dal nostro server.

MongoClient accetta tre argomenti:

• Un URL (utilizzato per connettersi al server MongoDB)
• Opzioni / Impostazioni (che in questo caso imposta la variabile "useUnifiedTopology" su true, per facilitare l'utilizzo del nuovo motore di rilevamento e monitoraggio dei server)
• Una funzione di callback che accetta due argomenti (errore e client)

All'interno della funzione di callback del metodo MongoClient, possiamo finalmente inserire un utente nel nostro database. Ma prima di arrivare a quel punto, dobbiamo accedere al database del gestore utenti.

Una delle bellezze dell'utilizzo di MongoDB è che non è necessario creare esplicitamente un database. Una volta generato un riferimento a un database particolare utilizzando l'argomento "client" (come mostrato nel codice sopra), sei libero di iniziare a manipolarlo.

Il riferimento al database user-manager che generiamo è memorizzato nella variabile “db”, che useremo per inserire il nostro primo utente nel database.

Utilizzando il riferimento “db”, possiamo creare una nuova collezione, a cui assegniamo il nome "utente".

Il insertOne il metodo accetta due argomenti obbligatori; il documento (l'utente) e una funzione di callback. Con il insertOne metodo, siamo in grado di inserire un utente con il nome di Peter Davis con l'età di 32, nel nostro database.

La funzione di callback accetta due argomenti (errore e risultato). La funzione di risultato contiene un metodo ops che usiamo per vedere l'utente che abbiamo appena creato nel nostro database. Questo produce il seguente output nella console, dopo che il codice sopra è stato eseguito:

[{name: "Peter Davis", age: "32", _id: 60772f869475e84740003c45}]

Sebbene abbiamo fornito solo due campi durante la creazione di un utente, puoi vedere dall'output sopra che è stato generato un terzo campo. Questa è un'altra cosa interessante di MongoDB; genera automaticamente un ID univoco per ogni documento che crea.

Relazionato: In che modo la modellazione dei dati è diversa in MongoDB?

Leggere un utente in MongoDB

I due metodi principali utilizzati per leggere i documenti da un MongoDB sono: trova e trova uno. Il trova viene utilizzato per leggere più documenti contemporaneamente e il metodo trova uno viene utilizzato per leggere un singolo documento alla volta.

Esempio del metodo findOne di MongoDB

// importa mongodb e usa la destrutturazione per ottenere il metodo MongoClient
const {MongoClient} = require ("mongodb");
// l'URL di connessione e il database a cui intendiamo connetterci
const connectionURL = 'mongodb: //127.0.0.1: 27017';
const databaseName = 'user-manager';
// utilizzando la funzione di connessione su MongoClient per connettersi al server MongoDB
MongoClient.connect (connectionURL, {useUnifiedTopology: true}, (errore, client) => {
// controlla se la connessione è stata stabilita
if (errore) {
return console.log ("Impossibile connettersi al database");
}
// crea il database del gestore utenti
const db = client.db (databaseName);
// trovare un utente nel database
db.collection ('users'). findOne ({name: 'Peter Davis'}, (error, user) => {
if (errore) {
return console.log ("Impossibile trovare l'utente");
}
console.log (utente);
})
});

È bene ricordare che dovrai sempre connetterti al server MongoDB e al database appropriato prima di poter eseguire qualsiasi operazione CRUD (come mostrato nel nostro esempio sopra).

Il trova uno metodo accetta due argomenti obbligatori. Il primo argomento contiene i criteri di ricerca; è possibile cercare un documento utilizzando qualsiasi nome di variabile univoco. Nel nostro esempio sopra usiamo il nome "Peter Davis".

Il secondo argomento del trova uno metodo è la funzione di callback che accetta due argomenti; il primo è un errore se il documento non può essere localizzato, e il secondo è il documento (che abbiamo chiamato "utente").

L'esecuzione del codice precedente produrrà il seguente risultato nella console:

{_id: 60772f869475e84740003c45, nome: "Peter Davis", età: "32"}

Aggiornamento di un utente in MongoDB

Sono disponibili due metodi per aggiornare i documenti in MongoDB. Sebbene la struttura per entrambi sia molto simile, updateOne viene utilizzato per aggiornare un documento alla volta e updateMany viene utilizzato per aggiornare molti documenti contemporaneamente.

Esempio di metodo updateOne di MongoDB

// Aggiorna l'età di un utente
db.collection ('users'). updateOne ({name: "Peter Davis"},
{
$ set: {
età: "24"
}
})

Con il codice sopra possiamo aggiornare l'età di Peter Davis a 24 anni.

Eliminazione di un utente in MongoDB

Sono disponibili due metodi per eliminare un documento da MongoDB. Il deleteOne viene utilizzato per eliminare un singolo documento e il metodo deleteMany viene utilizzato per eliminare più documenti.

Esempio di metodo deleteOne di MongoDB

// elimina un documento
db.collection ('users'). deleteOne ({name: 'Peter Davis'})

L'operazione di eliminazione è la più semplice operazione CRUD che può essere eseguita in MongoDB. Come puoi vedere nell'esempio sopra (escluso il codice di connessione richiesto e la funzione di callback), richiede solo una riga di codice.

Ora puoi eseguire operazioni CRUD in MongoDB

Ora hai una conoscenza di base di MongoDB e sai cosa significa NoSQL. Sai anche cosa significa l'acronimo CRUD e perché queste operazioni sono qualità essenziali di ogni database.

Questo articolo fornisce tutti gli strumenti necessari per eseguire le quattro operazioni CRUD di base in MongoDB. Ora che sei dotato del know-how delle operazioni CRUD, puoi iniziare a imparare come modellare al meglio i tuoi dati utilizzando MongoDB.

Credito immagine: Alexander Sosluev /WiKiMedia Commons

In che modo la modellazione dei dati è diversa in MongoDB?

Stai considerando un approccio diverso ai database? Ecco come funziona la modellazione dei dati in MongoDB.

Leggi Avanti

Circa l'autore