Mongo DB

Exemple : mongo DB
MongoDB est un engin de base de données dans la famille des engins NoSQL. Dans ce
contexte, il n’y a pas de table ou de schéma de structure de données. Les données sont
enregistrées dans des structures nommées Documents.

MongoBD est une base de données open source NoSQL orientée document. Elle stocke des
données au format JSON (en fait BSON, qui est une version binaire de JSON).
Le serveur MongoDB est organisé en plusieurs databases :
 Chaque database contient des collections.
 Chaque collection contient des documents.
 Chaque document est au format JSON et contient des propriétés.

SQL MongoDB
base de données ou schéma base de données
table collection
enregistrement document
attribut (atomique) propriété

C'est un Système de gestion de base de données NoSQL

•Utilise le modèle de stockage par document
•Une base de données contient des collections de documents
•Les documents sont écrits au format BSON, format binaire de JSON.

Document
•Un document représente une entité du système
•Chaque collection de la base de données est composée de zéros ou plusieurs documents
•Les documents d’une même collection n’ont pas à être du même format
•Un document peut contenir des sous-documents
•La représentation textuelle des champs est automatiquement sauvegardée en format binaire
(BSON)

•La notation BSON ajoute certaines contraintes supplémentaires à JSON :

•Les champs ne peuvent pas contenir
•Le caractère NULL
•Le point (.)
•Le signe de dollar ($)

•Le nom de champs _idest réservé au numéro d’identificateur unique du document

•Un document peut ressembler à ceci
{
name: "Nouveau projet",
version : 1,
langages : ["C++", "Java"],
admin : { nom : "Vincent", idEmploye: 1}
}
Atomicité

1
•L’écriture d’un document est une opération atomique
•Les modifications se font en entier ou pas du tout
•L’écriture de plusieurs documents est atomique pour chacun des documents, mais pas pour
l’ensemble
•Si plusieurs personnes modifient plusieurs documents, les modifications peuvent s’entrelacer

•Il n’y a pas de concept de transaction avec MongoDB

•Pas de commit et de rollback!
•Il faut donc, de préférence, définir les documents afin qu’une modification des données
ne modifie qu’un seul document

La notion de document est la base d’un système NoSQL. Toutefois, sachez que
MongoDB est plus que cela. Par exemple, MongoDB offre:

 Les Requêtes CRUD sur les documents (création, lecture, mise à jour et

suppression)
 Environnement de développement complet en ligne de commande
 Sécurisation des accès aux données
 Fonctions d’agrégation comme MapReduce
 Indexation
 Réplication des données et fractionnement sur plusieurs instances de
MongoDB

Schema-less
Mongodb est une base schema-less, une collection peut contenir des
documents de structures différentes et il n'est pas possible de définir la
structure a priori d'une collection.
La structure d'une collection n'est donc définie que par les documents qui
la composent, et elle peut évoluer dynamiquement au fur et à mesure des
insertions et suppressions.

Identification clé / valeur

Chaque document est identifié par un identifiant nommé _id unique pour
une collection, fonctionnant comme une clé primaire artificielle.

Architecture

2
 MongoDB fonctionne sous la forme d'un serveur auquel il est possible de
se connecter avec un client textuel (mongo shell).
MongoDb peut être distribuée sur plusieurs serveurs (partitionnement
horizontal ou sharding) et accédée à travers de multiples couches
applicatives (langages, API...)

Installation de MongoDB
MongoDB est disponible sur Windows, OSX et Linux :
https://docs.mongodb.com/manual/installation

1.  Téléchargez la version de MongoDB à http://www.mongodb.org/downloads

2. Installer dans un répertoire à la racine de votre disque C:\ et utilisez un répertoire
sans espaces comme c:\mongodb-win32-x86.

Configuration de l'environnement MongoDB

MongoDB nécessite un répertoire pour stocker toutes les données. Par défaut, le chemin de ce
répertoire est \data\db. Créer ce répertoire. On obtient le répertoire c:\data\db.

Ou bien

Dans le répertoire C:\mongodb…\bin, créez un document nommé mongod.cfg et insérez-y les

lignes suivantes:

 logpath=C:\data\logs\mongo.log
 dbpath=C:\data\db

Vous pouvez spécifier un autre chemin pour les fichiers de données mais en utilisant l'option

 --dbpath à mongod.exe lors du lancement,

Exemple :

C:\mongodb\bin\mongod.exe --dbpath "C:\test\mongodb\data"

3. Création d’un répertoire pour vos bases de données C:\data\logs

4. Pour vérifier que l'installation a bien fonctionné, ajouter le chemin de mongodb au
path et exécutez la commande  mongod.exe –config C:\mongodb-2.6\bin\mongod.cfg.
5. Connecter vous à votre instance MongoDB avec la commande  mongo.exe

3
Pour se connecter à un serveur MongoDB :
 présent sur la même machine : exécuter simplement mongo dans un terminal ;
 distant sur le port standard de MongoDB : exécuter mongo --host nom-du-serveur.

 mongod est le processus démon primaire pour le système MongoDB. Il traite les requêtes
sur les données, gère l'accès aux données, et effectue des opérations de traitement en
arrière-plan.
 Lancez mongo via une invite de commandes en tapant la commande suivante : mongo
 La connexion ne peut réussir que si le service MongoDB est lancé.
 Par défaut, mongo recherche un serveur de base de données sur le port 27017 sur
l'interface locale. Pour se connecter à un serveur sur un port ou une interface différente,
utilisez les paramètres --port et --host.

Création d’un service Windows pour exécuter MongoDB en tant que

service système

Exécutez la commande suivante: sc.exe create MongoDB binPath= « c:\mongodb-

…\bin\mongod.exe –service –config C:\mongodb-…\bin\mongod.cfg »
DisplayName= « MongoDB Standard » start= « auto »

Pour démarrer le service, vous pouvez exécuter sc.exe start MongoDB.

Pour arrêter MongoDB, appuyez sur Control + C dans le terminal où l'instance de mongoDB est

lancée.

Types de données

 JSON-like documents
 6 data types: null, boolean, numeric, string, array, object

 MongoDB adds support for other datatypes

 null {"x" : null}
 boolean {"x" : true}
 number (by default 64-bit floating point numbers) {"x" : 1.4142}
 4-byte integers {"x" : NumberInt(141)}
 8-byte integers {"x" : LongInt(141)}
 string (any UTF-8 character) {"x" : "NobleProg"}
 date (stored as milliseconds from Linux epoch) {"x" : new Date()}
 regular expressions (in queries) {"x" : /bob/i}
 array {"x" : [1.4142, true, "training"]}
 embedded documents {"x" : {"y" : 100} }
 ObjectId {"x" : ObjectId("54597591bb107f6ef5989771")}
 binary data (for non-UTF-8 strings)
 code {"x" : function() {/*...*/}}

4
Query Criteria

 $lt, $lte, $gt, $gte, $eq, $ne

 $in, $nin, $or
 $not, $mod

Exemples

> db.people.find({Nationality : "USA", BirthYear : {$lte : 1950}})

> db.people.find({Nationality : "USA", BirthYear : {$gte : 1940,
$lte : 1950}})
> db.people.find({Nationality : {$in : ["Belgium", "french"]}})
> db.people.find({$or : [{Nationality : "Belgium"}, {Nationality :
"french"}]})
> db.people.find({BirthYear : {$mod : [10, 0]}})
> db.people.find({BirthYear : {$not : {$mod : [10, 0]}}})
> db.people.find({Nationality : null})
> db.people.find({Nationality : {$exists : 1, $eq : null}})
> db.people.find({Name : /east/i})

Query Criteria for Arrays

 behave in the same way as scalars
 $all, $size (can not be combined with other criterias)
 $slice, $- operator, * $elemMatch

> db.people.find({Occupation : "Actor"}, {Name : 1, Occupation : 1})

> db.people.find({Occupation : ["Actress"]})
> db.people.find({Occupation : {$all : ["Actress", "Producer"]}})
> db.people.find({"Occupation.1" : "Producer"})
> db.people.find({Occupation : {$size : 3}})

Créer une nouvelle base de données

Pour créer une base de données il faut exécuter l'instruction use sur une
nouvelle base de données, puis donner un ordre d'insertion d'un premier
document JSON avec insert.

5
Exemple
use db1
db.col1.insert( { "nom":"salima" } )

db.people.insert({"nom" : "ait ali", "prenom" : "ali", "age":40})

person = {"nom" : "Sean Connery", "prenom" : "Great Britain", "age":30}

db.people.insert(person)

 On peut voir la liste des bases de données avec : show dbs

Pour accéder à la base de données db1 il faut utiliser la commande :
use db1

 On peut voir la liste des collections de la base de données en cours

avec : show collections
 On peut voir le contenu d'une collection avec : db.col1.find()

Cette commande donne comme résultat :

Le résultat attendu est le suivant, la clé générée étant bien entendu différente :
{ "_id":ObjectId("5dbe32b3286a9a8fad205"), "nom":"salima" }

Sélection d'une base de données

1. Pour voir le nom de la base de données courante, tapez db.

2. Pour voir la liste des bases de données, tapez show dbs.
3. Pour changer de base de données : use <database>.
4. # afficher les collections : Show collections
5. # renommer une collection : db.oldname.renameCollection("newname")
6. # effacer une collection : db.contacts.drop()
7. # effacer la base dans laquelle on est : db.dropDatabase()
8. Pour afficher l'aide : Help.

Insertion des documents

L'insertion de données dans une base MongoDB se fait avec l'instruction
db.collection.insert(Document JSON).

Si la collection n'existe pas, elle est créée dynamiquement.

L'insertion associe un identifiant (_id) à chaque document de la collection.

6
Exemple
db.Cinema.insert(
{
"nom":"Honkytonk Man",
"realisateur":{
"nom":"Eastwood",
"prenom":"Clint"
},
"annee":1982,
"acteurs":[
{
"nom":"Eastwood",
"prenom":"Kyle"
},
{
"nom":"Eastwood",
"prenom":"Clint"
}
]
}
)

Trouver des documents

La recherche de documents dans une base MongoDB se fait par l'instruction
db.collection.find(Document JSON, document JSON), où :

 le premier document JSON définit une restriction;

 le second document JSON (optionnel) définit une projection.

‘’.pretty()’’ permet de mieux afficher les données structurées

db.Cinema.find().pretty()

Exemple
Restriction
db.Cinema.find({"nom":"Honkytonk Man"})
retourne les documents JSON tels qu'ils ont à la racine un attribut "nom" avec la valeur
"Honkytonk Man".

Restriction et projection
db.Cinema.find({"nom":"Honkytonk Man"}, {"nom":1, "realisateur":1,"_id":0} )
retourne les documents JSON tels qu'ils ont à la racine un attribut "nom" avec la valeur

7
"Honkytonk Man", et seul les attributs situés à la racine "nom" et "realisateur" sont
projetés.

Insertion de plusieurs documents en utilisant une boucle « for »

Il est possible de générer des données de test en utilisant une boucle for. À partir du Shell mongo,
tapez la commande suivante :

for (var i = 1; i <= 100; i++) {

   db.testData.insert( { x : i } )
}

Insertion de plusieurs documents en utilisant une fonction JavaScript

Les données précédentes peuvent être générées en utilisant une fonction JavaScript :

function insertData(dbName, colName, num) {

var col = db.getSiblingDB(dbName).getCollection(colName);
for (i = 0; i < num; i++) {
col.insert({x:i});
}
print(col.count());
}

Cette fonction prend trois paramètres :

 la base de données ;
 le nom de la collection (existante ou non) ;
 le nombre de documents à créer.

Par exemple : insertData("bdtest", "testData", 15).

Cette fonction doit être introduite dans le fichier « .mongorc.js ».

Interroger Mongo en JavaScript

La console mongo permet d’exécuter des programme JavaScript avec
instruction load.

//test.js
2 print("Hello world");
> load("test.js")

Parcours d'un résultat de requête Mongo

8
//query.js
conn = new Mongo();
db = conn.getDB("db1");

recordset = db.User.find({"liked":{$elemMatch:{"star":3}}}, {"_id":0,

"liked.film":1})

while ( recordset.hasNext() ) {
printjson( recordset.next() );
}

 Utilisation de l'objet « Cursor »

Lorsqu'on interroge une collection, MongoDB retourne un objet «cursor» qui

contient les résultats de la requête.

Le shell mongo parcourt donc le cursor pour afficher les résultats, et n'affiche

dans un premier temps que les 20 premiers résultats.

Sur le shell mongo, il faut taper la commande it pour afficher la suite des

résultats.

Utilisation d'une boucle pour parcourir un objet « cursor »

Veuillez insérer plusieurs documents dans la collection en utilisant l'une des

méthodes de génération de données de test vues précédemment (shell ou
javascript).

1. Dans le shell MongoDB, faites une requête sur la collection testData en

affectant l'objet cursor à une variable c : var c = db.testData.find();
2. Affichez l'ensemble des résultats en utilisant une boucle while pour
parcourir le contenu de la variable c contenant l'objet cursor : 

while ( c.hasNext() ) printjson( c.next() ).

La méthode « hasNext() » retourne «true» si l'objet «cursor» contient

encore des documents.

La méthode « next() » affiche le document suivant.

La méthode printjson() affiche les documents sous un format JSON-like.

Utilisation d'un objet « cursor » comme un tableau

9
Il est possible de manipuler un objet «cursor» comme s'il était un
tableau :

1-      Faites une requête sur la collection testData en affectant le résultat dans

une variable :

var c = db.testData.find()

2-      Affichons par exemple le sixième élément : printjson( c [ 6 ] )

lorsqu'on accède aux documents d'un objet «cursor» en utilisant la notation

index des tableaux, mongo appelle dans un premier temps la méthode
« cursor.toArray() » et charge les documents retournés dans la RAM.
L'indexation est ainsi effectuée sur le tableau obtenu.

Pour de très grands volumes de données, mongo peut ainsi manquer de mémoire.

Requête pour l'obtention d'un document spécifique (équivaut à where)

Il est possible d'effectuer des requêtes avec paramètres pour obtenir un

document spécifique.

L'obtention de documents spécifiques se fait en interrogeant la collection en

utilisant un « document de requête » comme paramètre à la méthode
« find() ».

Dans notre cas : retrouvons les documents ayant 7 pour valeur de x, par
exemple. La requête est la suivante :

db.testData.find( { x : 7 } )

Le critère « x a pour valeur 7 » se traduit par le paramètre suivant : { x : 7 }.

Obtention d'un document unique d'une collection

La méthode « findOne() » permet d'obtenir un résultat unique à partir d'une

collection MongoDB.

La méthode « findOne() » prend les mêmes paramètres que la méthode

« find() », mais retourne un document au lieu d'un objet «cursor».

La commande suivante permet d'obtenir un document de la collection testData:

db.testData.findOne()

10
  Limiter le nombre de documents du résultat d'une requête

Pour des raisons de performance, il est possible de réduire la taille du résultat en

limitant le nombre de données à retourner via une requête.

La méthode « limit() » appliquée à un « cursor » permet de spécifier le nombre

maximum de documents à retourner.

Exemple :

db.testData.find().limit(3)

Insertion

Documents contenant un tags tableau

db.tags.insert({"tags":["red", "tall", "cheap"]});

db.tags.insert({"tags":["blue", "tall", "expensive"]});
db.tags.insert({"tags":["blue", "little", "cheap"]});

trouver tout ce qui inclut le tag "bleu"

db.tags.find({tags: { $elemMatch: { $eq: "blue" } }})

trouver tous les tags "bleu" et seulement bleu

db.tags.find({tags: "blue"})

trouver tous les tags "bleu" et "pas cher"

db.tags.find({ tags: { $all: ["cheap", "blue"] } } )

trouver tout pas "bleu"

db.tags.find({tags: { $ne: "blue" } })

# requêter selon des propriétés d'un sous-document

# admettons l'objet suivant :
# { nom: "Quentin", agenda: { lundi: "programmation", mardi: "dev", mercredi: "code" } }

# on pourra matcher depuis son sous document ainsi (notez bien les guillemets autour
de agenda.mardi) :

db.users.find({ 'agenda.mardi': 'dev' })

 db.db1.find().sort({ addedOn: 1 })

 db.db1.find().count()

11