MongoDB: installazione in Windows e primo utilizzo della shell
In un precedente articolo, che ti invito a leggere, abbiamo già fatto la conoscenza di MongoDB, un database di tipo NoSQL, di come si differenzia rispetto ai classici database relazionali, come ad esempio MySQL, e di come installarlo in una distribuzione Linux.
A grande richiesta, oggi vediamo come installare MongoDB "Community Edition", attualmente alla versione 4.4, in Windows.
Installazione di MongoDB in Windows 10
Accediamo al sito Mongo, alla sezione "Sofware > Community server", dove possiamo affettuare il suo download. In questo momento la versione disponibile è la 4.4.1, selezioniamo Windows come sistema operativo, e lanciamo il download.
Scaricato l'eseguibile, apriamolo e lanciamo l'installazione.
Clicchiamo su Next, e proseguiamo fino alla fine lasciando le impostazioni di default.
Durante l'installazione verrà indicata la cartella in cui verranno salvati i dati
C:\Program Files\MongoDB\Server\4.4\datae la cartella destinata ai file di log
C:\Program Files\MongoDB\Server\4.4\logAl termine verrà riavviato Windows.
Nota: durante l'installazione viene anche installato "MongoDB Compass" che è una interfaccia grafica che vi lascio studiare in quanto noi vederemo come utilizzare Mongo da shell cioè da linea di comando.
Dopo il riavvia andiamo nella cartella "C:\Program Files\MongoDB\Server\4.4" dove saranno state create la cartella "data", la cartella "log" e la cartella "bin"
C:\Program Files\MongoDB\Server\4.4\binQuesta cartella "bin"conterrà alcuni eseguibili di Mongo, e quelli che useremo più spesso sono
- mongod.exe: è il server di Mongo
- mongo.exe: è il client di Mongo, cioè la shell amministrativa
Prima di utillizzare la shell "mongo", dobbiamo effettuare questa operazione
- Copiamo il percorso della cartella bin, cioè "C:\Program Files\MongoDB\Server\4.4\bin"
- Andiamo su "pannello di controllo > sistema e sicurezza > sistema", clicchiamo su "impostazioni di sistema avanzate"
- Si aprirà un pannello e nel tab "avanzate" clicchiamo su "variabili d'ambiente", e nel riquadro "variabili di sistema" cerca la variabile "Path" e dopo averla selezionata clicca sul pulsante "Modifica"
- Aggiungi, cliccando su "Nuovo", il percorso copiato. Salva cliccando su OK ed esci dal pannello
Questa operazione ci semplifica la vita perchè potremmo utilizzare la shell "mongo" sarà dovere prima accedere al percorso alla cartella bin.
A questo punto, apri un terminale, ad esempio il "Prompt dei comandi" o la "PowerShell", e digita
mongo --versionSe tutto è andato a buon fine vedrai la versione di Mongo installata, nel nostro caso la 4.4.1
MongoDB shell version v4.4.1
Build Info: {
"version": "4.4.1",
"gitVersion": "ad91a93a5a31e175f5cbf8c69561e788bbc55ce1",
"modules": [],
"allocator": "tcmalloc",
"environment": {
"distmod": "windows",
"distarch": "x86_64",
"target_arch": "x86_64"
}
}Proviamo ad usare la shell, senza collegarci al database, utilizzando il comando
mongo --nodbLa shell si avvia e resta in attesa di istruzioni
MongoDB shell version v4.4.1
>Vediamo una piccola istruzione. Essendo un interprete javascript possiamo indicare una istruzione javascript, per cui creriamo una variabile "nome", e la stampiamo a video.
MongoDB shell version v4.4.1
> var nome ="giulio";
> print (nome);
giulio
>Usciamo dalla shell utlizzando il comando quit() o con exit
> quit()Vediamo adesso come utilizzare effettivamente un database.
Come prima attività, dobbiamo avviare il server utilizzando il comando mongod seguito dal percorso alla cartella dove vogliamo salvare i dati (raggruppate il percorso tra virgolette se ci sono spazi nel percorso)
mongod --dbpath "C:\Program Files\MongoDB\Server\4.4\data"Abbiamo indicato il path che Mongo ha previsto di default, ma potevamo creare una cartella ovunque nel nostro PC ed indicare il percorso di questa cartella. Attenzione perchè se non indichi il path non viene inserito, come potremmo aspettarci, il path di default, ma il path "C:\data\db".
Lanciando mongod si avvia il server, che resta in ascolto nella porta 27017, come possiamo vedere spulciando i log che appaiono nel terminale... e se buttate un occhio nella cartella "data" vedrete che si sono creati vari files.
Non dovete chiudere mai questo termale, pena la caduta della connessione, oppure dovete utilizzare, ma normalmente lo si fa in produzione, l'opzione --fork che mantiene il processo aperto anche dopo aver chiuso la finestra.
Quindi, mantenendo aperto questo terminale, ne apriamo uno nuovo nuovo e qui apriamo la shell digitando
mongoVerrà effettuata la connessione al db, installato in locale (127.0.0.1), cioè sullo stesso server in cui il client si trova), e al database di default che si chiama "test", e resterà in attesa di istruzioni
MongoDB shell version v4.4.1
connecting to: mongodb://127.0.0.1:27017/?compressors=disabled&gssapiServiceName=mongodb
Implicit session: session { "id" : UUID("55271f54-bb8a-451f-9918-961ee5b859e3") }
MongoDB server version: 4.4.1
Welcome to the MongoDB shell.
For interactive help, type "help".
For more comprehensive documentation, see
https://docs.mongodb.com/
Questions? Try the MongoDB Developer Community Forums
https://community.mongodb.com
---
The server generated these startup warnings when booting:
2020-10-14T11:57:42.068+02:00: ***** SERVER RESTARTED *****
2020-10-14T11:57:44.499+02:00: Access control is not enabled for the database. Read and write access to data and configuration is unrestricted
---
---
Enable MongoDB's free cloud-based monitoring service, which will then receive and display
metrics about your deployment (disk utilization, CPU, operation statistics, etc).
The monitoring data will be available on a MongoDB website with a unique URL accessible to you
and anyone you share the URL with. MongoDB may use this information to make product
improvements and to suggest MongoDB products and deployment options to you.
To enable free monitoring, run the following command: db.enableFreeMonitoring()
To permanently disable this reminder, run the following command: db.disableFreeMonitoring()
---
>Possiamo uscire dalla shell, con quit().
Opzioni di avvio del server
All'avvio del server abbiamo inserito come parametro il path alla cartella dati con l'opzione "--dbpath".
Esistono tuttavia altre opzioni che possiamo utilizzare, come quelle che adesso vediamo.
L'opzione "--logfile" che consente di indicare un path ai log diverso rispetto a quello previsto di default
L'opzione "--port" che avviare il server su una porta diversa da quella di default
L'opzione "--fork" consente di mantenere il processo attivo anche se il terminale viene chiuso... tuttavia non è utilizzabile in Windows quindi se lo inserite riceverete un errore
Mettendo assieme queste opzioni, possiamo avviare il server Mongo così
mongod --dbpath "C:\Users\mario\Desktop\test" --logfile "C:\Users\mario\Desktop\log" --port 12345In Windows, c'è un modo per aggirare la mancanza di "fork".
- apri il pannello "gestione attività" di Windows (CTRL + ALT + CANC)
- vai sul tab "Servizi"
- cerca il servizio MongoDB
- con il pulsante destro del mouse clicca su "Avvia".
Il server viene avviato (con i parametri di default tra cui il path dati "C:\Program Files\MongoDB\Server\4.4\data") e adesso puoi utilizzare la shell. Ricorda tuttavia di spegnere il server quando avrai finito i tuoi test.
Per tutte le altre opzioni si rimanda alla documentazione, con link posto a fondo articolo.
Primi comandi da shell
Con il server avviato, apriamo un secondo terminale e proviamo i primi comandi con la shell di Mongo, che varranno per tutti i sistemi operativi.
RIcorda di tenere aperto il primo terminale, altrimenti la shell perderebbe la connessione al server.
Apriamo la shell digitando mongo e così saremmo connessi al database di default test, e la shell resterà in attesa di istruzioni.
Per sapere a quale database siamo connessi digitiamo "db" e la shell risponderà con "test"
> db
test
Se avessi più database, per sportarmi da un database all'altro, devo utilizzare "use" seguito dal nome del database
Ad esempio ci sposiamo sul database "demo"... che non esiste
> use demo
switched to db demoAnche se non esiste ancora, così come non esiste il database "test", stiamo usando questo database: questo database verrà effettivamente creato sono nel momento in cui lo andremo ad utilizzare attraverso la creazione di collections (tabelle) e documenti (records).
Proviamo ad utilizzare questo database, utilizzando questo comando
> db.giocatori.find()db: è un oggetto all'interno della nostra shell ed identifica il database in uso, nel nostro caso "demo"
giocatori: è una collection, che ancora non esiste (una tabella)
find(): è il comando che equivale ad una SELECT per estrarre i dati
Possiamo leggerlo così "vai a prendere il database in uso, cioè demo, considera la collection giocatori, e cerca tutti i documenti che ci sono al suo interno"
Lanciando questo comando non succede nulla perchè non abbiamo ancora salvato documenti (records) nella nostra collection (tabella).
Proviamo a creare il primo documento nella collection giocatori, con il comando insert.
Inseriamo il giocatore "ronaldo" con tutti campi che avevamo previsto all'inizio della nostra spiegazione, quindi il nome, l'età, e le competizione vinte, indicate in un array (parentesi quadre!)
> db.giocatori.insert(
{
"nome":"ronaldo",
"eta": 34,
"vittorie": [
{"anno":"2002", "competizione":"Supercoppa portoghese"},
{"anno":"2003", "competizione":"Coppa d'Inghilterra"},
{"anno":"2019", "competizione":"Serie A"},
]
}
)Il risultato sarà il seguente
WriteResult({ "nInserted" : 1 })
>Il documento (record) è stato inserito e il database creato.
Per conoscere la lista dei database presenti utilizziamo il comando "show dbs"
> show dbs
admin 0.000GB
config 0.000GB
demo 0.000GB
local 0.000GBPossiamo vedere il nostro database "demo" ed altri database di sistema già presenti.
Adesso che il database "demo" è creato, con la collection "giocatori", ed al suo interno abbiamo un documento, riproviamo con il comando "find" e verrà visualizzato il nostro documento
> db.giocatori.find()
{ "_id" : ObjectId("5f86e7adb8927708451222bb"), "nome" : "ronaldo", "eta" : 34, "vittorie" : [ { "anno" : "2002", "competizione" : "Supercoppa portoghese" }, { "anno" : "2003", "competizione" : "Coppa d'Inghilterra" }, { "anno" : "2019", "competizione" : "Serie A" } ] }
>Possiamo vedere che, assieme a tutti i campi che abbiamo creato, ne è stato aggiunto uno chiamato "_id": è un attributo speciale, di tipo "ObjectId": è un indice e deve essere sempre presente ed in sua assenza viene creato in automatico da Mongo.
Creiamo un secondo documento
> db.giocatori.insert(
{
"nome":"ibrahimovic",
"eta": 38,
"vittorie": [
{"anno":"2007", "competizione":"Serie A"},
{"anno":"2009", "competizione":"Supercoppa UEFA"},
{"anno":"2017", "competizione":"Europa League"}
]
}
)Ripetiamo la ricerca
{ "_id" : ObjectId("5f86e7adb8927708451222bb"), "nome" : "ronaldo", "eta" : 34, "vittorie" : [ { "anno" : "2002", "competizione" : "Supercoppa portoghese" }, { "anno" : "2003", "competizione" : "Coppa d'Inghilterra" }, { "anno" : "2019", "competizione" : "Serie A" } ] }
{ "_id" : ObjectId("5f86e98bb8927708451222bc"), "nome" : "ibrahimovic", "eta" : 38, "vittorie" : [ { "anno" : "2007", "competizione" : "Serie A" }, { "anno" : "2009", "competizione" : "Supercoppa UEFA" }, { "anno" : "2017", "competizione" : "Europa League" } ] }Adesso che abbiamo due documenti possiamo effettuare una ricerca più approfondita.
Nel find, infatti, possiamo mettere delle condizioni json: ad esempio vogliamo sapere quali sono i giocatori che hanno 34 anni, per cui cerchiamo nella chiave "eta" il valore "34".
> db.giocatori.find( {"eta":34} )Il risultato sarà
{ "_id" : ObjectId("5f86e7adb8927708451222bb"), "nome" : "ronaldo", "eta" : 34, "vittorie" : [ { "anno" : "2002", "competizione" : "Supercoppa portoghese" }, { "anno" : "2003", "competizione" : "Coppa d'Inghilterra" }, { "anno" : "2019", "competizione" : "Serie A" } ] }Per leggere meglio la risposta aggiungiamo .pretty() dopo il .find()
> db.giocatori.find( {"eta":34} ).pretty()La risposta sarà formattata in questo modo
{
"_id" : ObjectId("5f86e7adb8927708451222bb"),
"nome" : "ronaldo",
"eta" : 34,
"vittorie" : [
{
"anno" : "2002",
"competizione" : "Supercoppa portoghese"
},
{
"anno" : "2003",
"competizione" : "Coppa d'Inghilterra"
},
{
"anno" : "2019",
"competizione" : "Serie A"
}
]
}Se avessimo avuto più match ovviamente sarebbero stati estratti tutti i documenti.
Per estrarre invece un solo documento utilizziamo, findOne, al posto di find. Con findOne non puoi usare pretty... ma otterrai comunque il risultato ben formattato.
> db.giocatori.findOne( {"eta":34} )Vediamo adesso come aggiungere un campo.
Iniziamo con il cercare il documento con ObjectId("5f86e7adb8927708451222bb").
> db.giocatori.findOne( {"_id" : ObjectId("5f86e7adb8927708451222bb")} )Essendo la shell un interprete javascript, creiamo una variabile x con valore questa estrazione
> var x = db.giocatori.findOne( {"_id" : ObjectId("5f86e7adb8927708451222bb")} )Nella variabile x abbiamo il nostro documento, infatti se digitiamo x avremo:
> x
{
"_id" : ObjectId("5f86e7adb8927708451222bb"),
"nome" : "ronaldo",
"eta" : 34,
"vittorie" : [
{
"anno" : "2002",
"competizione" : "Supercoppa portoghese"
},
{
"anno" : "2003",
"competizione" : "Coppa d'Inghilterra"
},
{
"anno" : "2019",
"competizione" : "Serie A"
}
]
}Adesso che x è il nostro documento (è un oggetto di tipo json) possiamo modificarlo ed aggiungere degli attributi, ad esempio aggiungiamo la chiave "anno di nascita", in questo modo
> x.year = 1992Se adesso visualizzi il docmento vedrai che è stata aggiunta la coppia chiave / valore
> x
{
"_id" : ObjectId("5f86e7adb8927708451222bb"),
"nome" : "ronaldo",
"eta" : 34,
"vittorie" : [
{
"anno" : "2002",
"competizione" : "Supercoppa portoghese"
},
{
"anno" : "2003",
"competizione" : "Coppa d'Inghilterra"
},
{
"anno" : "2019",
"competizione" : "Serie A"
}
],
"year" : 1992
}Questa modifica non è ancora stata effettivamente salvata nel database. Per salvarla utilizziamo la funzione save().
> db.giocatori.save(x)
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })La funzione save() in realtà non viene molto usata, è una sorta di scorciatoia sia per l'update che per l'insert, che vedremo in un secondo momento.
Se provi a digitare db.giocatori.save, senza argomenti, la shell ti mostrerà il codice della funzione con cui viene eseguito l'insert o l'update
> db.giocatori.save
function(obj, opts) {
if (obj == null)
throw Error("can't save a null");
if (typeof (obj) == "number" || typeof (obj) == "string")
throw Error("can't save a number or string");
if (typeof (obj._id) == "undefined") {
obj._id = new ObjectId();
return this.insert(obj, opts);
} else {
return this.update({_id: obj._id}, obj, Object.merge({upsert: true}, opts));
}
}Questa funzione verifica se l'oggetto json (la variabile x) possiede o meno l'attributo "_id": se lo possiede fa un update, in caso contrario fa una insert.
Per conoscere tutti i comandi disponibili, digita "help"
> help
db.help() help on db methods
db.mycoll.help() help on collection methods
sh.help() sharding helpers
rs.help() replica set helpers
help admin administrative help
help connect connecting to a db help
help keys key shortcuts
help misc misc things to know
help mr mapreduce
show dbs show database names
show collections show collections in current database
show users show users in current database
show profile show most recent system.profile entries with time >= 1ms
show logs show the accessible logger names
show log [name] prints out the last segment of log in memory, 'global' is default
use <db_name> set current database
db.mycoll.find() list objects in collection mycoll
db.mycoll.find( { a : 1 } ) list objects in mycoll where a == 1
it result of the last line evaluated; use to further iterate
DBQuery.shellBatchSize = x set default number of items to display on shell
exit quit the mongo shellTra questi comandi per adesso menzioniamo "show" che serve mostrare delle liste, ad esempio
- show dbs: mostra i nomi dei database, come abbiamo visto in precedenza
- show collections: mostra le collezioni del database in uso
Nei prossimi articoli vedremo MongoDB come esguire un CRUD completo (create, read, update, delete).
Stay tuned!
Photo gallery
