• seguici su feed rss
  • seguici su twitter
  • seguici su linkedin
  • seguici su facebook
  • cerca

SEI GIA' REGISTRATO? EFFETTUA ADESSO IL LOGIN.



ricordami per 365 giorni

HAI DIMENTICATO LA PASSWORD? CLICCA QUI

NON SEI ANCORA REGISTRATO ? CLICCA QUI E REGISTRATI !

MongoDB: installazione in Windows e primo utilizzo della shell

di :: 21 ottobre 2020
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.

MongoDB: installazione in Windows e primo utilizzo della shell

Scaricato l'eseguibile, apriamolo e lanciamo l'installazione.

MongoDB: installazione in Windows e primo utilizzo della shell

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\data

e la cartella destinata ai file di log

C:\Program Files\MongoDB\Server\4.4\log

Al 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\bin

Questa 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

  1. Copiamo il percorso della cartella bin, cioè "C:\Program Files\MongoDB\Server\4.4\bin"
  2. Andiamo su "pannello di controllo > sistema e sicurezza > sistema", clicchiamo su "impostazioni di sistema avanzate"
  3. 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"
  4. 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 --version

Se 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 --nodb

La 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

mongo

Verrà 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 12345

In 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 demo

Anche 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.000GB

Possiamo 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 = 1992

Se 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 shell

Tra 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!

Potrebbe interessarti

Photo gallery

yum install mongodb-org

Approfondimenti

 
pay per script

Hai bisogno di uno script PHP personalizzato, di una particolare configurazione su Linux, di una gestione dei tuoi server Linux, o di una consulenza per il tuo progetto?

 
 
 
x

ATTENZIONE