La shell e le operazioni CRUD

Dopo aver avviato il nostro server MongoDB (mongod) e la shell (mongo), possiamo utilizzare quest’ultima per interagire attivamente con
il nostro database. Come abbiamo già visto, MongoDB memorizza i documenti in collezioni (collection). Non dobbiamo pensare alle collezioni come se fossero tabelle di un database relazionale:
infatti, i documenti di una stessa collezione potrebbero avere strutture diverse, nonostante essi condividano gli stessi indici.

Un database, invece, è un insieme di collezioni che corrisponde ad un insieme di file nel disco fisso. Un’istanza di MongoDB può gestire più database. Di seguito mostreremo brevemente come utilizzare la shell per effettuare le operazioni CRUD (Create, Read, Update, Delete).

Inserimento di documenti nel database

Dopo aver aperto la shell, selezionamo il database da usare:

[code]
use html_it
[/code]

MongoDB risponderà con il messaggio switched to db html_it. In realtà non abbiamo ancora creato alcun database con nome html_it; esso
verrà generato al momento del suo primo effettivo utilizzo. Su MongoDB, infatti, non esiste alcun comando esplicito per creare un
database. Possiamo però sapere quali database sono stati effettivamente creati, utilizzando il comando <code>show databases</code>.

Anche le collezioni vengono create implicitamente al primo utilizzo, quindi non è necessario farlo con un comando specifico. È sufficiente passare
direttamente alla creazione di un documento:

db.websites.insert({ name: "homepage", url: "http://www.html.it", tags: ["Development", "Design", "System"]});

La risposta del server sarà la seguente:

WriteResult({ "nInserted" : 1 })

Ciò significa che l’inserimento ha avuto successo. A questo punto avremo una nuova collezione (websites), contenente un solo documento avente tre campi: name, url e un campo a valori multipli: tags. Per verificarlo possiamo usare innanzitutto il comando show collections, che ci elencherà le collezioni presenti nel database corrente. Quindi, per interrogare tutti i documenti presenti nella collezione, digitiamo quanto segue:

db.website.find()

In questo caso il server risponderà così:

{
   "_id" : ObjectId("5450e468efaef47248f4412c"),
   "name" : "homepage",
   "url" : "http://www.html.it",
   "tags" : [ "Development", "Design", "System" ]
}

Deduciamo che MongoDB ha aggiunto un nuovo campo al nostro documento, chiamato _id. Questo campo identifica univocamente ogni documento ed è obbligatorio, oltre ad essere unico nell’intera collezione. Se non assegniamo noi un valore a _id (come abbiamo fatto in questo caso), MongoDB genera un ObjectId e lo assegna. Un ObjectId è un numero pseudocasuale
che ha un tasso di collisione infinitesimo (è cioè molto difficile generarne due uguali). Si noti anche che la sintassi di ObjectId non rientra nello
standard JSON. Ciò perché in realtà MongoDB usa una sua estensione, chiamata BSON (Binary JSON).

Naturalmente possiamo associare noi stessi un _id ad un documento, se esiste un valore che lo identifica univocamente. Per esempio possiamo usare
il codice fiscale nel caso di un database contenete dati anagrafici di cittadini, mentre nel nostro esempio avremmo potuto usare la URL:

db.websites.insert({ name: "homepage", _id: "http://www.html.it", tags: ["Development", "Design", "System"]});

È bene però tenere a mente che se proviamo ad inserire due documenti con lo stesso ­_id nella medesima collezione, MongoDB restituirà un errore e l’inserimento non andrà a buon fine.
Possiamo verificarlo eseguendo due volte l’ultimo comando.

Vedremo altri esempi e studieremo più in dettaglio il comando insert e le altre operazioni per modificare il database nella lezione 5.

Interrogazioni

Abbiamo visto come interrogare tutti i documenti presenti in una collezione. Il metodo find permette anche di eseguire interrogazioni
complesse (query), includendo anche alcuni parametri di filtraggio dei risultati. La seguente query seleziona tutti i
documenti che includono il tag “Development” all’interno del campo tags:

db.websites.find({ tags: "Development" })

È da notare il fatto che non abbiamo dovuto usare alcune sintassi per specificare che stavamo cercando all’interno di un array. MongoDB,
infatti, non fa distinzione tra la ricerca in una stringa o in un array di stringhe. Di conseguenza, anche il seguente documento sarebbe stato mostrato tra
i risultati della precedente query.

db.websites.insert({ name: "Development – Html.it", _id: "https://www.html.it/development/", tags: "Development", clicks: 2011 });

Se vogliamo effettuare una proiezione, ovvero se non ci interessano interi documenti ma solamente alcuni campi, la sintassi del metodo find prevede un ulteriore parametro:

db.websites.find(  { name: /Dev/ }, { _id: 1, clicks: 1 } )

Questa interrogazione cerca i documenti che contengono nel campo name la stringa “Dev”. Per ogni documento trovato, sarà restituito un nuovo documento contenente solo i campi _id e click, riducendo di fatto la quantità di dati da gestire. Allo stesso scopo si può introdurre un limite al numero di documenti restituiti:

db.websites.find(  { clicks: { $lt: 5000 } }, { _id: 1, clicks: 1 } ).limit(10)

In quest’ultimo caso possiamo osservare un filtraggio per confronto: il campo clicks di ogni documento viene confrontato con il
valore 5000, e solo quelli con valore numerico inferiore saranno selezionati (lt sta infatti per lesser than). Altri operatori
tipici sono:

• $gt
  (maggiore);
• $ne
  (non uguale a);
• $in
  (ricerca di un valore all’interno di un array).

MongoDB supporta una ricca lista di operatori, che tratteremo più in dettaglio nella lezione 6. Per chi volesse saperne di più, maggiori dettagli
sono disponibili sulla documentazione ufficiale.

Aggiornamenti

L’aggiornamento dei documenti avviene tramite il metodo update. Vediamo subito un esempio:

db.websites.update( { name: "homepage"}, { $set : { clicks: 5403 } }, {multi: true} )

Questo comando modificherà i documenti che hanno il campo name impostato a homepage. Il server risponderà con un documento che indica
quanti documenti sono stati modificati. Il primo parametro (come nel metodo find) indica i criteri di selezione degli elementi
modificati. Il parametro multi indica che potranno essere aggiornati anche più di un documento; senza specificare quest’ultima opzione, di default
MongoDB ne aggiornerà solamente uno.

Eliminazioni

L’eliminazione di un documento dalla collezione viene effettuata per mezzo del metodo remove. Il primo parametro rappresenta, anche qui, il criterio di selezione dei documenti da eliminare:

db.websites.remove( { name: "homepage"})

Il server restituisce un documento che indica quanti documenti sono stati eliminati. Un caso particolare è quello relativo all’eliminazione di tutti i documenti della collezione; in questo caso bisogna che il primo parametro sia specificato, e coincida esplicitamente con un documento vuoto:

db.websites.remove( {} )