Un tutorial completo su NoSQL con MongoDB

Con l’esplosione dei dati prodotti nell’era digitale, i database sono fondamentali per archiviare, gestire e analizzare grandi quantità di informazioni. In generale, esistono due tipi di database: SQL e NoSQL.

I database SQL usano un formato strutturato e i dati sono organizzati in tabelle con schemi. A differenza dei database SQL, i database NoSQL offrono schemi flessibili per archiviare dati semi-strutturati e non strutturati. Forniscono l’infrastruttura necessaria per gestire e sfruttare l’enorme mole di dati generata nel panorama digitale di oggi.

Questa guida completa coprirà i fondamenti dei database NoSQL e i diversi tipi di database NoSQL con esempi disponibili nel settore. Una volta compresi questi concetti di base, passeremo a MongoDB, un popolare database NoSQL, e vedremo come eseguire le operazioni CRUD (Create, Retrieve, Update e Delete).

Che cos’è NoSQL?

NoSQL sta per “Not Only SQL” ed è stato creato per superare i limiti dei database relazionali. I database relazionali seguono una struttura rigida, hanno un formato tabellare e usano SQL (Structured Query Language) per la manipolazione dei dati.

I database NoSQL offrono un approccio più flessibile per archiviare dati semi-strutturati e non strutturati.

Il principale vantaggio dei database NoSQL è la loro idoneità a gestire grandi volumi di dati con strutture variabili. I database NoSQL sono schema-less, il che consente maggiore agilità e scalabilità.

Tuttavia, questi benefici comportano dei compromessi. Hanno una consistenza debole e un supporto limitato per query complesse. Nonostante tali limitazioni, sono ampiamente utilizzati per i vantaggi che offrono e si affiancano ai database SQL.

Puoi leggere di più sulle differenze chiave tra database SQL e NoSQL e su alcuni consigli su quando scegliere l’uno o l’altro in un tutorial dedicato.

Tipi di database NoSQL

Per soddisfare le esigenze di casi d’uso diversi, i database NoSQL adottano vari modelli di dati per organizzare e accedere alle informazioni. Ecco 4 tipi comuni di database NoSQL.

1. Basati su coppie chiave-valore sono la forma più semplice di database NoSQL. I dati sono archiviati come coppie chiave-valore e possono essere recuperati usando la chiave. Alcuni esempi sono Redis e Amazon DynamoDB.
2. I database orientati alle colonne organizzano i dati per colonne anziché per righe. Questa struttura è efficiente nel recupero dei dati per colonna. Apache Cassandra, HBase e Google Bigtable sono orientati alle colonne.
3. I database basati su grafi archiviano i dati in strutture a grafo composte da nodi, archi e proprietà. Neo4j e Amazon Neptune sono popolari database a grafo.
4. Orientati ai documenti archiviano i dati come documenti in stile JSON. La struttura di un documento può variare e includere dati annidati. Questo è un tipo di database NoSQL ampiamente utilizzato. Esempi includono MongoDB e CouchDB.

Per saperne di più sui diversi tipi di database, ti invitiamo a consultare il nostro tutorial, NoSQL Databases: What Every Data Scientist Needs to Know.

Dopo aver visto cos’è NoSQL e i tipi di database NoSQL, è il momento di fare pratica.

Tutorial NoSQL: progettare un database NoSQL per una piattaforma di blogging

Entrare in un esempio pratico e reale è fondamentale per comprendere e sperimentare i concetti trattati. Vediamo insieme un tutorial su NoSQL.

Supponiamo che tu voglia creare la tua piattaforma di blog. Vorresti creare post, consentire i commenti e mantenerli aggiornati. Dato che sai che i dati sono non strutturati, capisci che un database NoSQL come MongoDB sarebbe adatto al caso d’uso.

MongoDB è un database NoSQL open-source. Invece di usare tabelle, archivia i dati in documenti in stile JSON. Questo consente di rappresentare facilmente strutture e relazioni complesse. È semplice gestire diversi tipi di dati tra cui testo, numeri o immagini, che probabilmente esistono nei blog.

Iniziamo installando MongoDB sulla tua macchina.

1. Installare MongoDB

Installare MongoDB è piuttosto semplice. Possiamo scaricarlo e installarlo dal sito ufficiale di MongoDB. Le istruzioni variano in base al sistema operativo, quindi consulta le istruzioni di installazione per il tuo sistema operativo nella documentazione ufficiale.

Dopo l’installazione, avvia MongoDB. Apri semplicemente il terminale e digita quanto segue in base al tuo sistema operativo:

// Linux
sudo systemctl start mongod

//Mac OS
brew services start mongodb-community@7.0

Otterremo un output che dice “Successfully started”, come mostrato sotto.

Output: avvio di MongoDB. (Questa e tutte le immagini sotto sono dell’autore)

L’installazione di MongoDB include una shell chiamata mongosh che possiamo usare per interagire con il database MongoDB. Possiamo quindi utilizzarla senza installazioni aggiuntive.

Avvia la shell di MongoDB eseguendo il seguente comando nel terminale:

mongosh

L’esecuzione del comando mongosh restituirà l’output seguente che indica la connessione al tuo database.

Avvia la shell di MongoDB.

Con MongoDB installato, passiamo a definire il nostro modello dati.

2. Definire il modello dati

Creeremo un database chiamato “blog” e due collection chiamate “posts” e “comments”. La collection “posts” serve a raccogliere le voci del blog e la collection “comments” ad archiviare i commenti a quei post.

Ogni documento post avrà campi per titolo, contenuto, autore e data di creazione, mentre ogni documento comment avrà campi per il contenuto del commento, l’autore e l’ID del post associato.

Per elencare tutti i database esistenti, esegui show dbs nella shell. Se è la tua prima volta con MongoDB, vedrai l’output seguente.

Elenco dei database esistenti.

Per impostazione predefinita, useremo il database test. Anche se ci troviamo nel database test, il database non viene creato finché non inseriamo un documento in una collection del database.

Per creare un nuovo database, esegui use <database_name>.

Nel nostro esempio useremo “blog” come nome del database. Procedi ed esegui use blog per creare il nuovo database. Come detto sopra, l’esecuzione del comando show dbs non mostrerà il nuovo database finché non inseriamo una collection nel database. Pertanto, esegui i comandi sotto per creare una collection.

// create database
use blog

// create collection
db.createCollection("posts")
db.createCollection("comments")

L’esecuzione di use blog cambierà il database da “test” a “blog”.

Output: creazione di database e collection.

Dopo aver creato le collection, possiamo verificarlo con il comando show dbs.

Elenco dei database.

Abbiamo creato con successo un database e le collection.

3. Implementare le operazioni CRUD

MongoDB supporta quattro operazioni CRUD principali (Create, Read, Update, Delete) per interagire con i dati:

1. Create: Per creare un documento in MongoDB, lo inseriamo in una collection usando i metodi insertOne() o insertMany(). I documenti possono contenere qualsiasi dato JSON valido, consentendo un design dello schema flessibile.
2. Read: Per leggere i dati da MongoDB, effettuiamo query con il metodo find(). Le query filtrano i documenti in base ai criteri specificati e restituiscono i risultati.
3. Update: Per aggiornare i documenti, si possono usare updateOne() o updateMany(). Questo metodo consente una manipolazione flessibile dei dati.
4. Delete: Per eliminare documenti da una collection, usiamo i metodi deleteOne() o deleteMany(). Le eliminazioni vengono eseguite in base a criteri specifici, come la corrispondenza di un determinato valore di campo.

Ora che abbiamo visto i comandi, mettiamoli in pratica con il nostro caso d’uso del blog.

4. Creare un post del blog

Per inserire documenti in un database MongoDB, esistono due metodi.

1. insertOne() : inserisce un documento alla volta
2. insertMany() : con questo metodo possiamo inserire molti documenti in una volta sola.

Usiamo entrambi i metodi per aggiungere post al database. Nel codice sotto, creiamo documenti nella collection “posts”. Ogni documento ha un titolo, un contenuto, un autore e una data di creazione.

// use insertOne() method to insert one document to the "posts" collection
db.posts.insertOne({
   title: "Introduction to NoSQL with MongoDB",
   content: "MongoDB is a NoSQL database that stores data in JSON format",
   author: "Arunn Thevapalan",
   createdAt: new Date()
})

// array of blog post documents
var postsData = [
   {
       title: "Getting Started with MongoDB",
       content: "Learn the basics of MongoDB",
       author: "Arunn Thevapalan",
       createdAt: new Date()
   },
   {
       title: "Advanced MongoDB Techniques",
       content: "Explore advanced features of MongoDB",
       author: "Jim Murphy",
       createdAt: new Date()
   }
];

// use insertMany() to insert multiple documents
db.posts.insertMany(postsData);

Questo output indica che il server MongoDB ha ricevuto ed elaborato correttamente la richiesta insertOne.

Output: inserimento di un documento in una collection.

Allo stesso modo, l’output seguente indica l’elaborazione riuscita della richiesta insertMany.

Output: inserimento di più documenti in una collection.

Dopo l’operazione Create, passiamo all’operazione Read.

5. Interrogare i post del blog

Possiamo usare il metodo find() per recuperare i dati dalle collection. Per recuperare i post sopra dalla nostra collection “posts”, esegui il comando seguente.

db.posts.find()

Il metodo find restituirà tutti i documenti nella collection “posts”. L’output seguente mostra tutti i documenti inseriti nel passaggio precedente.

Output: recupero dei documenti da una collection.

6. Aggiungere un commento a un post

Supponiamo di voler aggiungere alcuni commenti a un post: possiamo inserire un documento nella collection “comments”. I commenti sono associati ai post del blog, quindi manterremo un riferimento all’ID del post.

// use an object id from any of the above entries
var postId = ObjectId("664bfc27f74ef93812b2179e")

// insert one comment
db.comments.insertOne({
   postId: postId,
   content: "Informative article!",
   author: "Anne Smith",
   createdAt: new Date()
})

Questo output indica che il server MongoDB ha ricevuto ed elaborato la richiesta.

Output: creazione di un documento che fa riferimento a un altro documento.

7. Interrogare i commenti di un post

Per recuperare i commenti associati a uno specifico post del blog, si può usare il metodo find() con un filtro di query:

// retrieve the above comment

db.comments.find({postId: postId})

L’output seguente mostra il commento inserito nel passaggio precedente.

Output: trovare un documento usando la query find.

Una volta creati i post del blog, gli utenti vorranno poterli aggiornare in un secondo momento. Vediamo quindi come aggiornare i documenti esistenti.

8. Aggiornare un post del blog

Analogamente all’inserimento, anche l’aggiornamento può essere effettuato singolarmente o collettivamente.

1. updateOne() : aggiorna un documento alla volta
2. updateMany() : aggiorna più documenti in una volta sola.

Proviamo a cambiare il titolo del post “Introduction to NoSQL with MongoDB” in “Absolute Beginner Guide to NoSQL with MongoDB”.

Poiché conosciamo l’ID del post da uno dei passaggi precedenti, esegui il codice seguente per cambiare il titolo. Assicurati di aggiornare postId con l’ID del tuo documento.

var postId = ObjectId("664bfc27f74ef93812b2179e");

db.posts.updateOne(
   { _id: postId },
   { $set: { title: "Absolute Beginner guide to NoSQL with MongoDB"} }
);

// verify update
db.posts.find({_id: postId})

L’output indica che la richiesta è stata elaborata correttamente. Ha trovato 1 documento corrispondente e ne ha modificato 1.

Output: aggiornamento di un documento.

9. Eliminare un post del blog

Per eliminare un post del blog si può usare deleteOne(). Come per le operazioni precedenti, facoltativamente possiamo usare deleteMany() per eliminare più documenti in una volta.

var postId = ObjectId("664bfc27f74ef93812b2179e");

// delete post
db.posts.deleteOne({ _id: postId });

// verify deletion -> no output
db.posts.find({_id: postId})

L’output conferma l’eliminazione avvenuta con successo.

Output: eliminare un documento da una collection

Ovviamente abbiamo semplificato il design di una piattaforma di blogging, che in genere è complessa e include varie altre operazioni come evidenziazioni, like, clap, raccomandazioni, ecc. Ma tutte queste operazioni si basano su una delle operazioni CRUD e ora abbiamo una buona comprensione di questi concetti di base. Ora tocca a te esplorare e sperimentare più funzionalità basate su queste operazioni.

Conclusione

Questo tutorial ti ha introdotto ai database NoSQL. Siamo partiti dai concetti di base, dalla definizione dei database NoSQL, da come differiscono dai database relazionali e dai loro tipi.

Abbiamo poi approfondito MongoDB, un database a documenti ampiamente utilizzato. Infine, abbiamo messo le mani in pasta con un semplice esempio per progettare un database per la nostra piattaforma di blog.

È normale bloccarsi quando si progetta un database per un nuovo caso d’uso, e ti invitiamo a consultare la documentazione ufficiale per conoscere funzioni ed esempi aggiornati.

Ecco alcuni corsi e tutorial più approfonditi se desideri ampliare le tue conoscenze su NoSQL.

• Corso NoSQL Concepts
• Introduzione a MongoDB in Python
• Introduzione a DynamoDB: padroneggiare il database NoSQL con Node.js | Tutorial per principianti