MongoDB par antonin_diet et rathalinux

Développé depuis 2007 par MongoDB, MongoDB est un système de gestion de base de données dans la mouvance NoSQL orientée documents écrit en langage C++, répartissable sur un nombre quelconque d'ordinateurs et ne nécessitant pas de schéma prédéfini des données. Son nom vient de Humongous qui veut dire énorme ou immense. L'objectif est donc de pouvoir gérer de grandes quantités de données. Le moteur de base de données facilite l'extension (on parle de scaling) si bien que l'on pourra supporter l'accroissement de la quantité de données par l'ajout de machines.

Il s'agit d'une base de données permettant aux référentiels d'évoluer aussi rapidement que les applications, tout en procurant aux concepteurs les fonctionnalités attendues des bases de données usuelles, notamment des indexes secondaires, un langage complet de requêtes et une stricte cohérence et stabilité.

MongoDB est conçue pour l'évolution, les performances et la haute disponibilité, passant de l'installation sur de simples serveurs, à des architectures complexes déployées sur plusieurs sites. En tirant profit du calcul en mémoire, MongoDB permet de lire et d'écrire très rapidement. La réplication intégrée à MongoDB et le basculement automatique, permettent une souplesse opérationnelle et une fiabilité de classe « entreprise ».

MongoDB est donc la première base de données, permettant aux sociétés d'être plus rapides et évolutives. Les entreprises de toutes tailles utilisent MongoDB pour créer de nouveaux types d'applications, améliorer la façon de travailler avec ses clients, accélérer les temps de mise sur le marché et faire baisser les coûts.

Contrairement aux base de données relationnelles comme SQL, MongoDB (qui est une base de données orientée documents) n'impose pas de schéma défini, d'où sa grande flexibilité.

MongoDB n’imposant pas de schéma, on peut lui trouver certains avantages:
- MongoDB offre un grand nombre de fonctions qui la rendent très polyvalente comme: les index géographiques, le framework d’agrégation, le map/reduce intégré et les nombreux outils de chargement de données en masse ou de sauvegarde et de restauration.
- Sa modélisation documentaire s’adapte parfaitement à de nombreuses applications. Par exemple, toutes les applications de gestion de dossiers, factures, commandes ou produits se modélisent plus facilement avec une base documentaire qu’avec une base relationnelle
- Le concept de « schéma » n’existe pas. Chaque document est libre de suivre sa propre structure. MondoDB permet une grande flexibilité au niveau des données
- MongoDB assure la scalabilité: la réplication et le Sharding (distribution de données sur plusieurs machines): son modèle de données orientées document lui permet de répartir automatiquement les données sur plusieurs serveurs (Cela permet aux développeurs de se concentrer sur la programmation de l'application)

Cependant, c'est cette flexibilité qui peut poser des problèmes lorsque l'on utilise MongoDB:
- Pas la possibilité de réaliser des jointures : les données sont généralement embarquées dans le même « document »
- La flexibilité, la performance et la scalabilité se font au détriment de la capacité de gérer des transactions complexes
- Pas de schéma imposé mais cela peut s’avérer rapidement pénalisant puisque la charge du contrôle des données est reportée du côté de l’application
- MongoDB propose un langage d’interrogation qui lui est propre (donc, non standardisé), pratique mais qui s'avère limité

https://www.mongodb.com/fr https://fr.wikipedia.org/wiki/MongoDB http://blog.ippon.fr/2013/11/19/mongodb-est-moins-rapide-et-alors/ http://www.next-decision.fr/les-editeurs/stockage/mongo-db

MongoDB est développé depuis 2007 par MongoDB. Cette entreprise travaillait alors sur un système de Cloud computing, informatique à données largement réparties, similaire au service Google App Engine de Google. Sa première version considérée comme industriellement viable a été la 1.4, en 2010. La dernière version en date est MongoDB 3.2.

Il existe différentes versions de MongoDB depuis la première version. Voici les différentes versions stables de MongoDB:

https://docs.mongodb.com/manual/release-notes/

On associe les documents aux bases de données orientées documents qui sont destinées aux applications qui gèrent des documents. Ce type de bases de données peut être ou non une sur-couche d'une base de données relationnelle.

Dans un système de base de données relationnelles, les informations sont stockées par ligne dans des tables. Ces tables sont mises en relation en utilisants des clés primaires et étrangères. Or dans MongoDb, l'information est modélisée sur un document au format BSON basé sur JSON (Javascript Object Notation).

MongoDB ne nécessite donc pas de schéma prédéfini comme en SQL, il n'est pas nécessaire par exemple de définir des colonnes avec un nom et un type et on peut insérer n'importe quel document BSON. Lors de l'insertion d'un document, MongoDB ajoute automatiquement un index nommé par défaut _id. La méthode insert retourne l'identifiant du document inséré.

De plus, contrairement aux bases de données SQL, il n'est pas nécessaire de faire des requêtes avec des jointures pour connaitre des informations. Dans MongoDb, il suffit de lire le document qui nous intéresse, d'où l'avantage de modéliser les données sur un document.

Le terme collection est issu du monde NoSQL (pour Not Only SQL) et correspond par analogie à la notion de table dans les bases de données relationnelles (MySQL, PosgreSQL, Microsoft Access, Oracle, etc.). Une collection permet de stocker des documents, notion analogue à celle de ligne.

En comparant le schéma de structure d'une base de MongoDB à celui d'une base de donnée relationelle comme SQL, on peut faire le parallèle suivant:

Pour avoir un apercu, on peut définir par exemple 2 documents comme ceci:

{_id: "Her", acteurs : [{nom:"Johansson", prenom:"Scarlett"}, {nom:"Phoenix", prenom:"Joaquim"}]}
{_id: "Avengers", acteurs : [{nom:"Johansson", prenom:"Scarlett"}]}

Dans ces exemples, on peut voir que les acteurs sont dupliqués. Dans le monde NoSQL, on n'hésite pas à dénormaliser le schéma de la base de données pour favoriser les performances à la lecture. L'important est de savoir quelles requêtes seront faites pour décider du format des documents.

http://b3d.bdpedia.fr/mongodb.html https://openclassrooms.com/courses/guide-de-demarrage-pour-utiliser-mongodb http://blog.xebia.fr/2010/12/15/mongodb-en-pratique/

Le format BSON correspond au format des données manipulés par MongoDB. C'est un format d'échange de données informatiques utilisé principalement comme stockage de données et format de transfert de données par le réseau dans la base de données MongoDB. C'est un format binaire permettant de représenter des structures de données simples et des tableaux associatifs (appelées objets ou des documents dans MongoDB). Le nom BSON est basé sur le terme JSON et signifie Binary JSON

JSON ou JavaScript Object Notation, est un format de données textuelles dérivé de la notation des objets du langage JavaScript. Il permet de représenter de l’information structurée Un document JSON a pour fonction de représenter de l'information accompagnée d'étiquettes permettant d'en interpréter les divers éléments, sans aucune restriction sur le nombre de celles-ci. Un document JSON ne comprend que deux types d'éléments structurels : des ensembles de paires nom / valeur et des listes ordonnées de valeurs.

Voici un tableau comparatif de BSON ET JSON

On constate que le format BSON supporte plus de types que le format JSON. Le codage BSON complète la représentation JSON en y ajoutant des types de données supplémentaires, tels que les formats virgule flottante ou date entre autres.

http://www.slideshare.net/marksmalley1/json-the-argonauts-and-mark https://fr.wikipedia.org/wiki/BSON

• Fonctionnalités principales de MongoDB

MongoDB une base de données NoSQL de type document et écrite en C++ qui dispose de plusieurs fonctionnalités intéressantes. Voici les fonctionnalités générales de MongoDB:
- La réplication permet de dupliquer les serveurs de base de données pour répondre à une monté en charge ou une tolérance de panne.
- Le Sharding (distribution de données sur plusieurs machines pour assurer la scalabilité) permet de répartir les données sur plusieurs serveurs soit pour simplement augmenter les performances ou pour répartir les données géographiquement.
- Système de fichiers GridFS permet de stocker simplement des fichiers en base de données.
- Le SIG ou Système d’information géographique permet de manipuler simplement des positions sur un plan ou sur le globe terrestre.
- La fonction de recherche : MongoDB intègre un système de recherche optimisé en fonction de la langue utilisée.
- MongoDB offre des nombreuses fonctionnalités que l’on trouve dans le monde relationnel (count, groupBy, etc.) mais aussi le support de la recherche full-text, la recherche géo-spatiale ou MapReduce (manipulation et distribution de données dans un cluster)
- supporte l’indexation pour l’optimisation des recherches

• Fonctionnalités pour les requêtes

Une base est constituée d’un ensemble de collections, l’équivalent d’une table en relationnel.
Soit la collection movies qui enregistre les informations sur les films.
Notre collection movies contient des documents au format BSON définis par le schéma suivant.

Voici le format d'un document au format BSON. On a par exemple comme informations stockées pour un film:

 {
  "_id": "movie:100",
  "title": "The Social network",
  "summary": "On a fall night in 2003, Harvard undergrad and
     programming genius Mark Zuckerberg sits down at his
     computer and heatedly begins working on a new idea. (...)",
  "year": 2010,
  "director": {"last_name": "Fincher",
                "first_name": "David"},
  "actors": [
    {"first_name": "Jesse", "last_name": "Eisenberg"},
    {"first_name": "Rooney", "last_name": "Mara"}
   ]
}

Liste des collections

 show collections 

Placement dans une base

 use <nombase> 

Création d'une collection. Une base est constituée d’un ensemble de collections, l’équivalent d’une table en relationnel

 db.createCollection("movies") 

Insertion d'un document BSON dans une collection (ici, movies)

 db.movies.insert ({"title": "Batman", "year": 1989}) 

 db.movies.insert ({"produit": "Grulband", prix: 230, enStock: true}) 

On remarque que la structure de ce document n’a rien à voir avec le précédent: il n’y a pas de schéma (et donc pas de contrainte) dans MongoDB. On est libre de tout faire (et même de faire n’importe quoi). Nous sommes partis pour mettre n’importe quel objet dans notre collection movies, ce qui revient à reporter les problèmes (contrôles, contraintes, tests sur la structure) vers l’application.

Affichage du contenu d’une collection

 db.movies.find() 

C’est un premier exemple d’une fonction de recherche avec MongoDB. On obtient des objets (javascript, encodés en BSON)

 { "_id" : ObjectId("5422d9095ae45806a0e66474"), "nom" : "nfe024" } 

MongoDB associe un identifiant unique à chaque document, de nom conventionnel _id, et lui attribue une valeur si elle n’est pas indiquée explicitement.

Affectation d'un identifiant explicitement

 db.movies.insert ({_id: "1", "produit": "Kramölk", prix: 10, enStock: true}) 

Remplacement complet d'un document (update)

 db.movies.update( { "title": "Mr Smith" }, { "title": "Mr Cool", "year": 2000 } ) 

Modification des champs d’un document (update/$set)

 db.movies.update( { "title": "Avengers" }, { $set: { "summary": "c'est un film divertissant" } } ) 

Comptage du nombre de documents dans la collection

 db.movies.count() 

Suppression d'un document
La suppression d’un ou plusieurs documents se fait via la commande « remove » à laquelle on passe en paramètre le query permettant d’identifier les documents visés.

 db.movies.remove({"produit": "Grulband"}) 

Suppression d'un champ présent dans un document
On utilise la commande $unset

 db.movies.update({"title": "Batman"}, {$unset : {year : 1989}}) 

Suppression d'une collection

 db.movies.drop() 

• Création de bases : utilitaire d’import de MongoDB

Lorsque l'on veut insérer des documents BSON dans la base MongoDB, au lieu de les insérer un par un (ce qui pourrait être fastidieux), on peut utiliser l’utilitaire d’import de MongoDB, qui prend en entrée un tableau BSON contenant la liste des objets à insérer.

• Selections : parcours, comptage et tri

Parcours dans toute une collection. On utilise alors find() dans argument:

 db.movies.find () 

Comptage: On peut savoir combien de documents comprend le résultat:

 db.movies.count () 

Tri des documents

 db.movies.find ().sort({"title": 1}).skip(9).limit(12) 

Implicitement, cela suppose qu’il existe un ordre sur le parcours des documents. Par défaut, cet ordre est dicté par le stockage physique: MongoDB fournit les documents dans l’ordre où il les trouve (dans les fichiers). On peut trier explicitement, ce qui rend le résultat plus déterministe.

• Recherche d'éléments

Recherche si on connaît l’identifiant:

 db.movies.find ({"_id": "movie:2"}) 

Interrogation de n’importe quel attribut

 db.movies.find ({"title": "Alien"}) 

• Projections

Jusqu’à présent, les requêtes ramènent l’intégralité des objets satisfaisant les critères de recherche.
On peut aussi faire des projections, en passant un second argument à la fonction find().

 db.movies.find ({"actors.last_name": "Tarantino"}, {"title": true, "actors": 'j'} ) 

Le second argument est un objet BSON dont les attributs sont ceux à conserver dans le résultat. La valeur des attributs dans cet objet-projection ne prend que deux interprétations.
Toute valeur autre que 0 ou null indique que l’attribut doit être conservé. Si on choisit au contraire d’indiquer les attributs à exclure, on leur donne la valeur 0 ou null.

Par exemple, la requête suivante retourne les films sans les acteurs et sans le résumé.

 db.movies.find ({"actors": null, "summary": 0}) 

• Opérateurs ensemblistes

Les opérateurs du langage SQL in, not in, any et all se retrouvent dans le langage d’interrogation. La différence, notable, est que SQL applique ces opérateurs à des relations (elles-mêmes obtenues par des requêtes) alors que dans le cas de MongoDB, ce sont des tableaux JSON. MongoDB ne permet pas d’imbriquer des requêtes.

Par exemple, on cherche les films dans lesquels joue au moins un des artistes dans une liste (on suppose que l’on connaît l’identifiant).

 db.artists.find({"actors._id": {$in: ["artist:34","artist:98","artist:1"]}}) 

Le not in correspond à l’opérateur $nin.

 db.artists.find({"_id": {$nin: ["artist:34","artist:98","artist:1"]}}) 

Comment trouver les films qui n’ont pas d’attribut summary?

 db.movies.find({"summary": {$exists: false}}, {"title": 1}) 

• Opérateurs booléens

Par défaut, quand on exprime plusieurs critères, c’est une conjonction (and) qui est appliquée. On peut l’indiquer explicitement. Voici la syntaxe (les films tournés avec Leonardo DiCaprio en 1997):

 db.movies.find({$and : [{"year": "1997"}, {actors.last_name: "DiCaprio"]} ) 

L’opérateur and s’applique à un tableau de conditions. Bien entendu il existe un opérateur or avec la même syntaxe. Les films parus en 1997 ou avec Leonardo DiCaprio.

 db.movies.find({$or : [{"year": "1997"}, {actors.last_name: "DiCaprio"]} ) 

http://b3d.bdpedia.fr/mongodb.html http://blog.xebia.fr/2010/12/15/mongodb-en-pratique/

Voici les interfaces les plus connues de MongoDB

RoboMongo: il s'agit d'un client graphique disponible pour toutes les plate-formes sur le site robomongo.org. L’installation est très simple, l’outil semble assez complet et en évolution rapide. L’interface RoboMongo montre l’interface en action

RockMongo: il s'agit d'une application PHP disponible sur le site http://www.rockmongo.com et qui nécessite un serveur Apache/PHP. De plus, il est nécessaire d’installer l’extension PHP de connexion à MongoDB.

Genghis: Genghis est une interface d'administration de bases de données NoSQL sous MongoDB permettant une lecture adaptée à chaque périphérique.
Il s'agit d'une interface semblable a l'outil phpMyAdmin.

https://blog.michaelckennedy.net/2013/04/22/a-roundup-of-mongodb-management-tools-nosql-database/ http://rockmongo.com/ http://genghisapp.com/

Pour le langage Java

Java-MongoDB-Driver est le pilote Java pris en charge pour MongoDB
com.mongodb: il s'agit du paquet de base permettant de créer une connexion client à une instance en cours d' exécution mongod
com.mongodb.client: ce paquet permet l'accès à une base de données MongoDB
On se connecte à une instance MongoDB en cours d' exécution sur le localhost (port par défaut 27017)

Pour gérer les documents dans l'application, on utilise les paquets suivants:
* org.bson.Document
* com.mongodb.MongoClient
* com.mongodb.client.MongoCollection
* com.mongodb.client.MongoDatabase

https://api.mongodb.com/java/current/
http://javarticles.com/2016/01/inserting-document-using-mongodb-java-driver.html

Pour le langage C++

mongo-cxx-driver : permet de se connecter à une instance mongod et de créer une connexion client à une instance en cours d' exécution mongod.

La librairie bsoncxx : elle permet de gérer les documents.
Pour gérer les applications, on doit inclure bson/bson.h dans le fichier code de l'application afin de pouvoir gérer les documents.

https://www.mongodb.com/blog/post/introducing-new-c-driver
http://mongoc.org/libmongoc/1.2.2/tutorial.html

L'installation de MongoDB est simple, rapide et efficace.

La première étape est de configurer un dépot de packet pour utiliser yum.

 
[root@centos7 ~]# touch /etc/yum.repos.d/mongodb-org-3.2.repo
[root@centos7 ~]# vi /etc/yum.repos.d/mongodb-org-3.2.repo

[mongodb-org-3.2]
name=MongoDB Repository
baseurl=https://repo.mongodb.org/yum/redhat/$releasever/mongodb-org/3.2/x86_64/
gpgcheck=1
enabled=1
gpgkey=https://www.mongodb.org/static/pgp/server-3.2.asc

On lance l'installation avec yum

[root@centos7 ~]# yum install mongodb-org
Loaded plugins: fastestmirror, langpacks
mongodb-org-3.2                                       | 2.5 kB     00:00
mongodb-org-3.2/7/primary_db                            |  46 kB   00:00
Loading mirror speeds from cached hostfile
 * base: centos.quelquesmots.fr
 * extras: mirror.plusserver.com
 * updates: centos.quelquesmots.fr
Resolving Dependencies
--> Running transaction check
---> Package mongodb-org.x86_64 0:3.2.9-1.el7 will be installed
--> Processing Dependency: mongodb-org-tools = 3.2.9 for package: mongodb-org-3.2.9-1.el7.x86_64
--> Processing Dependency: mongodb-org-shell = 3.2.9 for package: mongodb-org-3.2.9-1.el7.x86_64
--> Processing Dependency: mongodb-org-server = 3.2.9 for package: mongodb-org-3.2.9-1.el7.x86_64
--> Processing Dependency: mongodb-org-mongos = 3.2.9 for package: mongodb-org-3.2.9-1.el7.x86_64
--> Running transaction check
---> Package mongodb-org-mongos.x86_64 0:3.2.9-1.el7 will be installed
---> Package mongodb-org-server.x86_64 0:3.2.9-1.el7 will be installed
---> Package mongodb-org-shell.x86_64 0:3.2.9-1.el7 will be installed
---> Package mongodb-org-tools.x86_64 0:3.2.9-1.el7 will be installed
--> Finished Dependency Resolution

Dependencies Resolved

=============================================================================
 Package                Arch       Version         Repository           Size
=============================================================================
Installing:
 mongodb-org            x86_64     3.2.9-1.el7     mongodb-org-3.2     5.8 k
Installing for dependencies:
 mongodb-org-mongos     x86_64     3.2.9-1.el7     mongodb-org-3.2     5.6 M
 mongodb-org-server     x86_64     3.2.9-1.el7     mongodb-org-3.2      12 M
 mongodb-org-shell      x86_64     3.2.9-1.el7     mongodb-org-3.2     6.7 M
 mongodb-org-tools      x86_64     3.2.9-1.el7     mongodb-org-3.2      43 M

Transaction Summary
=============================================================================
Install  1 Package (+4 Dependent packages)

Total download size: 68 M
Installed size: 222 M
Is this ok [y/d/N]: y
Downloading packages:
(1/5): mongodb-org-3.2.9-1.el7.x86_64.rpm               | 5.8 kB   00:01
(2/5): mongodb-org-mongos-3.2.9-1.el7.x86_64.rpm        | 5.6 MB   00:04
(3/5): mongodb-org-shell-3.2.9-1.el7.x86_64.rpm         | 6.7 MB   00:10
(4/5): mongodb-org-server-3.2.9-1.el7.x86_64.rpm        |  12 MB   00:15
(5/5): mongodb-org-tools-3.2.9-1.el7.x86_64.rpm         |  43 MB   00:13
-----------------------------------------------------------------------------
Total                                           2.4 MB/s |  68 MB  00:28
Running transaction check
Running transaction test
Transaction test succeeded
Running transaction
  Installing : mongodb-org-server-3.2.9-1.el7.x86_64                     1/5
  Installing : mongodb-org-shell-3.2.9-1.el7.x86_64                      2/5
  Installing : mongodb-org-mongos-3.2.9-1.el7.x86_64                     3/5
  Installing : mongodb-org-tools-3.2.9-1.el7.x86_64                      4/5
  Installing : mongodb-org-3.2.9-1.el7.x86_64                            5/5
  Verifying  : mongodb-org-tools-3.2.9-1.el7.x86_64                      1/5
  Verifying  : mongodb-org-mongos-3.2.9-1.el7.x86_64                     2/5
  Verifying  : mongodb-org-shell-3.2.9-1.el7.x86_64                      3/5
  Verifying  : mongodb-org-3.2.9-1.el7.x86_64                            4/5
  Verifying  : mongodb-org-server-3.2.9-1.el7.x86_64                     5/5

Installed:
  mongodb-org.x86_64 0:3.2.9-1.el7

Dependency Installed:
  mongodb-org-mongos.x86_64 0:3.2.9-1.el7
  mongodb-org-server.x86_64 0:3.2.9-1.el7
  mongodb-org-shell.x86_64 0:3.2.9-1.el7
  mongodb-org-tools.x86_64 0:3.2.9-1.el7

Complete!
[root@centos7 ~]#

Mongo est installé. Pour voir si mongod ce lance correctement on regarde les dernières entrée du journal de log

[root@centos7 ~]# tail -n 1 /var/log/mongodb/mongod.log
2016-09-08T11:48:58.758+0200 I NETWORK  [initandlisten] waiting for connections on port 27017
[root@centos7 ~]# ps -ax | grep mongod
31322 ?        Sl     0:04 /usr/bin/mongod -f /etc/mongod.conf
[root@centos7 ~]#

On peut démarrer, redémarrer, arrêter le serveur avec les commandes:

[root@centos7 ~]# systemctl start mongod
[root@centos7 ~]# systemctl restart mongod
[root@centos7 ~]# systemctl stop mongod

le client MongoDB est invoqué avec la commande mongo (pour quitter on utilisera “quit()” Ctrl-c)

[root@centos7 ~]# mongo
MongoDB shell version: 3.2.9
connecting to: test
Welcome to the MongoDB shell.
For interactive help, type "help".
For more comprehensive documentation, see
        http://docs.mongodb.org/
Questions? Try the support group
        http://groups.google.com/group/mongodb-user
Server has startup warnings:
2016-09-08T12:13:01.656+0200 I CONTROL  [initandlisten]
2016-09-08T12:13:01.656+0200 I CONTROL  [initandlisten] ** WARNING: soft rlimits too low. rlimits set to 4096 processes, 64000 files. Number of processes should be at least 32000 : 0.5 times number of files.
>

.
.
.

>quit()
[root@centos7 ~]#

Le fichier de mongodb se trouve dans /etc/mongod.conf Dans ce fichier, sont notamment définit le lieux de stockage des données et des logs respectivement dans /var/lib/mongo et /var/log/mongodb/mongod.conf par défaut.

Une manipulation intéressante à faire consiste à modifier le prompt du client mongo pour afficher la base de donnée courante. Par défaut le prompt est minimaliste:

>

Pour connaître le base de donnée sur laquelle on travaille il convient de de taper “db”

>db
test
>

Pour cela il faut quitter mongo est éditer le fichier $HOME/.mongorc.js (vide de base) et ajouter la ligne:

prompt = function(){return db+">";}

Puis observer le résultat sur mongo.

Après avoir installé MongoDB, on se connecte en tant que root puis on lance MongoDB en lançant la commande Mongo pour démarrer MongoDB

[root@centos7 ~]# mongo
MongoDB shell version: 3.2.9
connecting to: test
Server has startup warnings:
2016-09-08T14:59:06.638+0200 I CONTROL  [initandlisten]
2016-09-08T14:59:06.638+0200 I CONTROL  [initandlisten] ** WARNING: soft rlimits too low. rlimits set to 4096 processes, 64000 files. Number of processes should be at least 32000 : 0.5 times number of files.
>

Voici quelques commandes utiles qui illustrent la spécificité de MongoDB par rapport aux base de données relationnelles SQL.

On commence par créer une collection nommé Movies qui enregistre des informations sur des films

> db.createCollection("movies")

Puis on crée des documents qui seront rangés dans la collection movies

> db.movies.insert({ "_id" : "movie:1", "titre" : "Batman", "année" : 1989, "acteurs" : [ { "prénom" : "Michael", "nom" : "Keaton" } ] })
> db.movies.insert({ "_id" : "movie:2", "titre" : "Beetlejuice", "année" : 1988, "acteurs" : [ { "prénom" : "Michael", "nom" : "Keaton" }, { "prénom" : "Geena", "nom" : "Davis" } ] })
> db.movies.insert({ "_id" : "movie:3", "titre" : "Jurassik Park", "réalisateur" : { "prénom" : "Steven", "nom" : "Spielberg" }, "année" : 1990, "acteurs" : [ { "prénom" : "Sam", "nom" : "Neil" }, { "prénom" : "Laura", "nom" : "Dern" } ] })
> db.movies.insert({ "_id" : "movie:4", "titre" : "Avengers", "année" : 2012 })
> db.movies.insert({ "_id" : "movie:5", "titre" : "Hobbit", "année" : 2012 })

Constatez que nous avons rentré 2 fois le nom et prénom du champ acteurs pour les 2 premiers documents crées.

Utilisez ensuite la commande find pour vérifier que les 5 documents ont bien été crées dans la collection movies

> db.movies.find()
{ "_id" : "movie:1", "titre" : "Batman", "année" : 1989, "acteurs" : [ { "prénom" : "Michael", "nom" : "Keaton" } ] }
{ "_id" : "movie:2", "titre" : "Beetlejuice", "année" : 1988, "acteurs" : [ { "prénom" : "Michael", "nom" : "Keaton" }, { "prénom" : "Geena", "nom" : "Davis" } ] }
{ "_id" : "movie:3", "titre" : "Jurassik Park", "réalisateur" : { "prénom" : "Steven", "nom" : "Spielberg" }, "année" : 1990, "acteurs" : [ { "prénom" : "Sam", "nom" : "Neil" }, { "prénom" : "Laura", "nom" : "Dern" } ] }
{ "_id" : "movie:4", "titre" : "Avengers", "année" : 2012 }
{ "_id" : "movie:5", "titre" : "Hobbit", "année" : 2012 }
>

Modifiez ensuite un des champs du document (le document ayant par exemple pour _id : movie 3). Pour cela, utilisez la commande update

> db.movies.update({"_id": "movie:3"}, {$set: {titre: "le parc des dinausores"}})

En retour, on nous indique que la modification d'un champ a bien été effectué

WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })

Vérifiez que le champ a bien été modifié dans le document en consultant la collection movies avec la commande find

> db.movies.find()
{ "_id" : "movie:1", "titre" : "Batman", "année" : 1989, "acteurs" : [ { "prénom" : "Michael", "nom" : "Keaton" } ] }
{ "_id" : "movie:2", "titre" : "Beetlejuice", "année" : 1988, "acteurs" : [ { "prénom" : "Michael", "nom" : "Keaton" }, { "prénom" : "Geena", "nom" : "Davis" } ] }
{ "_id" : "movie:3", "titre" : "le parc des dinausores", "réalisateur" : { "prénom" : "Steven", "nom" : "Spielberg" }, "année" : 1990, "acteurs" : [ { "prénom" : "Sam", "nom" : "Neil" }, { "prénom" : "Laura", "nom" : "Dern" } ] }
{ "_id" : "movie:4", "titre" : "Avengers", "année" : 2012 }
{ "_id" : "movie:5", "titre" : "Hobbit", "année" : 2012 }
>

On constate que le titre du film ayant pour id : movie 3 a bien été modifié

On peut aussi faire une requête plus précise en recherchant par exemple les films sans le réalisateur

> db.movies.find({"réalisateur": null})
{ "_id" : "movie:1", "titre" : "Batman", "année" : 1989, "acteurs" : [ { "prénom" : "Michael", "nom" : "Keaton" } ] }
{ "_id" : "movie:2", "titre" : "Beetlejuice", "année" : 1988, "acteurs" : [ { "prénom" : "Michael", "nom" : "Keaton" }, { "prénom" : "Geena", "nom" : "Davis" } ] }
{ "_id" : "movie:4", "titre" : "Avengers", "année" : 2012 }
{ "_id" : "movie:5", "titre" : "Hobbit", "année" : 2012 }
>

Constatez le résultat: il n'y a que les documents sans le champ réalisateur qui sont affichés

Si on veut supprimer un document de la collection movies, on utilise la commande remove. Supprimez par exemple le premier document

> db.movies.remove({"titre": "Batman"})
WriteResult({ "nRemoved" : 1 })

Si on consulte à nouveau la collection contenant les documents, on constate que le premier document a bien disparu

> db.movies.find()
{ "_id" : "movie:2", "titre" : "Beetlejuice", "année" : 1988, "acteurs" : [ { "prénom" : "Michael", "nom" : "Keaton" }, { "prénom" : "Geena", "nom" : "Davis" } ] }
{ "_id" : "movie:3", "titre" : "le parc des dinausores", "réalisateur" : { "prénom" : "Steven", "nom" : "Spielberg" }, "année" : 1990, "acteurs" : [ { "prénom" : "Sam", "nom" : "Neil" }, { "prénom" : "Laura", "nom" : "Dern" } ] }
{ "_id" : "movie:4", "titre" : "Avengers", "année" : 2012 }
{ "_id" : "movie:5", "titre" : "Hobbit", "année" : 2012 }
>

Si on supprime maintenant le 4ème document ayant le champ “année” : 2012, on a comme résultat:

> db.movies.remove({"année": 2012})
WriteResult({ "nRemoved" : 2 })

On constate que 2 documents ont été supprimés. Si on vérifie la collection, on obtient en effet:

{ "_id" : "movie:2", "titre" : "Beetlejuice", "année" : 1988, "acteurs" : [ { "prénom" : "Michael", "nom" : "Keaton" }, { "prénom" : "Geena", "nom" : "Davis" } ] }
{ "_id" : "movie:3", "titre" : "le parc des dinausores", "réalisateur" : { "prénom" : "Steven", "nom" : "Spielberg" }, "année" : 1990, "acteurs" : [ { "prénom" : "Sam", "nom" : "Neil" }, { "prénom" : "Laura", "nom" : "Dern" } ] }

En ayant supprimé le 4ème document (“_id” : “movie:4”) ayant le champ “année” : 2012, on a aussi supprimé le 5ème document (“_id” : “movie:5”) puisque qu'il contenait aussi le même champ “année” : 2012.
Or, on voulait juste supprimer le 4ème document (ayant pour index “_id” : “movie:4”) dans la collection movies.

<note important>Avec MongoDB, quand on veut supprimer un document en particulier, il faut donc aussi bien faire attention de préciser dans la requête le champ ayant de préférence une valeur spécifique (ou unique) associé au document à supprimer.</note>

Donc si on veut juste supprimer le 4ème document en particulier (avec le champ “_id” : “movie:4”) sans toucher aux autres documents de la collection movies, il aurait fallu entrer dans la commande remove le champ du 4ème document ayant une valeur spécifique (ou unique) comme “titre” : “Avengers” ou bien “_id” : “movie:4” de la façon suivante:

> db.movies.remove({"titre" : "Avengers"})

ou bien encore:

> db.movies.remove({"_id" : "movie:4"})

En conclusion, à travers cette exemple, on constate que bien que MongoDB garantit un certain avantage dans la flexibilité au niveau des données stockées dans les documents, cela peut s'avérer dans certains cas préjudiciable pour l'utilisateur lorsqu'il est amené a effectuer des requêtes.