NoSQL

Modèle des données

Principe de base : les données sont des documents

• stocké en Binary JSON (`BSON)
• documents similaires rassemblés dans des collections
• pas de schéma des documents définis en amont
  • contrairement à un BD relationnel ou NoSQL de type Column Store
• les documents peuvent n’avoir aucun point commun entre eux
• un document contient (généralement) l’ensemble des informations
  • pas (ou très peu) de jointure à faire
• BD respectant CP (dans le théorème CAP)
  • propriétés ACID au niveau d’un document

Point sur JSON

• JavaScript Object Notation
• Créé en 2005
• On parle de littéral
• Format d’échange de données structurées léger
• Schéma des données non connu
  • contenu dans les données
• Basé sur deux notions :
  • collection de couples clé/valeur
  • liste de valeurs ordonnées
• Structures possibles :
  • objet (couples clé/valeur) :
  • {}
  • { "nom": "jollois", "prenom": "fx" }
  • tableau (collection de valeurs) :
  • []
  • [ 1, 5, 10]
  • une valeur dans un objet ou dans un tableau peut être elle-même un littéral
• Deux types atomiques (string et number) et trois constantes (true, false, null)

Validation possible du JSON sur jsonlint.com/

{
    "tubd": {
        "formation": "DU Analyste Big Data",
        "responsable": { "nom": "Poggi", "prenom": "JM" },
        "etudiants" : [
            { "id": 1, "nom": "jollois", "prenom": "fx" },
            { "id": 2, "nom": "aristote", "details": "délégué" },
            { "id": 5, "nom": "platon" }
        ],
        "ouverte": true
    },
    "tudv": {
        "formation": "DU Data Visualisation",
        "ouverte": false,
        "todo": [
            "Creation de la maquette",
            "Validation par le conseil"
            ],
        "responsable": { "nom": "Métivier" }
    }
}

Compléments

BSON : extension de JSON

• Quelques types supplémentaires (identifiant spécifique, binaire, date, …)
• Distinction entier et réel

Schéma dynamique

• Documents variant très fortement entre eux, même dans une même collection
• On parle de self-describing documents
• Ajout très facile d’un nouvel élément pour un document, même si cet élément est inexistant pour les autres
• Pas de ALTER TABLE ou de redesign de la base

Pas de jointures entre les collections

Langage d’interrogation

• Pas de SQL (bien évidemment), ni de langage proche
• Définition d’un langage propre
• Langage permettant plus que les accès aux données
  • définition de variables
  • boucles
  • …

Commandes suivantes réalisables à partir du shell

Document dans R

R ne gérant pas nativement les données JSON, les documents sont traduits, pour la librairie mongolite, en data.frame. Pour récupérer le premier document, nous utilisons la fonction find() de l’objet créé m.

d = m$find(limit = 1)
d
class(d)

Les objets Capital, OffLang et NotOffLang sont particuliers, comme on peut le voir dans le JSON. Capital est une liste, et les deux autres sont des tableaux de listes. Voila leur classe en R.

class(d$Capital)
d$Capital
class(d$OffLang)
d$OffLang
class(d$NotOffLang)
d$NotOffLang

Restriction et Projection

La fonction find() de l’objet m permet de retourner tous les documents. On peut se limiter à un certain nombre de documents avec l’option limit, comme précédemment.

Pour faire une restriction sur la valeur d’un attribut, il faut utiliser l’option query, avec un formalisme particulier. Il faut écrire au format JSON dans une chaîne, avec pour les champs à comparer leur nom suivi de la valeur (pour l’égalité) ou d’un objet complexe pour les autres tests (infériorité, supériorité, présence dans une liste).

Pour une projection, c’est l’option fields à renseigner. On écrit au format JSON, avec la valeur 1 pour les champs qu’on souhaite avoir en retour. Par défaut, l’identifiant (_id) est toujours présent, mais on peut le supprimer en indiquant 0.

Dans cet exemple, on recherche le document dont l’attribut "Name" est égal à "France", et on affiche uniquement les attributs "Name" et "Population". Dans la deuxième expression, on supprime l’affichage de l’identifiant interne à MongoDB.

m$find(query = '{"Name": "France"}', 
       fields = '{"Name": 1, "Population": 1}')
m$find(query = '{"Name": "France"}', 
       fields = '{"_id": 0, "Name": 1, "Population": 1}')

Ici, on recherche les pays du continent "Europe" dont la population est supérieur à 50M d’habitants.

m$find(query = '{"Continent": "Europe", "Population": {"$gt": 50000000}}',
       fields = '{"_id": 0, "Name": 1, "Population": 1}')
m$find(query = '{"Continent": {"$in": ["Antarctica", "South America"]}}', 
       fields = '{"_id": 0, "Name": 1, "Continent": 1}')

Dans ces exemples, nous cherchons en premier les pays avec comme capital "Paris", et ensuite les pays dont une des langues officielles est le français.

m$find(query = '{"Capital.Name": "Paris"}',
       fields = '{"_id": 0, "Name": 1, "Capital": 1}')
m$find(query = '{"OffLang.Language": "French"}',
       fields = '{"_id": 0, "Name": 1, "OffLang.Percentage": 1}')

Il est aussi posible de trier les documents retournés, via l’option sort. Toujours en JSON, on indique 1 pour un tri croissant et -1 pour un tri décroissant.

m$find(fields = '{"_id": 0, "Name": 1}', 
       sort = '{"Population": -1}', 
       limit = 10)

Agrégat

m$count()
m$count(query = '{"Name": "France"}')
m$count(query = '{"Continent": "Europe"}')

m$aggregate(pipeline = '[
    {"$group": {"_id": "$Continent", "NbPays": {"$sum": 1}}}
]')
m$aggregate(pipeline = '[
    {"$group": {"_id": "$Continent", "NbPays": {"$sum": 1}, "Population": {"$sum": "$Population"}}}, 
    {"$sort": { "NbPays": -1}}
]')

m$aggregate('[
    { "$unwind": "$OffLang" },
    { "$match": { "OffLang.Language": "French"}},
    { "$project": { "_id": 0, "Name": 1, "OffLang.Percentage": 1 }}
]')

m$aggregate('[
    { "$unwind": "$OffLang" },
    { "$project": { "Language": "$OffLang.Language", "Percentage": "$OffLang.Percentage"}},
    { "$group": { "_id": "$Language", "NbPays": {"$sum": 1}, "PctMoyen": { "$avg": "$Percentage" } }},
    { "$sort": { "NbPays": -1}}
]')

Map-Reduce

Le paradigme Map-Reduce permet de décomposer une tâche en deux étapes :

1. Map : application d’un algorithme sur chaque document, celui-ci renvoyant un résultat ou une série de résultat
2. Reduce : synthèse des résultats renvoyés dans l’étape précédente selon certains critères

Exemple classique : décompte des mots présents dans un ensemble de texte

• Map : pour chaque texte, à chaque mot rencontré, on créé un couple <mot, 1> (un document = beaucoup de résultats générés)
• Reduce : pour chaque mot, on fait la somme des valeurs pour obtenir le nombre de fois où chaque mot apparaît dans l’ensemble des textes à disposition

On utilise la fonction mapreduce() de m pour appliquer l’algorithme Map-Reduce sur les documents de la collection, avec les paramètres suivants :

• map : fonction JavaScript
  • aucun paramètre
  • emit(key, value) pour créer un couple résultat
• reduce : fonction JavaScript
  • deux paramètres : key et values (tableau des valeurs créés à l’étape précédente)
  • return result pour renvoyer le résultat
• out : collection éventuelle dans laquelle stocker les résultats dans MongoDB
• …

Dans la fonction concernant l’étape Map, on utilise l’objet this pour accéder aux attributs du document. Le langage utilisé est le JavaScript.

Dans l’exemple ci-dessous, nous calculons pour chaque continent la population de celui-ci.

m$mapreduce(
    map = 'function() { emit(this.Continent, this.Population)}',
    reduce = 'function(cont, nb) { return Array.sum(nb) }'
)

On peut utiliser ce paradigme pour calculer le pourcentage médian de la population parlant cette langue.

m$mapreduce(
    map = 'function() {
        if (this.OffLang) {
            for (i = 0; i < this.OffLang.length; i++) {
                emit(this.OffLang[i].Language, this.OffLang[i].Percentage);
            }
        }
    }',
    reduce = 'function(id, values) { 
        values.sort( function(a,b) {return a - b;} );
        var half = Math.floor(values.length/2);
        if(values.length % 2)
            return values[half];
        else
            return (values[half-1] + values[half]) / 2.0;
    }'
)