UNIVERSITÀ DEGLI STUDI DI MILANO
Dipartimento di Informatica

MongoDB e basi di dati NoSQL

Insegnamento di Analisi dei dati su larga scala
Anno accademico 2013/14

RDBMS più diffusi

Oracle
MySQL
PostgreSQL
SQLite
etc..

Welcome to NoSQL!

I più diffusi

MongoDB
CouchDB
Cassandra
Redis
e altri.

Un buon posto per valutare le differenze tra le varie soluzioni è questo post.

Perché?

Non sempre i dati seguono uno schema
Capacità di leggere strutture complesse individualmente
Scalabilità orizzontale su cluster (sharding)
Data analytics
Ridondanza
Flessibilità
- organizzazione dati su disco, informazioni che si possono memorizzare
- struttura dei dati modificabile facilmente

MongoDB

MongoDB (http://www.mongodb) è un sistema open source per la gesione di database NoSQL (document-oriented) sviluppato da 10gen (http://www.10gen.com/)

Storia

Lo sviluppo di MongoDB è iniziato nel 2007
A partire dalla versione 1.4 (marzo 2010) MongoDB è considerato pronto per essere messo in produzione
La versione stabile più recente è la 2.4.6, rilasciata a fine agosto 2013

Ma ha anche dei lati deboli

gli indici tendono a occupare parecchia RAM (sono B-alberi)
i database occupano di norma più spazio rispetto a un RDBMS
non è previsto supporto per le transazioni

Nei RDBMS classici...

un database aggrega delle tabelle
una tabella aggrega delle righe
una riga aggrega dei valori per attributi (fissi)
si eseguono operazioni di join tra tabelle
la struttura delle righe in una tabella è prefissata (schema)

Nei DB NoSQL...

un database aggrega delle tabelle collezioni
una tabella collezione aggrega delle righe dei documenti
una riga un documento aggrega dei valori per attributi (fissi) dei campi (variabili) indicati tramite coppie (nome, valore)
si eseguono non si possono eseguire (direttamente) operazioni di join tra tabelle
la struttura dei documenti in una collezione non è prefissata (schema)

In MongoDB

Invece di memorizzare l'informazione nelle righe di una tabella, MongoDB memorizza dati strutturati utilizzando un formato simile a JSON
JSON (JavaScript Object Notation, http://www.json.org) è un formato lightweight per lo scambio di dati, facile da leggere (per gli umani) e da analizzare (dalle macchine)

JSON: carte sintattiche

Un esempio

la tabella

Nome	Cognome	Targa
Paolino	Paperino	313
Topolino		113

diventa

   {
        "nome": "Paolino",
        "cognome": "Paperino",
        "targa": 313
    },
    {
        "nome": "Topolino",
        "targa": 113
    }

Per la precisione...

Il formato in cui effettivamente MongoDB memorizza l'informazione è BSON (Binary JSON, http://bsonspec.org/), che permette di

serializzare documenti JSON in modo efficiente
attraversare facilmente tali documenti
conservare la lightweightness

Documenti incorporati

È possibile inserire un documento all'interno di un campo BSON

{
    "nome": "Paolino",
    "cognome": "Paperino",
    "auto": {"modello": "American Bantam", "targa": 313}
}

Array

In BSON gli array sono oggetti di prima classe

{
    "nome": "Paolino",
    "cognome": "Paperino",
    "auto": {"modello": "American Bantam", "targa": 313},
    "familiari": ["qui", "quo", "qua"]
}

Componenti di MongoDB

mongod: server (per default sulla porta 20017)
mongo: shell Javascript
API: per Python, Java, Scala, Ruby, C, C++, ... (http://api.mongodb.org/)

Istruzioni per l'installazione a http://docs.mongodb.org/manual/installation/

Esecuzione

in un terminale lanciare il server

$ mongod
all output going to: /usr/local/var/log/mongodb/mongo.log

in un altro terminale lanciare la shell

$ mongo
MongoDB shell version: 2.4.1
connecting to: test
>

Per iniziare a capirci qualcosa può essere più semplice usare la shell online a http://www.mongodb.org

Prime operazioni con MongoDB

creazione di (o passagio a) un database
```
> use fumetti
switched to db fumetti
```

inserimento di un documento (e creazione di una collezione)

> db.personaggi.insert({nome: "Paolino", cognome: "Paperino",
... genere: 'M', auto: {modello: "American Bantam", targa: 313},
... anno_nascita: 1920, prima_apparizione: 1934})

la dimensione massima di un documento è pari a 16MByte
l'inserimento è possibile anche tramite upsert (vedi oltre)

Prime operazioni con MongoDB

lettura di una collezione

> db.personaggi.find()
{ "_id" : ObjectId("51618534b8810192ed114356"),
"nome" : "Paolino", "cognome" : "Paperino",
"auto" : { "modello" : "American Bantam", "targa" : 313 },
"anno_nascita" : 1920, "prima_apparizione" : 1934 }

lettura di un elemento in una collezione

> db.personaggi.findOne()
{
    "_id" : ObjectId("5161a459b356cd6125b74e7b"),
    "nome" : "Paolino",
    "cognome" : "Paperino",
    "genere" : "M",
    ...
}

Indici

Il campo _id contiene un valore generato automaticamente in termini di ObjectId

> ObjectId()
ObjectId("51618f81b8810192ed114357")
> ObjectId()
ObjectId("51618f83b8810192ed114358")
> ObjectId()
ObjectId("51618f84b8810192ed114359")

MongoDB indicizza automaticamente i documenti inseriti in una collezione

Popoliamo una collezione

> db.personaggi.insert({nome: "nonna papera", genere: 'F',
... "auto": {modello: "Detroit Electric"}, anno_nascita: 1833,
... prima_apparizione: 1943, passatempi: ['cucina', 'agricoltura']})
> db.personaggi.insert({nome: "Paperon", cognome: "De Paperoni",
... genere: 'M' anno_nascita: 1867, prima_apparizione: 1947,
... passatempi: ['alta finanza', 'risparmio',
... 'nuoto in depositi aurei']})
> db.personaggi.insert({nome: "Archimede", cognome: "Pitagorico",
... genere: 'M', prima_apparizione: 1952, passatempi: ['invenzioni',
... 'studio']})
> db.personaggi.insert({nome: "Pico", cognome: "De Paperis",
... genere: 'M', prima_apparizione: 1961, passatempi: ['studio']})

Selettori semplici

in base a esistenza di campi

> db.personaggi.find({auto: {$exists: true}})
{ ..., "nome" : "Paolino", "cognome" : "Paperino", ... }
{ ..., "nome" : "Nonna papera",... }

in base a valori specifici

> db.personaggi.find({genere: 'F'})
{ ..., "nome" : "Nonna papera", ... }
> db.personaggi.find({prima_apparizione: 1961})
{ ..., "nome" : "Pico", "cognome" : "De Paperis"... }

Selettori semplici

in base a una relazione

> db.personaggi.find({prima_apparizione: {$gt: 1950}})
{ ..., "nome" : "Archimede", "cognome" : "Pitagorico", ... }
{ ..., "nome" : "Pico", "cognome" : "De Paperis", ... }

in base a più possibili valori per un campo

> db.personaggi.find({prima_apparizione: {$in: [1947, 1961]}})
{ ..., "nome" : "Paperon", "cognome" : "De Paperoni", ... }
{ ..., "nome" : "Pico", "cognome" : "De Paperis", ... }

Selettori complessi

in base a congiunzione logica

> db.personaggi.find({prima_apparizione: {$lt: 1950}, genere: 'M'})
{ ..., "nome" : "Paolino", "cognome" : "Paperino", ... }
{ ..., "nome" : "Paperon", "cognome" : "De Paperoni", ... }

in base a disgiunzione logica

> db.personaggi.find({$or: [{anno_nascita: {$gt: 1900}},
... {genere: 'F'}]})
{ ..., "nome" : "Paolino", "cognome" : "Paperino", ... }
{ ..., "nome" : "Nonna papera", ... }

Selettori complessi

in base a contenuto di array

> db.personaggi.find({passatempi: 'studio'})
{ ..., "nome" : "Archimede", "cognome" : "Pitagorico", ... }
{ ..., "nome" : "Pico", "cognome" : "De Paperis", ... }
> db.personaggi.find({passatempi: ['studio']})
{ ..., "nome" : "Pico", "cognome" : "De Paperis", ... }
> db.personaggi.find({'passatempi.1': 'studio'})
{ ..., "nome" : "Archimede", "cognome" : "Pitagorico", ... }

in base al contenuto di documenti incorporati

> db.personaggi.find({'auto.modello': 'American Bantam'})
{ ..., "nome" : "Paolino", "cognome" : "Paperino", ... }

Selettori complessi

in base a espressioni regolari
```
> db.personaggi.find({nome: /.*aper.*/})
{ ..., "nome" : "Nonna papera", ... }
{ ..., "nome" : "Paperon", "cognome" : "De Paperoni", ... }
```
l'uso di espressioni regolari e di altri strumenti come $lt e $gt può essere fonte di inefficienza durante l'esecuzione delle query
in base a relazioni di natura geospaziale ($near, $within)

Proiezioni

è possibile visualizzare campi specifici dei documenti selezionati specificando un secondo argomento per find

contenente un elenco dei campi da visualizzare

> db.personaggi.find({"passatempi.1": 'studio'}, {nome: 1,
... cognome: 1})
{ "_id" : ObjectId("5161a459b356cd6125b74e7e"),
"nome" : "Archimede", "cognome" : "Pitagorico" }

contenente un elenco dei campi da escludere

> db.personaggi.find({"passatempi.1": 'studio'}, {cognome: 0,
... genere: 0, anno_nascita: 0, prima_apparizione: 0,
... passatempi: 0})
{ "_id" : ObjectId("5161a459b356cd6125b74e7e"),
"nome" : "Archimede" }

Proiezioni

non è possibile utilizzare i due approcci assieme, con l'unica eccezione dell'esclusione di _id, che altrimenti viene sempre visualizzato
```
> db.personaggi.find({"passatempi.1": 'studio'}, {nome: 1,
... cognome: 1, _id: 0})
{ "nome" : "Archimede", "cognome" : "Pitagorico" }
```

Indici

è possibile associare un indice a una collezione

db.personaggi.ensureIndex({nome: 1, prima_apparizione: -1})

l'indice è associato a un campo o a un gruppo di campi, ordinati in modo non decrescente (1) o non crescente (-1)
un indice ricopre una query se di esso fanno parte
- tutti i campi filtrati dalla query, e
- tutti i campi restituiti dalla query

le query ricoperte vengono eseguite leggendo l'indice

db.personaggi.find({nome: /P.*/, prima_apparizione: {$lt, 1950}},
{_id: 0, nome: 1, prima_apparizione: 1})

Cursori

find restituisce un cursore ai suoi risultati
Se un cursore non viene assegnato a una variable, questo viene letto 20 volte, stampando i risultati

Un cursore può essere acceduto

usando i metodi next e hasNext

 var cursor = db.personaggi.find()
> var personaggio = cursor.next()
> personaggio.auto
{ "modello" : "American Bantam", "targa" : 313 }
> personaggio.auto.targa
313
> cursor.hasNext()
true

Cursori

usando una notazione array-like

> cursor[0]
{
    "_id" : ObjectId("5161a459b356cd6125b74e7c"),
    "nome" : "Nonna papera",
    "genere" : "F",
    "auto" : {
        "modello" : "Detroit Electric"
    },
    "anno_nascita" : 1833,
    "prima_apparizione" : 1943,
    "passatempi" : [
        "cucina",
        "agricoltura"
    ]
}

Metodi sui cursori

limit

limita il numero di documenti

skip

sposta il punto in cui il cursore inizia a restituire risultati

sort

ordina i risultati

> db.personaggi.find().sort({prima_apparizione: 1})

count

conta il numero di documenti in un risultato

Aggiornamento

il metodo update va usato con attenzione

> db.personaggi.update({name: 'Archimede'}, {prima_apparizione: 1950})
> db.personaggi.find({name: 'Archimede'})
>

le operazioni standard di aggiornamento vanno fatte utilizzando $set

> db.personaggi.update({nome: 'Archimede'}, {$set:
... {prima_apparizione: 1950}})
> db.personaggi.find({nome: 'Archimede'})
{ ..., "nome" : "Archimede", ..., "prima_apparizione" : 1950 }

Aggiornamento

$inc incrementa (o decrementa) una quantità

$push aggiunge elementi a un array

> db.personaggi.update({nome: 'Archimede'},
... {$push: {passatempi: 'lampadine'}})
> db.personaggi.find({nome: 'Archimede'})
{ ..., "nome" : "Archimede", ...,
"passatempi" : [ "invenzioni", "studio", "lampadine" ] }

Peculiarità di `update`

impostando a true il terzo argomento di update, l'operazione di aggiornamento crea una collezione qualora quella da modificare non esista (upsert)
normalmente l'esecuzione di update aggiorna un solo documento, a meno che non venga impostato a true il suo quarto argomento

Cancellazione

di tutti i documenti che soddisfano una condizione
```
db.personaggi.remove({nome: 'Pico'})
```
di (al più) un documento che soddisfa una condizione
```
db.personaggi.remove({nome: 'Pico'}, 1)
```
(equivale a LIMIT 1)
di tutti i documenti in una collezione
```
db.personaggi.remove()
```

Cancellazione

di una collezione
```
db.personaggi.drop()
```
di un database
```
db.dropDatabase()
```

MapReduce

partendo dai dati...

resource    date
index       Jan 20 2010 4:30
index       Jan 20 2010 5:30
about       Jan 20 2010 6:00
index       Jan 20 2010 7:00
about       Jan 21 2010 8:00
about       Jan 21 2010 8:30
index       Jan 21 2010 8:30
about       Jan 21 2010 9:00
index       Jan 21 2010 9:30
index       Jan 22 2010 5:00

MapReduce

...vogliamo ottenere

resource    year    month   day     count
index       2010    1       20      3
about       2010    1       20      1
about       2010    1       21      3
index       2010    1       21      2
index       2010    1       22      1

usiamo un algoritmo MapReduce in cui

Map emette 1 per ogni chiave (risorsa, data)
Reduce somma i valori

MapReduce

popoliamo il database

> db.hits.insert({resource:'index', date:new Date(2010,0,20,4,30)})
> db.hits.insert({resource:'index', date:new Date(2010,0,20,5,30)})
> db.hits.insert({resource:'about', date:new Date(2010,0,20,6,0)})
> db.hits.insert({resource:'index', date:new Date(2010,0,20,7,0)})
> db.hits.insert({resource:'about', date:new Date(2010,0,21,8,0)})
> db.hits.insert({resource:'index', date:new Date(2010,0,21,8,30)})
> db.hits.insert({resource:'about', date:new Date(2010,0,21,9,0)})
> db.hits.insert({resource:'index', date:new Date(2010,0,21,9,30)})
> db.hits.insert({resource:'index', date:new Date(2010,0,22,5,0)})

MapReduce

creiamo la funzione map...

> var map = function() {
...  var key = {
...    resource: this.resource,
...    year: this.date.getFullYear(),
...    month: this.date.getMonth(),
...    day: this.date.getDate()
...  };
...  emit(key, {count: 1});
...};

MapReduce

...la funzione reduce...

> var reduce = function(key, values) {
...  var sum = 0;
...  values.forEach(function(value) {
...     sum += value['count'];
...  });
...  return {count: sum};
...}

MapReduce

...eseguiamo l'algoritmo...

> db.hits.mapReduce(map, reduce, {out: 'hit_stats'})
{
    "result" : "stats",
    "timeMillis" : 52,
    "counts" : {
        "input" : 9,
        "emit" : 9,
        "reduce" : 3,
        "output" : 5
    },
    "ok" : 1,
}

MapReduce

...e leggiamo i risultati

> db.hit_stats.find()
{ "_id" : { "resource" : "about", "year" : 2010, "month" : 0,
"day" : 20 }, "value" : { "count" : 1 } }
{ "_id" : { "resource" : "about", "year" : 2010, "month" : 0,
"day" : 21 }, "value" : { "count" : 2 } }
{ "_id" : { "resource" : "index", "year" : 2010, "month" : 0,
"day" : 20 }, "value" : { "count" : 3 } }
{ "_id" : { "resource" : "index", "year" : 2010, "month" : 0,
"day" : 21 }, "value" : { "count" : 2 } }
{ "_id" : { "resource" : "index", "year" : 2010, "month" : 0,
"day" : 22 }, "value" : { "count" : 1 } }

Altre forme di aggregazione

MongoDB prevede forme più deboli di aggregazione che non richiedono l'utilizzo di algoritmi MapReduce, utilizzando il metodo aggregate in congiunzione con operatori come $match, $project, $group, $sort, ecc.

Join

le operazioni di join non vanno a braccetto con la scalabilità orizzontale
i database orientati ai documenti sono forse quelli più vicini all'approccio relazionale

Join

nessuno ci impedisce di fare le join "a mano"...

> db.personaggi.find({cognome: 'Paperino'})
{ "_id" : ObjectId("5161a459b356cd6125b74e7b"), ...,
"cognome" : "Paperino", ... }
> db.personaggi.insert({nome: 'qui', ...,
... capofamiglia: ObjectId("5161a459b356cd6125b74e7b")})
> db.personaggi.insert({nome: 'quo', ...,
... capofamiglia: ObjectId("5161a459b356cd6125b74e7b")})
> db.personaggi.insert({nome: 'qua', ...,
... capofamiglia: ObjectId("5161a459b356cd6125b74e7b")})

...al prezzo di una query in più (per recuperare il capofamiglia).

Relazioni molti a molti

si possono utilizzare gli array

> db.personaggi.insert({nome: 'Paolino', cognome: 'Paperino', ...,
... familiari: [ObjectId("516405b8b356cd6125b74e89"),
... ObjectId("516405b8b356cd6125b74e8a"),
... ObjectId("516405b8b356cd6125b74e8b")]})
> db.personaggi.find({familiari:
... ObjectId("516405b8b356cd6125b74e8a")})

o i documenti incorporati

> db.personaggi.insert({nome: 'Paolino', cognome: 'Paperino', ...,
... familiari: [{nome: 'Qui', ...}, {nome: 'Quo', ...},
... {nome: 'Qua', ...}]})
> db.personaggi.find({'familiari.nome': 'Quo'})

Alternativa: denormalizzazione

potrebbe non essere drammatico, ove dovesse essere necessario, denormalizzare i dati, duplicando parte dell'informazione
in teoria bisogna tenere conto del limite di 16MByte per documento, anche se nella pratica tale limite è spesso ben più che abbondante (e.g., un post di un blog implementato come un documento che incorpora i documenti che corrispondono ai commenti, tenendo conto che il testo dell'Amleto occupa 200KByte...)
il prezzo da pagare consiste nel dover aumentare il numero di query (per esempio se si aggiornano dati duplicati)

Come al solito...

...non c'è una soluzione universale, e molto spesso la scelta dipende oltre che dal problema che si vuole risolvere dal proprio stile di progettazione.

RDBMS più diffusi

Welcome to NoSQL!

I più diffusi

Perché?

MongoDB

Storia

Ma ha anche dei lati deboli

Nei RDBMS classici...

Nei DB NoSQL...

In MongoDB

JSON: carte sintattiche

Un esempio

Per la precisione...

Documenti incorporati

Array

Componenti di MongoDB

Esecuzione

Prime operazioni con MongoDB

Prime operazioni con MongoDB

Indici

Popoliamo una collezione

Selettori semplici

Selettori semplici

Selettori complessi

Selettori complessi

Selettori complessi

Proiezioni

Proiezioni

Indici

Cursori

Cursori

Metodi sui cursori

Aggiornamento

Aggiornamento

Peculiarità di update

Cancellazione

Cancellazione

MapReduce

MapReduce

MapReduce

MapReduce

MapReduce

MapReduce

MapReduce

Altre forme di aggregazione

Join

Join

Relazioni molti a molti

Alternativa: denormalizzazione

Come al solito...

Peculiarità di `update`