MongoDB find(): guida completa per principianti alle query sui dati

MongoDB è un popolare database NoSQL progettato per flessibilità e prestazioni. A differenza dei database relazionali tradizionali, che usano tabelle strutturate e SQL, MongoDB archivia i dati in documenti flessibili simili a JSON. Questo lo rende ideale per gli sviluppatori che lavorano con dati dinamici o semi-strutturati.

Una delle operazioni più importanti che eseguirai in MongoDB è la creazione di query sui dati, e il metodo più usato per farlo è find(). Che tu stia iniziando ora o voglia migliorare le tue abilità di interrogazione, capire come funziona find() è essenziale per navigare e manipolare efficacemente i dati in MongoDB.

Immagina di esplorare un database di film. Vuoi trovare tutti i film di fantascienza usciti dopo il 2000, oppure elencare tutti i commenti degli utenti fatti in un determinato intervallo di tempo. È qui che find() dà il meglio.

In questo articolo imparerai a usare il metodo find() per recuperare documenti da una collezione, applicare filtri, proiettare campi, ordinare i risultati e ottimizzare le prestazioni, il tutto lavorando con il dataset sample_mflix.

Per un percorso pratico sull'uso di MongoDB nei workflow di data science, dai un'occhiata al corso Introduction to MongoDB in Python.

Introduzione a find() in MongoDB

Il metodo find() è il modo principale in cui MongoDB recupera documenti da una collezione. Restituisce un cursore sui documenti che corrispondono alla query specificata. Puoi quindi iterare su questo cursore o convertirlo in un array, a seconda delle esigenze della tua applicazione.

Ecco la sintassi completa:

db.collection.find(<query>, <projection>, <options>)

Parametri

• query (opzionale): un documento che definisce i criteri per selezionare i documenti. Se ometti questo parametro o passi un documento vuoto ({}), find() restituirà tutti i documenti nella collezione.
• projection (opzionale): un documento che specifica quali campi restituire. Puoi includere (1) o escludere (0) campi. Per impostazione predefinita, MongoDB restituisce tutti i campi, incluso _id.
• options (opzionale): un documento aggiuntivo per configurare il comportamento della query. Puoi impostare elementi come ordine di ordinamento, limiti di paginazione, timeout e suggerimenti sugli indici.

Esempio

Per rendere i concetti il più chiari e applicabili possibile, useremo il dataset di esempio di MongoDB Atlas—in particolare il database sample_mflix. Questo dataset include collezioni come film, commenti, utenti e sale cinematografiche, che citeremo in tutto l'articolo per dimostrare ogni esempio.

db.books.find(
  { year: { $gte: 2000 } },              // query: books published in or after 2000
  { title: 1, author: 1, _id: 0 },        // projection: include only title and author
  { sort: { title: 1 }, limit: 5 }       // options: sort by title, return only 5 books
)

Questa query:

• Filtra i libri pubblicati nel 2000 o successivamente.
• Restituisce solo i campi titolo e autore (esclude _id).
• Ordina i risultati alfabeticamente per titolo (A-Z).
• Limita l'output ai primi cinque libri corrispondenti.

Figura 1. Questa query trova i film usciti dopo il 2000, ordinati per titolo e limitati a cinque risultati.

Il risultato è un cursore, che carica pigramente i documenti corrispondenti man mano che ci iteri sopra. Puoi usare .toArray() o .forEach() per elaborare i risultati.

Se sei connesso tramite la shell di MongoDB (mongosh) e non assegni il risultato a una variabile, per impostazione predefinita verranno mostrati solo i primi 20 documenti. Per visualizzare documenti aggiuntivi, digita it e premi Invio. Questo processo continuerà recuperando il batch successivo dal cursore.

> Nota: quanto sopra è un comportamento specifico della shell, non un limite di MongoDB. Nella maggior parte dei driver MongoDB (ad es. Node.js, Python, Java), chiamare .toArray() o iterare sul cursore recupera automaticamente tutti i risultati corrispondenti. Il comportamento del cursore può variare a seconda dell'ambiente e del linguaggio che stai usando.

Figura 2. Questa query recupera tutti i film, restituendo solo il campo _id e usando il cursore per ottenere risultati aggiuntivi.

Se sei alle prime armi con i database NoSQL, il corso Introduction to NoSQL offre i concetti di base che completano questo tutorial.

Scrivere le tue prime query

Proseguendo con l'esempio dei film, poniamo che tu voglia recuperare tutti i film del genere Sci-Fi. Ecco come farlo:

db.movies.find({ genres: "Sci-Fi" })

Ora vuoi solo i film usciti nel 2000 o successivamente:

db.movies.find({ year: { $gte: 2000 } })

E se li vuoi entrambi? Combina le condizioni:

db.movies.find({ genres: "Sci-Fi", year: { $gte: 2000 } })

In alternativa, puoi scriverlo esplicitamente usando $and:

db.movies.find({ $and: [ { genres: "Sci-Fi" }, { year: { $gte: 2000 } } ] })

Entrambe le query restituiscono lo stesso risultato—documenti con genere Sci-Fi e anno di uscita 2000 o successivo. La prima forma è più concisa ed è preferibile quando i campi sono diversi.

Figura 3. Modi diversi di scrivere la query che producono lo stesso risultato.

Usa find() come un imbuto di filtraggio—ogni condizione restringe i risultati.

Uso di operatori di confronto e logici

Ora rivediamo come usare gli operatori di confronto e logici per portare le tue query al livello successivo.

Operatori di confronto

• $eq, $ne: uguale, diverso
• $gt, $gte, $lt, $lte: maggiore/minore (o uguale)
• $in, $nin: presente o non presente in un array

Immagina di tracciare gli ordini dei clienti e voler gli ordini tra 100 $ e 500 $:

db.orders.find({ total: { $gte: 100, $lte: 500 } })

Operatori logici

• $and, $or, $nor, $not

Ora, immagina di voler mostrare i prodotti nella categoria "Books" oppure con prezzo inferiore a 20 $. Ecco un esempio di query:

db.products.find({ $or: [ { category: "Books" }, { price: { $lt: 20 } } ] })

Query su campi annidati

Puoi accedere ai campi annidati usando la dot notation:

db.customers.find({ "address.city": "Chicago" })

Proiettare i campi

La proiezione ti permette di restituire solo ciò che ti serve, il che può migliorare sensibilmente prestazioni e chiarezza.

db.movies.find({}, { directors: 1, languages: 1, _id: 0 })

Importante: quando specifichi una proiezione, MongoDB richiede di scegliere tra due modalità: includere campi specifici (1) oppure escludere campi specifici (0). Non puoi mescolare entrambi gli stili nella stessa proiezione, fatta eccezione per il campo _id, che può essere escluso anche quando altri campi sono inclusi.

✅ Valido (solo inclusione):

db.movies.find({}, { directors: 1, languages: 1 })

✅ Valido (solo esclusione):

db.movies.find({}, { directors: 0, _id: 0 })

❌ Non valido (mix di inclusione ed esclusione):

db.movies.find({}, { directors: 1, languages: 0 }) // Not allowed

L'unica eccezione è il campo _id, che puoi escludere anche quando includi altri campi:

db.movies.find({}, { directors: 1, _id: 0 }) // Allowed

Figura 4. Questo esempio mostra l'errore generato dal mix di inclusione ed esclusione di campi in un'unica proiezione, non consentito da MongoDB, tranne che per `_id`.

Ordinare, limitare e saltare risultati

Quando lavori con dataset di grandi dimensioni, è comune mostrare agli utenti solo una parte dei dati alla volta—una tecnica nota come paginazione. Ad esempio, un'app di streaming potrebbe mostrare 10 film per pagina invece di caricarne migliaia in una volta. Questo non solo migliora le prestazioni ma anche l'esperienza utente.

In MongoDB, la paginazione si ottiene combinando sort(), limit() e skip().

SQL vs. MongoDB: confronto di base

Se arrivi da un background SQL, ecco come si confrontano i concetti comuni di paginazione:

Query di base in SQL: 

SELECT * FROM movies WHERE year >= 2000

Lo stesso può essere espresso in MongoDB come segue:

db.movies.find({ year: { $gte: 2000 } })

Selezione di campi in SQL: 

SELECT title, year FROM movies

Selezione di campi in MongoDB: 

db.movies.find({}, { title: 1, year: 1, _id: 0 })

Ora vediamo qualche altro esempio di operazioni comuni sulle query:

Ordinamento:

• SQL: ORDER BY title ASC
• MongoDB: .sort({ title: 1 })

Limitazione:

• SQL: LIMIT 10
• MongoDB: .limit(10)

Salto:

• SQL: OFFSET 10
• MongoDB: .skip(10)

Capire questi parallelismi può aiutare gli utenti SQL a passare più facilmente al sistema di query basato su documenti di MongoDB.

Ordinare i risultati

L'ordinamento ti aiuta a organizzare i risultati in base a un campo specifico—ad esempio, per ordinare i film per titolo in ordine alfabetico:

db.movies.find().sort({ title: 1 }) // ascending (A–Z)

• 1 significa ordine crescente (A-Z, 0-9)
• -1 significa ordine decrescente (Z-A, 9-0)

Limitare i risultati

Restituisci solo un certo numero di risultati—ad esempio, i primi 10:

db.movies.find().limit(10)

Questo è utile quando implementi elenchi "Top 10" o viste iniziali.

Saltare i risultati

Usalo per saltare documenti. Spesso è usato insieme a limit() per la paginazione:

db.movies.find().skip(10).limit(10)

Questo salta i primi 10 documenti e restituisce i successivi 10, mostrando di fatto la Pagina 2 quando pageSize = 10.

Formula di paginazione:

skip = (pageNumber - 1) * pageSize

> Nota: usare skip() per paginazione profonda (ad es., skip(10000)) può essere inefficiente, perché MongoDB scansiona comunque e scarta i documenti saltati. Per prestazioni migliori con grandi dataset, valuta la paginazione basata su intervalli usando campi indicizzati come _id.

Esempio combinato: Pagina 3, 10 film per pagina, ordinati per titolo

db.movies.find()
  .sort({ title: 1 })
  .skip(20)
  .limit(10)

Questo schema è utile anche per funzionalità come "carica altro" o lo scroll infinito.

Figura 5. Questa query recupera la terza pagina di risultati (10 film per pagina), ordinata per titolo.

Lavorare con i cursori

Il metodo find() restituisce un cursore—un puntatore al set di risultati. Puoi iterarci sopra:

const cursor = db.movies.find({ type: "movie" });
cursor.forEach(doc => print(doc.name));

Oppure convertirlo in un array:

const results = db.collection.find().toArray();

Figura 6. Dopo aver chiamato `find()`, ricevi un cursore. Puoi usarlo per iterare sui documenti o convertire l'intero set di risultati in un array.

> Nota: l'oggetto cursore è disponibile in mongosh o nel codice tramite i driver (ad es., Node.js, Python). Gli strumenti GUI come MongoDB Compass gestiscono internamente i cursori. Non li accederai né ci itererai direttamente.

Opzioni avanzate del cursore

Per affinare le tue query, puoi usare metodi aggiuntivi del cursore:

db.users.find({ age: { $gte: 30 } })
  .sort({ name: 1 })
  .limit(10)
  .skip(5)
  .maxTimeMS(200)
  .hint({ age: 1 })

• maxTimeMS(ms): interrompe la query se impiega troppo tempo
• hint(): forza MongoDB a usare un indice specifico
• batchSize(n): controlla il numero di documenti per batch

Ti stai preparando ai colloqui? Esplora le 25 principali domande e risposte su MongoDB per mettere alla prova la tua comprensione di concetti chiave come find().

Indici e ottimizzazione delle prestazioni

Gli indici sono come scorciatoie—aiutano MongoDB a recuperare i documenti più velocemente.

Creare un indice

db.movies.createIndex({ type: 1 })

Usare .explain()

db.users.find({ type: "movie" }).explain()

Questo rivela se gli indici vengono usati e quanto è efficiente la tua query.

Senza un indice:

Figura 7. Esegui `explain()` sulla query prima dell'indicizzazione.

Creazione di un indice: 

Figura 8. Crea un indice semplice sul campo type.

Con un indice: 

Figura 9. Esegui la stessa query con `explain()`, ora usando un indice.

Puoi vedere che lo stage che prima era CollScan (scansione della collezione) è diventato Fetch + IXSCAN, ossia utilizza l'indice + cerca altri dati che non fanno parte dell'indice (dato che stiamo restituendo tutto).

Usare MongoDB Compass per visualizzare le query

Se preferisci strumenti visuali, MongoDB Compass è il client GUI ufficiale. Ti consente di:

• Costruire visivamente le query usando i filtri.
• Visualizzare in anteprima documenti e indici.
• Ottimizzare e convalidare le prestazioni delle query.

Puoi anche passare alla "vista JSON" per copiare/incollare le query nel tuo codice.

Usare Atlas + AI per generare query

Se usi MongoDB Atlas, puoi sfruttare Atlas Search con il generatore di query potenziato dall'AI.

Ti basta scrivere un prompt in linguaggio naturale come:

"Mostrami tutti i clienti del Brasile che hanno effettuato ordini superiori a 100 $ nell'ultimo mese."

Atlas suggerisce una query MongoDB corrispondente usando find() o $search. È un ottimo acceleratore di produttività, soprattutto quando non sei sicuro della sintassi.

Figura 10. Usa Compass per generare una query dal linguaggio naturale.

Errori comuni e come evitarli

• Query su campi non indicizzati → Portano a prestazioni lente
• Set di risultati molto grandi → Usa la paginazione (limit + skip)
• Proiezioni inefficienti → Proietta sempre solo i campi necessari
• Incongruenze di tipo → Assicurati che i tipi dei campi corrispondano (ad es., numero vs stringa)
• Mescolare inclusione ed esclusione nelle proiezioni → Non consentito, tranne per _id

Confrontare MongoDB find() con SQL

Se arrivi da un background SQL, capire come find() di MongoDB si confronta con le query SQL familiari può semplificare la transizione. Ecco un confronto generale delle operazioni comuni:

Come vedi, la sintassi di MongoDB è più simile a JavaScript ed espressiva in formato JSON, mentre SQL è più dichiarativo e strutturato. Conoscere questi parallelismi ti aiuterà a sentirti a tuo agio più rapidamente in MongoDB.

Riepilogo e best practice

• Pensa a find() come al tuo filtro sui dati—combina condizioni per risultati precisi.
• Proietta sempre solo i campi necessari per chiarezza e prestazioni.
• Usa gli indici per evitare scansioni lente.
• Usa Compass se preferisci un feedback visivo e iterazioni più rapide.
• Sfrutta l'assistente AI di MongoDB Atlas per generare query più velocemente.
• Esplora le opzioni avanzate del cursore per un controllo fine dei risultati.

Che tu stia costruendo una dashboard per startup, uno strumento di analisi dati o un back-end e-commerce, padroneggiare find() renderà la tua esperienza con MongoDB più fluida, veloce ed efficace.

Resta sintonizzato per altri approfondimenti su MongoDB nei prossimi articoli!

Vuoi convalidare le tue competenze su MongoDB? Leggi la guida completa alla certificazione MongoDB per esplorare le tue opzioni.