Padroneggiare le Operazioni CRUD di MongoDB: Una Guida Pratica ai Comandi

MongoDB, un popolare database documentale NoSQL, costituisce la spina dorsale di innumerevoli applicazioni moderne grazie alla sua flessibilità, scalabilità e prestazioni. Al centro dell'interazione con qualsiasi database ci sono le operazioni fondamentali di Creazione, Lettura, Aggiornamento ed Eliminazione (CRUD). Padroneggiare questi comandi è essenziale per chiunque lavori con MongoDB, dagli sviluppatori che creano nuove funzionalità agli amministratori che gestiscono i dati.

Questa guida utilizza una piccola collezione users e mostra i comandi CRUD di MongoDB a cui ricorri durante il lavoro reale: aggiungere un record da un modulo di registrazione, trovare il documento dietro un ticket di supporto, modificare un campo senza sovrascrivere il resto del documento ed eliminare dati senza cancellare accidentalmente l'intera collezione. Gli esempi usano mongosh, ma gli stessi filtri e operatori di aggiornamento si applicano ai driver delle applicazioni.

Prerequisiti

Prima di immergerti nei comandi, assicurati di avere:

• MongoDB installato e in esecuzione: Puoi scaricarlo dal sito ufficiale di MongoDB o utilizzare un servizio cloud come MongoDB Atlas.
• mongosh (MongoDB Shell) installato: Questa è l'interfaccia JavaScript interattiva per MongoDB.

Connessione a MongoDB e Selezione di un Database

Per iniziare, apri il tuo terminale o prompt dei comandi e connettiti alla tua istanza MongoDB usando mongosh:

mongosh

Una volta connesso, ti troverai nel database predefinito test. Per passare a un nuovo database o crearne uno, usa il comando use:

use myDatabase;

Se myDatabase non esiste, MongoDB lo creerà implicitamente quando inserirai il tuo primo documento in una collezione al suo interno.

Operazioni di Creazione (Insert)

Le operazioni di creazione comportano l'aggiunta di nuovi documenti a una collezione. MongoDB fornisce metodi per inserire documenti singoli o multipli.

1. db.collection.insertOne()

Questo metodo inserisce un singolo documento in una collezione. Se la collezione non esiste, MongoDB la crea.

// Seleziona una collezione chiamata 'users'
db.users.insertOne({
  name: "Alice Smith",
  age: 30,
  city: "New York",
  email: "[email protected]",
  interests: ["reading", "hiking"]
});

L'output mostrerà lo stato acknowledged e l'insertedId del nuovo documento.

2. db.collection.insertMany()

Usa questo metodo per inserire più documenti in una collezione in una singola operazione. Prende un array di documenti.

db.users.insertMany([
  {
    name: "Bob Johnson",
    age: 24,
    city: "Los Angeles",
    email: "[email protected]",
    interests: ["coding", "gaming"]
  },
  {
    name: "Charlie Brown",
    age: 35,
    city: "New York",
    email: "[email protected]",
    interests: ["cooking", "photography"]
  },
  {
    name: "Diana Prince",
    age: 29,
    city: "London",
    email: "[email protected]",
    interests: ["fitness", "travel"]
  }
]);

Questo restituirà un array di insertedIds per tutti i documenti aggiunti.

Suggerimento: MongoDB aggiunge automaticamente un campo _id (un ObjectId univoco) a ogni documento se non ne fornisci uno.

Operazioni di Lettura (Find)

Le operazioni di lettura comportano l'interrogazione dei documenti da una collezione. Il metodo find() è il tuo strumento principale per questo.

1. db.collection.find()

a. Trova Tutti i Documenti

Per recuperare tutti i documenti in una collezione, chiama find() senza argomenti:

db.users.find();

b. Trova Documenti con un Filtro di Query

Passa un documento di query a find() per specificare i criteri per la selezione dei documenti. Questo funge da clausola WHERE in SQL.

// Trova utenti da New York
db.users.find({ city: "New York" });

// Trova utenti con età maggiore di 25
db.users.find({ age: { $gt: 25 } });

// Trova utenti con età compresa tra 25 e 35 (escluso 35)
db.users.find({ age: { $gt: 25, $lt: 35 } });

// Trova utenti i cui interessi includono 'coding'
db.users.find({ interests: "coding" });

// Trova utenti i cui interessi includono ENTRAMBI 'reading' e 'hiking'
db.users.find({ interests: { $all: ["reading", "hiking"] } });

// Trova utenti di nome Alice Smith OPPURE di Londra
db.users.find({
  $or: [
    { name: "Alice Smith" },
    { city: "London" }
  ]
});

Operatori di query comuni:

• $eq: Uguale a (predefinito se non viene specificato alcun operatore)
• $ne: Diverso da
• $gt: Maggiore di
• $gte: Maggiore o uguale a
• $lt: Minore di
• $lte: Minore o uguale a
• $in: Corrisponde a uno qualsiasi dei valori specificati in un array
• $nin: Non corrisponde a nessuno dei valori specificati in un array
• $and, $or, $not, $nor: Operatori logici

c. Proiezione: Selezione di Campi Specifici

Per restituire solo un sottoinsieme di campi, passa un documento di proiezione come secondo argomento a find(). Un valore di 1 include il campo, 0 lo esclude. Il campo _id è incluso per impostazione predefinita a meno che non sia esplicitamente escluso.

// Restituisce solo nome ed email, esclude _id
db.users.find({ city: "New York" }, { name: 1, email: 1, _id: 0 });

d. Ordinamento, Limitazione e Salto

Concatenare metodi consente query più complesse:

// Ordina per età in ordine decrescente (1 per crescente, -1 per decrescente)
db.users.find().sort({ age: -1 });

// Limita i risultati a 2 documenti
db.users.find().limit(2);

// Salta i primi 2 documenti e restituisce il resto
db.users.find().skip(2);

// Combina operazioni: Trova utenti da New York, ordina per età, salta 1, limita a 1
db.users.find({ city: "New York" }).sort({ age: 1 }).skip(1).limit(1);

2. db.collection.findOne()

Questo metodo restituisce un singolo documento che corrisponde ai criteri della query. Se più documenti corrispondono, restituisce il primo trovato.

db.users.findOne({ name: "Alice Smith" });

Operazioni di Aggiornamento

Le operazioni di aggiornamento modificano i documenti esistenti in una collezione. Puoi aggiornare un singolo documento, più documenti o persino sostituire un intero documento.

1. db.collection.updateOne()

Aggiorna un singolo documento che corrisponde ai criteri del filtro.

// Aggiorna la città di Alice a 'San Francisco'
db.users.updateOne(
  { name: "Alice Smith" },
  { $set: { city: "San Francisco", lastUpdated: new Date() } }
);

2. db.collection.updateMany()

Aggiorna tutti i documenti che corrispondono ai criteri del filtro.

// Incrementa l'età di tutti gli utenti a New York di 1
db.users.updateMany(
  { city: "New York" },
  { $inc: { age: 1 } }
);

// Aggiungi un nuovo interesse 'reading' agli utenti che non lo hanno già
db.users.updateMany(
  {}, // Applica a tutti i documenti
  { $addToSet: { interests: "reading" } }
);

// Rimuovi 'gaming' dagli interessi per Bob Johnson
db.users.updateOne(
  { name: "Bob Johnson" },
  { $pull: { interests: "gaming" } }
);

Operatori di aggiornamento comuni:

• $set: Imposta il valore di un campo in un documento. Crea il campo se non esiste.
• $inc: Incrementa il valore di un campo di una quantità specificata.
• $unset: Rimuove un campo da un documento.
• $push: Aggiunge un valore a un campo array.
• $pull: Rimuove tutte le istanze di un valore o valori che corrispondono a una query specificata da un array.
• $addToSet: Aggiunge un valore a un array solo se il valore non è già presente.

3. db.collection.replaceOne()

Sostituisce un singolo documento che corrisponde ai criteri del filtro con un nuovo documento. Il campo _id del documento sostituito non può essere modificato.

// Sostituisce completamente il documento di Bob Johnson
db.users.replaceOne(
  { name: "Bob Johnson" },
  {
    name: "Robert Johnson",
    occupation: "Software Engineer",
    status: "active",
    email: "[email protected]"
  }
);

Opzione Upsert

Sia updateOne() che updateMany() supportano un'opzione upsert. Se impostata su true e nessun documento corrisponde al filtro, MongoDB inserirà un nuovo documento basato sulla query e sulle operazioni di aggiornamento.

db.users.updateOne(
  { name: "David Lee" },
  { $set: { age: 28, city: "Seattle" } },
  { upsert: true } // Se David Lee non esiste, crealo
);

Operazioni di Eliminazione

Le operazioni di eliminazione rimuovono documenti da una collezione. Fai molta attenzione con le operazioni di eliminazione, poiché sono irreversibili.

1. db.collection.deleteOne()

Elimina al massimo un documento che corrisponde al filtro specificato.

// Elimina l'utente di nome 'Robert Johnson' (precedentemente 'Bob Johnson')
db.users.deleteOne({ name: "Robert Johnson" });

2. db.collection.deleteMany()

Elimina tutti i documenti che corrispondono al filtro specificato.

// Elimina tutti gli utenti da Londra
db.users.deleteMany({ city: "London" });

Attenzione: Per eliminare tutti i documenti in una collezione, usa un filtro vuoto {}. Fai molta attenzione poiché questa operazione non può essere annullata:

db.users.deleteMany({}); // Elimina tutti i documenti nella collezione 'users'

3. db.collection.drop()

Questo metodo rimuove permanentemente un'intera collezione dal database, inclusi tutti i suoi documenti e indici.

db.users.drop(); // Elimina l'intera collezione 'users'

Attenzione: Eliminare una collezione è un'operazione altamente distruttiva. Assicurati di avere backup adeguati o di essere assolutamente certo prima di eseguire questo comando.

Best Practice per le Operazioni CRUD di MongoDB

• Indicizzazione: Per i campi interrogati frequentemente, crea indici per accelerare significativamente le operazioni di lettura. db.collection.createIndex({ fieldName: 1 }).
• Proiezioni: Recupera solo i dati di cui hai bisogno. L'uso delle proiezioni ({ field: 1 }) riduce la larghezza di banda di rete e l'utilizzo della memoria.
• Operazioni Batch: Quando inserisci, aggiorni o elimini molti documenti, usa insertMany(), updateMany() e deleteMany() invece di operazioni individuali per ridurre il sovraccarico.
• Comprendi gli Operatori: Familiarizza con il ricco set di operatori di query e aggiornamento di MongoDB. Offrono modi potenti per manipolare i tuoi dati.
• Gestione degli Errori: In un'applicazione di produzione, implementa sempre una robusta gestione degli errori per le tue operazioni sul database.
• Progettazione dello Schema: Sebbene MongoDB sia senza schema, una progettazione attenta dello schema è cruciale per query efficienti e coerenza dei dati.

Un Modo Più Sicuro per Praticare le CRUD in un Database Reale

La parte pericolosa delle CRUD di MongoDB non è la sintassi. È eseguire un filtro troppo ampio nel database sbagliato, specialmente con updateMany() o deleteMany(). Mi piace usare un'abitudine in tre passaggi per qualsiasi scrittura che tocchi dati esistenti.

Primo, esegui il filtro come lettura:

db.users.find(
  { city: "New York", status: "inactive" },
  { name: 1, email: 1, city: 1, status: 1 }
).limit(20);

Se l'anteprima restituisce documenti che non ti aspettavi, fermati qui. Correggi il filtro prima di pensare all'aggiornamento. Se non restituisce nulla, assicurati di essere nel database giusto con db.getName() e che i nomi dei campi corrispondano ai documenti effettivi.

Secondo, conta i documenti corrispondenti:

db.users.countDocuments({ city: "New York", status: "inactive" });

Questo ti dà un'idea approssimativa del raggio d'azione. Se ti aspettavi 12 utenti e il conteggio dice 12.000, il comando ti sta dicendo che qualcosa non va. Un conteggio non sostituisce un backup, ma è un guardrail economico.

Terzo, esegui la scrittura con il comando più ristretto che si adatta al lavoro. Usa updateOne() quando un'email univoca, un ID account o _id dovrebbe corrispondere a un documento. Usa updateMany() solo quando la modifica di un intero segmento è intenzionale.

db.users.updateMany(
  { city: "New York", status: "inactive" },
  {
    $set: {
      marketingEmailEnabled: false,
      updatedBy: "ops-maintenance-2025-11-04"
    }
  }
);

Aggiungere un updatedBy, updatedAt o una nota di manutenzione non è richiesto da MongoDB, ma aiuta in seguito quando qualcuno chiede perché un campo è cambiato.

Errori Comuni che Causano Veri Bug

Il primo errore è sostituire un documento quando intendevi aggiornare un campo. Questo comando sembra innocuo, ma sostituisce l'intero documento corrispondente con solo i campi mostrati:

db.users.updateOne(
  { email: "[email protected]" },
  { city: "Boston" }
);

MongoDB moderno si aspetta operatori di aggiornamento per i documenti di aggiornamento a meno che tu non stia usando metodi di sostituzione, quindi questo modello potrebbe fallire a seconda del comando e della versione. Il modello mentale più sicuro è semplice: se stai modificando campi sul posto, usa $set, $unset, $inc, $push, $pull o un altro operatore di aggiornamento.

db.users.updateOne(
  { email: "[email protected]" },
  { $set: { city: "Boston" } }
);

Il secondo errore è interrogare gli array come se l'ordine contasse sempre. { interests: ["reading", "hiking"] } corrisponde esattamente a un array. { interests: "reading" } corrisponde a documenti in cui l'array contiene quel valore. { interests: { $all: ["reading", "hiking"] } } corrisponde ad array che contengono entrambi i valori, indipendentemente dall'ordine. Sono tre domande diverse.

Il terzo errore è presumere che findOne() restituisca "quello giusto" quando il filtro non è univoco. Se esegui:

db.users.findOne({ city: "New York" });

MongoDB restituisce un documento corrispondente, ma senza un ordinamento non dovresti trattare quel documento come il più recente, il più vecchio, il più importante o il più rappresentativo. Se l'ordine è importante, dillo:

db.users.find({ city: "New York" }).sort({ createdAt: -1 }).limit(1);

Il quarto errore è saltare gli indici finché l'app non è già lenta. Una collezione con poche migliaia di documenti può nascondere una query inefficiente. La stessa query può diventare dolorosa quando la collezione cresce. Se l'applicazione trova frequentemente utenti per email, crea un indice univoco quando il modello dati lo consente:

db.users.createIndex({ email: 1 }, { unique: true });

Questo protegge sia le prestazioni che la qualità dei dati. Se esistono già email duplicate, il comando fallirà, che è esattamente il tipo di problema che vuoi scoprire prima di fare affidamento sull'email come identificatore.

Verificare Cosa Ha Effettivamente Fatto una Scrittura

I risultati delle scritture di MongoDB meritano di essere letti. Dopo un aggiornamento, guarda matchedCount e modifiedCount. matchedCount ti dice quanti documenti hanno corrisposto al filtro. modifiedCount ti dice quanti sono stati effettivamente modificati.

Se matchedCount è 1 e modifiedCount è 0, il comando potrebbe comunque andare bene. Forse il campo aveva già il valore richiesto. Se matchedCount è 0, il tuo filtro non ha corrisposto a nulla. Questo è comune quando un _id viene passato come stringa invece che come ObjectId.

db.users.findOne({ _id: ObjectId("6650f1e59d0a41a37c2d8011") });

Per le eliminazioni, controlla deletedCount. Se ti aspettavi un documento eliminato e il risultato dice deletedCount: 0, non eseguire immediatamente un'eliminazione più ampia. Ricontrolla il database, la collezione e il filtro.

Quando le CRUD Non Bastano

I comandi CRUD di base coprono la maggior parte del lavoro quotidiano con i dati, ma alcune attività necessitano di strumenti più potenti. Se stai aggiornando più collezioni che devono rimanere coerenti insieme, guarda le transazioni su set di repliche o cluster condivisi. Se stai rimodellando i dati attraverso molti documenti, una pipeline di aggregazione potrebbe essere più chiara di una lunga serie di cicli lato client. Se stai migrando dati di produzione, usa uno script con logging, modalità dry-run, backup e un piano di rollback.

Per operazioni una tantum in mongosh, mantieni i comandi leggibili. Una riga di comando intelligente è più difficile da rivedere e da cui recuperare. In produzione, i comandi noiosi sono solitamente migliori.

I comandi CRUD di MongoDB sono semplici una volta che ti abitui a documenti, filtri e operatori di aggiornamento. L'abilità che conta nel lavoro reale è essere deliberati: visualizza in anteprima il filtro, conta l'impatto, scegli il comando di scrittura più ristretto, leggi il risultato e lascia abbastanza contesto affinché la prossima persona possa capire cosa è cambiato.