Vous êtes sur la page 1sur 163

A

Les bases de données NoSQL I


A N
N A
i l E
Adil ENAANAI
adil.enaanai@gmail.com

A d
Département d’Informatique
Sup’Technology-Casablanca-
PLAN
Introduction
A I
MongoDB
A N
Cassandra
N A
Neo4J
il E
A d
A I
Chapitre 1
A N
Introduction aux bases de
A
données NoSQL
N
il E
A d
Introduction

Les bases de données relationnelles

• Structure de données A I
Les bases de données de données relationnelles sont basées sur trois éléments :

• Des contraintes
• Des opérations A N
N A
Limites:
il E
• La distribution de données sur plusieurs serveurs devient impossible dans le

A d
cas où il y’a un très grand nombre de relations.
• Le temps consacré à la vérification des contraintes est élevé par rapport au
simple stockage sans contraintes.
• Les données doivent suivre la structure d’un schéma défini préalablement.
Donc, il n y’a pas de possibilité de sauvegarder des données semi structurées
Introduction

Pourquoi NoSQL?

A I
Avec l’augmentation exponentielle des données mondiales, on a commencé à
analyser et traiter les données massives (Big data). Donc, il est nécessaire de

A N
concevoir un SGBD léger qui garantit les points suivants:

• Distribution des données


N A


La haut disponibilité
La tolérance aux pannes
il E


A d
L’extensibilité horizontale
L’hétérogénéité de données
• La rapidité
Introduction

Types de bases de données

A I
A N
N A
il E
A d
Introduction

NoSQL orientées colonnes


Structure
A I
A N
N A
il E
A d
Introduction

NoSQL orientées colonnes


Exemple
Personnel

A I
Contact

N
Row Key Prénom Age téléphone ville

A
Juvénal 22 06 90 98 76 52 Douala
timestamp: timestamp: timestamp: timestamp:

A
10/09/2011 13:05:17:09 10/09/2011 13:05:17:09 10/09/2011 13:05:17:09 10/09/2011 13:05:17:09

00001
25

N
timestamp:

E
20/09/2013 15:00:05:09
Lille
timestamp:
20/09/2013 15:00:05:09

d il Paris
timestamp:
30/10/2016 16:18:50:10

00002
Paul
timestamp: A
10/09/2011 13:10:05:09
30
timestamp: 10/09/2011
13:10:05:09
07 90 94 86 52
timestamp:
10/09/2011 13:10:05:09
Nancy
timestamp:
10/09/2011 13:10:05:09

Jean 34 06 74 98 76 25 Marseille
00003 timestamp: timestamp: timestamp: timestamp:
12/09/2011 11:30:20:09 12/09/2011 11:30:20:09 12/09/2011 11:30:20:09 12/09/2011 11:30:20:09
Introduction

NoSQL orientées document


Structure
A I
A N
N A
il E
A d
Introduction

NoSQL orientées document


Exemple
A I
A N
N A
il E
A d
Introduction

NoSQL orientées Clé/Valeur


Structure Exemple
A I
A N
N A
il E
A d
Introduction

NoSQL orientées Graphe


Structure
A I
A N
N A
il E
A d
Introduction

NoSQL orientées Graphe


Exemple
A I
A N
N A
il E
A d
Introduction

Notion de cluster

A I
Un Cluster est un ensemble de machines interconnectées.
Les données d’une base NoSQL sont distribuées sur les différentes machines

A N
N A
il E
A d
Introduction

Le partitionnement (Sharding)
Le partitionnement consiste à
A I
• découper une (grande) collection en fragments en fonction d’une clé
• placer chaque fragment sur un serveur
A N
fragment sur tel serveur
N A
• Maintenir un répertoire indiquant que telle clé se trouve dans tel

il E
Le partitionnement apporte la répartition de charge (load balancing )

“élastiquement”
A d
Il doit être dynamique (ajout/retrait de serveurs) pour s’adapter

S’applique à des collections de paires (clé, valeur), où valeur est


n’importe quelle information structurée.
Introduction

Le partitionnement (Sharding)
La clé de partitionnement
A I
La clé indique à quel fragment appartient un document.

A N
Si un grand nombre de documents partagent la même clé, ils ne

souplesse de distribution.
N A
peuvent être que dans le même fragment => le système perd en

E
La valeur de la clé pour un document ne devrait pas être modifiable
il
(nécessité de
déplacement).
A d
L’identifiant séquentiel d’un document est un bon choix
Introduction

Le partitionnement (Sharding)
Avec catalogue
Où se trouve l’élément
A I
de clé #13?

A N
N A
La clé #13 se trouve

il
dans le serveur 2 E Client

A d
Server1 Server2 Server3 Server4 Server5
Introduction

Distribution de données

nœuds. Il y a 2 façons de répartir les données :


A I
Dans un cluster, les partitions dans une table sont réparties entre plusieurs

1) De manière ordonnée, chaque


A N
nœud prend en charge une plage de
clé de partition triée par ordre
N A
croissant.
il E
A d
Exemple : si la clé de partition est le
nom de famille, les noms
commençant entre A et E se
répartissent sur le noeud1, entre F et
J sur le noeud2 etc...
Introduction

Distribution de données

nœuds. Il y a 2 façons de répartir les données :


A I
Dans un cluster, les partitions dans une table sont réparties entre plusieurs

2) De manière aléatoire, chaque


A N
nœud prend en charge une plage de
la clé de partition distribuée
N A
uniformément

il E
Si l'on prend le hash MD5, la valeur

A d
du token se situe dans l'intervalle [0
.. 2127-1]. On répartit uniformément
cette plage de valeur de token entre
les différents noeuds du cluster.
Introduction

Distribution de données
Le nœud coordinateur

A I
Dans un cluster, les partitions dans une table sont réparties entre plusieurs

A N
nœuds. Il y a 2 façons de répartir les données :
Une architecture sans maître/esclave garantit l'absence de point unique de
A
défaillance (SPOF). Par contre, pendant la durée d'une requête (lecture ou
N
il E
écriture), le client fournit toujours une #partition. Le noeud qui reçoit la
requête ne l'exécute pas nécessairement en local car le hash de cette

responsable.
A d
#partition ne tombe pas forcément dans la plage de hash dont il est

Il va rediriger cette requête vers un autre noeud du cluster responsable de ces


données. Dans ce cas là, il jouera le rôle de noeud coordinateur pour la
requête actuelle.
Introduction

Distribution de données
Le nœud coordinateur

A I
A N
N A
il E
A d
Introduction

Exemple de SGBD NoSQL

A I
A N
N A
il E
A d
A I
Chapitre 2
A N
A
MongoDB
N
il E
A d
Installation

Pour bien fonctionner, une base MongoDB a besoin de trois choses :

https://www.mongodb.com/download-center/community
A I
1) L’installation du serveur, que vous pouvez télécharger ici:

A N
2) La création d’un répertoire pour stocker les données. Par exemple :
C:\data\db (par défaut)
N A
il E
3) Le lancement du serveur, avec l’exécutable mongod (disponible sur
$MONGO/bin)

A d
Installation

Interface utilisateur

A I
Maintenant que le serveur tourne, on peut s’attaquer à son administration avec
une interface graphique. Vous pouvez télécharger MongodbCompass par
N
exemple: https://www.mongodb.com/download-center/compass
A
N A
il E
A d
Solution cloud

Vous pouvez aussi utiliser la solution cloud sur le lien:


https://www.mongodb.com/cloud

A I
A N
N A
il E
A d
Cliquer sur « Login » et saisir vos données d’authentification si vous
avez déjà un compte. Sinon cliquer sur « Get started now » et créer un
compte
Solution cloud

Dans le menu à gauche, cliquer sur « Projects », puis sur «New Project »

A I
A N
N A
il E
A d
Taper le nom de votre projet
et cliquer sur « Next »
Solution cloud

Dans le menu à gauche, cliquer sur « Projects », puis sur «New Project »

A I
A N
N A
il E
A d
Taper le nom de votre projet
et cliquer sur « Next »
Solution cloud

Cliquer sur « Create project »

A I
A N
N A
il E
A d
Solution cloud

Quand vous voyez cet interface, cliquer sur « Build a Cluster »

A I
A N
N A
il E
A d
Solution cloud

Sélectionner ensuite le choix qui vous convient

A I
A N
N A
il E
A d
Solution cloud

Ensuite, choisissez le fournisseur Cloud que vous souhaitez et cliquer sur


« Create Cluster »

A I
A N
N A
il E
A d
Solution cloud

Quand votre Cluster et prêt, cliquer sur « Connect »

A I
A N
N A
il E
A d
Solution cloud

Ecrire votre adresse IP et


cliquer sur « Add IP Address »

A I
A N
N A
Saisir les données
d’authentification et cliquer
il E
A d
sur « Create MongoDB User »
Solution cloud

Choisissez la méthode de gestion de base de données. Dans ce cours, nous


allons utiliser La GUI MongoDBCompass

A I
A N
N A
il E
A d
Solution cloud

Si vous n’avez pas encore téléchargé MongoDB Compass, vous pouvez le


télécharger de cet interface.

A I
A N
N A
il E
A d Copier le lien de connexion
Solution cloud

Lancer maintenant MongoDB Compass et créer une nouvelle connexion

A I
A N
N A
Coller le lien que vous avez copié déjà

il E
A d
N’oublier pas de mettre votre mot de passe ici
Solution cloud

Maintenant, vous pouvez voir la liste des bases de données, et même créer une

A I
A N
N A
il E
A d
Manipulation

Lors de la création de la base de données SupTech, on vous propose de créer


une collection (Table).

A I
Capped collection est une
A N
collection de taille fixe.
Lorsqu’on atteint la fin, on
N A
commence à remplacer les
anciens documents par les
il E
nouveaux
A d
Manipulation

A chaque moment, vous pouvez créer une


nouvelle collection en cliquant sur le +

A I
Tester en créant la collection professeur

A N
N A
Cliquer sur la collection
il E
A d
« Etudiant » et commencer
à manipuler la collection
Manipulation

Importer les données externes


Vous avez le choix entre l’importation de fichier JSON ou CSV

A I
A N
A
Dans ce cours, nous allons utiliser le fichier « Etudiants.json »

N
il E
A d
Manipulation

Importer les données externes


Vous pouvez voir vos données importées

A I
A N
N A
il E Ajouter un nouveau document

A d
Manipulation

Importer les données externes


Vous saisissez le document sous format JSON

A I
A N
N A
il E
A d
MongoShell

mongoShell

A I
Le mongoshell est une interface JavaScript interactive pour MongoDB. Vous
pouvez utiliser le mongoshell pour interroger et mettre à jour des données

A N
ainsi que pour effectuer des opérations administratives.
Assurez-vous que MongoDB est en cours d'exécution avant de tenter de
démarrer le mongoshell.
N A
il E
Ouvrez une fenêtre de terminal (ou une invite de commande pour Windows)
et accédez à votre répertoire: <mongodb installation dir>/bin

A d
cd <répertoire d'installation de mongodb>/bin
Vous pouvez exécuter le mongoshell sans aucune option de ligne de commande
pour vous connecter à une instance MongoDB exécutée sur votre hôte local
avec le port par défaut 27017. La commande est: mongo
MongoShell

mongoShell
Instance MongoDB sur un hôte distant

A I
Pour spécifier explicitement le nom d'hôte et / ou le port,

A N
Vous pouvez spécifier une chaîne de connexion . Par exemple, pour vous
A
connecter à une instance MongoDB exécutée sur une machine hôte distante:
N
E
mongo "mongodb: //serverMDB.com: 28015"

il
A d
Vous pouvez utiliser l'option de ligne de commande . Par exemple, pour vous
connecter à une instance MongoDB exécutée sur une machine hôte distante:--
host <host>:<port>
mongo --host serverMDB.com:28015
Manipulation

Les requêtes MongoDB -Créer une base de données-

A I
La commande use DATABASE_NAME est utilisé pour créer la base de
données. La commande créera une nouvelle base de données si elle n'existe

use DATABASE_NAME A N
pas, sinon elle retournera la base de données existante.

Exemple
N A
Si vous souhaitez utiliser une base de données avec le nom <mydb> , alors

il
utiliser l'instruction suivante E
A d >use mydb
switched to db mydb
Pour vérifier votre base de données actuellement sélectionnée, utilisez la
commande db >db
mydb
Manipulation

Les requêtes MongoDB -Créer une base de données-

commande show dbs . >show dbs


A I
Si vous souhaitez vérifier votre liste de bases de données, utilisez la

local 0.78125GB
A N
test 0.23012GB

N A
Votre base de données créée (mydb) n'est pas présente dans la liste. Pour

il E
afficher la base de données, vous devez y insérer au moins un document.

>show dbs
A d
>db.movie.insert({"name":“ENAANAI"})

local 0.78125GB
mydb 0.23012GB
test 0.23012GB
Manipulation

Les requêtes MongoDB -Supprimer une base de données-

base de données existante.


A I
La commande MongoDB db.dropDatabase () est utilisée pour supprimer une

db.dropDatabase()
A N
N A
Cela supprimera la base de données sélectionnée. Si vous n'avez sélectionné
aucune base de données, elle supprimera la base de données «test» par défaut.
>use mydb
switched to db mydb
il E
A d
>db.dropDatabase()
>{ "dropped" : "mydb", "ok" : 1 }
>
Manipulation

Les requêtes MongoDB -Créer une collection-


La syntaxe de base de la commande createCollection () est la suivante:
db.createCollection(name, options)
A I
Voici la liste des options que vous pouvez utiliser:
A N
A
Champ Type La description

N
(Facultatif) Si vrai, active une collection plafonnée. La collection plafonnée est une
collection de taille fixe qui écrase automatiquement ses entrées les plus anciennes lorsqu'elle
capped Booléen

E
atteint sa taille maximale. Si vous spécifiez true, vous devez également spécifier le

il
paramètre de taille.

autoIndexId

size
Booléen

nombre A d
(Facultatif) Si vrai, créez automatiquement un index sur _id field.s La valeur par défaut est
false.
(Facultatif) Spécifie une taille maximale en octets pour une collection plafonnée. Si
plafonné est vrai, vous devez également spécifier ce champ.
(Facultatif) Spécifie le nombre maximal de documents autorisés dans la collection
max nombre
plafonnée.
Manipulation

Les requêtes MongoDB -Créer une collection-


Examples

A I
La syntaxe de base de la méthode createCollection () sans options est la
suivante >use test
A N
switched to db test

N A
>db.createCollection("mycollection")
{ "ok" : 1 }
>
il E
collections . A d
Vous pouvez vérifier la collection créée à l'aide de la commande show

>show collections
mycollection
system.indexes
Manipulation

Les requêtes MongoDB -Créer une collection-


Examples

A I
L'exemple suivant montre la syntaxe de la méthode createCollection () avec
quelques options importantes:
A N
6142800, max : 10000 } ){
N A
> db.createCollection("mycol", { capped : true, autoIndexID : true, size :

"ok" : 0,

il E
"errmsg" : "BSON field 'create.autoIndexID' is an unknown field.",
"code" : 40415,
A d
"codeName" : "Location40415"
}
> Dans MongoDB, vous n'avez pas besoin de créer de collection. MongoDB
crée automatiquement une collection lorsque vous insérez un document.
Manipulation

Les requêtes MongoDB -Insérer un document-

>db.COLLECTION_NAME.insert(document)
A I
La syntaxe de base de la commande insert () est la suivante:

Exemple
A N
> db.users.insert({

N A
... _id : ObjectId("507f191e810c19729de860ea"),

E
... title: "MongoDB",

il
... description: "MongoDB is no sql database",
... by: "Adil ENAANAI",

A d
... url: "https://www.mongodb.com",
... tags: ['mongodb', 'database', 'NoSQL'],
... likes: 100
Vous pouvez également passer
un tableau de documents dans
la méthode insert ()
... })
WriteResult({ "nInserted" : 1 })
>
Manipulation

Les requêtes MongoDB -Insérer un document-


La méthode insertOne()

A I
Si vous devez insérer un seul document dans une collection, vous pouvez
utiliser cette méthode
A N
> db.empDetails.insertOne(
{
N A
First_Name: "Adil",

il E
Last_Name: "ENAANAI",
Email: "enaanai@gmail.com",

{
})

A d
"acknowledged" : true,
"insertedId" : ObjectId("5dd62b4070fb13eec3963bea")
}
>
Manipulation

Les requêtes MongoDB -Insérer un document-


La méthode insertMany()

A I
Vous pouvez insérer plusieurs documents à l'aide de la méthode insertMany ().
N
Pour cette méthode, vous devez transmettre un tableau de documents.
A
> db.empDetails.insertMany(
[{
N A
E
First_Name: "Adil",

il
Last_Name: "ENAANAI",
Email: "enaanai@gmail.com",

A d{
},

First_Name: "Mohamed",
Last_Name: "SAFIR",
Email: "safir@gmail.com",
}]
)
Manipulation

Les requêtes MongoDB -Modifier un document-


La méthode Update ()

A I
La méthode update () met à jour les valeurs dans le document existant.
Syntaxe
A N
Exemple
N A
db.COLLECTION_NAME.update(SELECTION_CRITERIA, UPDATED_DATA)

il E
L'exemple suivant définira le nouveau titre «New MongoDB» des documents
dont le titre est «MongoDB».

A d
db.mycol.update({'title':'MongoDB'},{$set:{'title':'New MongoDB'}})
Par défaut, MongoDB ne mettra à jour qu'un seul document. Pour mettre à jour
plusieurs documents, vous devez définir un paramètre «multi» sur true.
db.mycol.update({'title':'MongoDB'},{$set:{'title':'New MongoDB'}},{multi:true})
Manipulation

Les requêtes MongoDB -Modifier un document-


La méthode Save ()

A I
La méthode save () remplace le document existant par le nouveau document
passé dans la méthode save ().
A N
Syntaxe

N A
db.COLLECTION_NAME.save({_id:ObjectId(),NEW_DATA})
Exemple

il E
L'exemple suivant remplacera le document par le _id '5983548781331adf45ec5'.
db.mycol.save(
A d
{"_id" : ObjectId("507f191e810c19729de860ea"),
"title":"Cours MongoDB", "by":"SupTech" }
)
Manipulation

Les requêtes MongoDB -Modifier un document-


La méthode findOneAndUpdate()

A I
La méthode findOneAndUpdate () met à jour les valeurs dans le document
existant.
A N
Syntaxe

N A
db.COLLECTION_NAME. findOneAndUpdate(SELECTION_CRITERIA, UPDATED_DATA)
Exemple

il E
A d
db.empDetails.findOneAndUpdate(
{First_Name: 'Adil'},
{ $set: { Age: '30',e_mail: ‘enaanai@gmail.com'}}
)
Manipulation

Les requêtes MongoDB -Modifier un document-


La méthode updateOne()

A I
Cette méthode met à jour un document unique qui correspond au filtre donné.

A N
Syntaxe

N A
db.COLLECTION_NAME.updateOne(<filter>, <update>)
Exemple

il E
A d
db.empDetails.updateOne(
{First_Name: 'Adil'},
{ $set: { Age: '39',e_mail: 'enaanai@gmail.com'}}
)
Manipulation

Les requêtes MongoDB -Modifier un document-


La méthode updateMany()

A I
La méthode updateMany () met à jour tous les documents qui correspondent
au filtre donné.
A N
Syntaxe

N A
db.COLLECTION_NAME.updateMany(<filter>, <update>)
Exemple

il E
A d
db.empDetails.updateMany(
{Age:{ $gt: "25" }},
{ $set: { Age: '00'}}
)
Manipulation

Les requêtes MongoDB -Supprimer un document-


La méthode remove()

A I
La méthode remove() de MongoDB est utilisée pour supprimer un document
de la collection.
A N
Syntaxe

N A
db.COLLECTION_NAME.remove(DELLETION_CRITTERIA)
Exemple

il E
L'exemple suivant supprimera tous les documents dont le titre est «MongoDB».

d
db.empDetails.remove({Age:{ $gt: "25" }})
A
Manipulation

Les requêtes MongoDB -Supprimer un document-


La méthode remove()
Supprimer un seul
A I
A N
S'il existe plusieurs enregistrements et que vous souhaitez supprimer

la méthode remove () .
N A
uniquement le premier enregistrement, définissez le paramètre justOne dans

E
db.COLLECTION_NAME.remove(DELETION_CRITERIA,1)

il
A d
Supprimer tous les documents
Si vous ne spécifiez pas de critères de suppression, MongoDB supprimera des
documents entiers de la collection. C'est l'équivalent de la commande
truncate de SQL. db.mycol.remove({})
Manipulation

Les requêtes MongoDB -Interroger un document-


La méthode find()

A I
Pour interroger les données de la collection MongoDB, vous devez utiliser la
méthode find () de MongoDB.
Syntaxe
A N
db.COLLECTION_NAME.find()
N A
il E
La méthode pretty()

A d
Pour afficher les résultats de manière formatée, vous pouvez utiliser la
méthode pretty ().
Syntaxe
db.COLLECTION_NAME.find().pretty()
Manipulation

Les requêtes MongoDB -Interroger un document-


La méthode findOne()

A I
Outre la méthode find (), il existe la méthode findOne () , qui ne renvoie qu'un
seul document.
Syntaxe
A N
db.COLLECTION_NAME.findOne()
N A
Exemple

il E
d
db.mycol.findOne({title: "MongoDB"})

A
Manipulation

Les requêtes MongoDB -Interroger un document-


Les clauses MongoDB
SQL
A I
MongoDB
where prenom = 'adil'
A N
db.mycol.find({"prenom":"adil"}).pretty()
where age < 50
where age <= 50
N A
db.mycol.find({"age":{$lt:50}}).pretty()
db.mycol.find({"age":{$lte:50}}).pretty()
where age > 50

il E
db.mycol.find({"age":{$gt:50}}).pretty()
where age >= 50
where age != 50
A d
Where prenom in ("adil", "kamal",
db.mycol.find({"age":{$gte:50}}).pretty()
db.mycol.find({"age":{$ne:50}}).pretty()
db.mycol.find({"name":{$in:[("adil", "kamal",
"Ahmed") "Ahmed"]}}).pretty()
Where prenom not in ("adil", "kamal", db.mycol.find({"name":{$nin:[("adil", "kamal",
"Ahmed") "Ahmed"]}}).pretty()
Manipulation

Les requêtes MongoDB -Interroger un document-


Le ET logique
Syntaxe
A I
A N
db.mycol.find({ $and: [ {<key1>:<value1>}, { <key2>:<value2>} ] })
Exemple

N A
Le OU logique
il E
db.mycol.find({$and:[{"prenom":"adil"},{"title": "MongoDB"}]}).pretty()

Syntaxe
A d
db.mycol.find({ $or: [ {<key1>:<value1>}, { <key2>:<value2>} ] })
Exemple
db.mycol.find({$or:[{"prenom":"adil"},{"title": "MongoDB"}]}).pretty()
Manipulation

Les requêtes MongoDB -Interroger un document-


Utiliser AND et OR ensemble
Exemple
A I
A N
db.mycol.find({"age": {$gt:10}, $or: [{"prenom": "adil"},
{"title": "MongoDB"}]}).pretty()

N A
La négation
Exemple
il E
A d
db.empDetails.find( { "Age": { $not: { $gt: "25" } } } )
Manipulation

Les requêtes MongoDB -La projection-

A I
Dans MongoDB, lorsque vous exécutez la méthode find(), elle affiche tous les

A N
champs d'un document. Pour limiter cela, vous devez définir une liste de
champs avec la valeur 1 ou 0. 1 est utilisé pour afficher le champ tandis que 0
est utilisé pour masquer les champs.
N A
il E
db.mycol.find({},{"title":1,_id:0})

A d
Manipulation

Les requêtes MongoDB -Limitation des résultats-


La méthode limit()

A I
Pour limiter les enregistrements dans MongoDB, vous devez utiliser la méthode

de documents que vous souhaitez afficher.


A N
limit () . La méthode accepte un argument de type numérique, qui est le nombre

N A
db.mycol.find({},{"title":1,_id:0}).limit(2)

La méthode skip()
il E
A d
Outre la méthode limit (), il existe une autre méthode skip () qui accepte
également l'argument de type numérique et est utilisée pour ignorer le nombre
de documents.
db.mycol.find({},{"title":1,_id:0}).limit(1).skip(1)
Manipulation

Les requêtes MongoDB -Trier des résultats-


La méthode sort()

A I
Pour spécifier l'ordre de tri 1 et -1 sont utilisés. 1 est utilisé pour l'ordre
N
croissant tandis que -1 est utilisé pour l'ordre décroissant.
A
A
db.mycol.find({},{"title":1,_id:0}).sort({"title":-1})

N
il E
A d
Manipulation

Les requêtes MongoDB -Créer les index-


La méthode createIndex()

A I
Les index prennent en charge la résolution efficace des requêtes. Sans index,

A N
MongoDB doit analyser chaque document d'une collection pour sélectionner les
documents qui correspondent à l'instruction de requête. Cette analyse est très

N A
inefficace et nécessite MongoDB pour traiter un grand volume de données.
Les index sont des structures de données spéciales, qui stockent une petite

il E
partie de l'ensemble de données sous une forme facile à parcourir. L'index

A d
stocke la valeur d'un champ spécifique ou d'un ensemble de champs, triée par la
valeur du champ comme spécifié dans l'index.
db.mycol.createIndex({"title":1,"description":-1})
Manipulation

Les requêtes MongoDB -L’aggregation-


La méthode aggregate()

A I
si vous souhaitez afficher une liste indiquant le nombre de didacticiels écrits par
N
chaque utilisateur, vous utiliserez la méthode d'agrégat()
A
A
db.Employe.aggregate([{$group:{_id:"$sexe",moyenne_age:{$avg:"$age"}}}])
N
E
La requête équivalente SQL pour le cas d'utilisation ci-dessus sera
il
A d
select user, count(*) from mycol group by user.
Dans l'exemple ci-dessus, nous avons regroupé les documents par champ
by_user et à chaque occurrence de par utilisateur, la valeur précédente de sum
est incrémentée.
Manipulation

Exercice

1. Liste de tous les livres (type « Book ») ;


A I
Exprimez des requêtes simples (pas de MapReduce) pour les recherches suivantes :

2. Liste des publications depuis 2011 ;


3. Liste des livres depuis 2014 ;
A N
N A
4. Liste des publications de l’auteur « Toru Ishida » ;
5. Liste de tous les éditeurs (type « publisher »), distincts ;

il E
6. Liste de tous les auteurs distincts ;
7. Trier les publications de « Toru Ishida » par titre de livre et par page de début ;

A d
8. Projeter le résultat sur le titre de la publication, et les pages ;
9. Compter le nombre de ses publications ;
10. Compter le nombre de publications depuis 2011 et par type ;
11. Compter le nombre de publications par auteur et trier le résultat par ordre croissant
Manipulation

Correction
1. db.publis.find({"type" : "Book"});
2.
3.
db.publis.find({year : {$gte : 2011}});
db.publis.find({"type" : "Book", year : {$gte : 2014}});
A I
4.
5.
db.publis.find({authors : "Toru Ishida"});
db.publis.distinct("publisher");
A N
6.
7.
db.publis.distinct("authors");

N A
db.publis.aggregate([{$match:{authors : "Toru Ishida"}}, { $sort : { booktitle : 1,
"pages.start" : 1 } }]);

il E
8. db.publis.aggregate([{$match:{authors : "Toru Ishida"}}, {$sort : { booktitle : 1,

A d
"pages.start" : 1 }}, {$project : {title : 1, pages : 1}}]);
9. db.publis.aggregate([{$match:{authors : "Toru Ishida"}}, {$group:{_id:null, total : { $sum
: 1}}}]);
10. db.publis.aggregate([{$match:{year : {$gte : 2011}}}, {$group:{_id:"$type", total : { $sum
: 1}}}]);
11. db.publis.aggregate([{ $unwind : "$authors" }, { $group : { _id : "$authors", number : {
$sum : 1 } }}, {$sort : {number : -1}}] );
Manipulation

L’imbrication d’objets
Soit le modèle relationnel suivant

A I
A N
N A
il E
A d
Manipulation

L’imbrication d’objets
La forme de données json sera comme suit:
{
A I
"id":1,
"nom":"SELLAMI",
A N
"prenom":"Nadia",
"sexe":"F",
N A
"filiere":"GL",
"cycle":"Master",
il E
d
"notes":{
"semestre1":{
A
"Angular":14,
"SI":15,
"BigData":13}
}
}
Manipulation

L’imbrication d’objets
Accès aux données imbriquées

A I
Modifier la note de la matière « BigData » de Mlle « SELLAMI »

A N
db.Etudiants.updateOne({nom:"SELLAMI"},{$set:{"notes.semestre1.BigData":10}})

A
Chercher tous les étudiants ayant 10 en BigData
N
E
db.Etudiants.find({"notes.semestre1.BigData":10})

il
Enlever le champs Big Data pour Mlle SELLAMI
d
A
db.Etudiants.update({nom:"SELLAMI"},{$unset:{"notes.semestre1.BigData":1}})
Client MongoDB en Java

Installation du pilote

I
Pour utiliser MongoDB, il faut importer le pilote à votre projet Java.

A
dépendance.
A N
Vous pouvez créer un projet Maven et importer le pilote en utilisant cette

N A
<!-- https://mvnrepository.com/artifact/org.mongodb/mongo-java-driver -->
<dependency>

il E
<groupId>org.mongodb</groupId>

d
<artifactId>mongo-java-driver</artifactId>
<version>3.12.2</version>
</dependency>
A
Client MongoDB en Java

Se connecter à la base de données et créer une collection


Pour connecter la base de données, vous devez spécifier le nom de la base de
I
données, si la base de données n'existe pas, MongoDB la crée automatiquement.
A
N
public class MongoDBTest {
public static void main( String args[] ) {
// Creating a Mongo client

A A
MongoClient mongo = new MongoClient( "localhost" , 27017 );
// Creating Credentials
MongoCredential credential;

E N
credential = MongoCredential.createCredential("adil", "myDb","1234".toCharArray());

il
System.out.println("Connected to the database successfully");
// Accessing the database

d
MongoDatabase database = mongo.getDatabase("myDb");

A
System.out.println("Credentials ::"+ credential);
//Creating a collection
database.createCollection("Person");
System.out.println("Collection created successfully");
}
}
Client MongoDB en Java

Sélectionner une collection

A I
Pour obtenir / sélectionner une collection à partir de la base de données, la
méthode getCollection() de la classe com.mongodb.client.MongoDatabase est
utilisée.
import com.mongodb.client.MongoCollection;

A N
A
import com.mongodb.client.MongoDatabase;
import org.bson.Document;
import
import
public
com.mongodb.MongoClient;
com.mongodb.MongoCredential;
class ConnectToDB {
E N
d
// Creating a Mongo client il
public static void main( String args[] ) {

A
// Creating Credentials
// Accessing the database
// Creating a collection
// Retrieving a collection
MongoCollection<Document> collection = database.getCollection("Person");
System.out.println("Collection myCollection selected successfully");
}
}
Client MongoDB en Java

Insérer un document

com.mongodb.client.MongoCollection est utilisée.


A I
Pour insérer un document dans MongoDB, la méthode insert() de la classe

import com.mongodb.client.MongoCollection;

A N
A
import com.mongodb.client.MongoDatabase;
import org.bson.Document;
import com.mongodb.MongoClient;
import com.mongodb.MongoCredential;
public class ConnectToDB {
E N
il
public static void main( String args[] ) {
// Creating a Mongo client // Creating Credentials // Accessing the database

"adil.enaanai@gmail.com");
A d
// Creating a collection // Retrieving a collection
Document document = new Document("nom", "ENAANAI").append("prenom", "Adil").append("email",

//Inserting document into the collection


collection.insertOne(document);
System.out.println("Document inserted successfully");
}
}
Client MongoDB en Java

Insérer et récupérer plusieurs documents


public class ConnectToDB {
public static void main( String args[] ) {
// Creating a Mongo client // Creating Credentials
A I
// Accessing the database

N
// Creating a collection // Retrieving a collection
Document document1 = new Document("nom", "MARFOUK").append("prenom", "Youssef").append("email",
"youssef.marfouk@gmail.com");

A A
Document document2 = new Document("nom", "SAFIR").append("prenom", "Laila").append("email",
"laila.safir@gmail.com");

list.add(document1);
list.add(document2);
E N
List<Document> list = new ArrayList<Document>();

il
collection.insertMany(list);
// Getting the iterable object

int i = 1;
// Getting the iterator d
FindIterable<Document> iterDoc = collection.find();

A
Iterator it = iterDoc.iterator();
while (it.hasNext()) {
System.out.println(it.next());
i++;
} }
}
Client MongoDB en Java

Mettre à jour le document


public class ConnectToDB {
public static void main( String args[] ) {
// Creating a Mongo client // Creating Credentials
A I
// Accessing the database

N
// Creating a collection // Retrieving a collection

collection.updateOne(Filters.eq("nom", "SAFIR"),

A A
Updates.combine(Updates.set("prenom", "Amine"),Updates.set("email", "amine.safir@gmail.com")));
System.out.println("Document update successfully...");

// Getting the iterable object


E N
// Retrieving the documents after updation

il
FindIterable<Document> iterDoc = collection.find();
int i = 1;

d
// Getting the iterator

A
Iterator it = iterDoc.iterator();
while (it.hasNext()) {
System.out.println(it.next());
i++;
}
}
}
Client MongoDB en Java

Supprimer un document
public class ConnectToDB {
public static void main( String args[] ) {
// Creating a Mongo client // Creating Credentials
A I
// Accessing the database

N
// Creating a collection // Retrieving a collection

// Deleting the documents

A
collection.deleteOne(Filters.eq("nom", "SAFIR"));
System.out.println("Document deleted successfully..."); A
// Getting the iterable object
E N
// Retrieving the documents after updation

il
FindIterable<Document> iterDoc = collection.find();
int i = 1;

d
// Getting the iterator

A
Iterator it = iterDoc.iterator();
while (it.hasNext()) {
System.out.println(it.next());
i++;
}
}
}
Client MongoDB en Python

PyMongo

MongoDB.
A I
Python a besoin d'un pilote MongoDB pour accéder à la base de données

A N
Nous vous recommandons d'utiliser PIP pour installer "PyMongo".
PIP est probablement déjà installé dans votre environnement Python.

qui suit:
N A
Accédez à votre ligne de commande jusqu'à l'emplacement de PIP et tapez ce

il E
C:\Users\ADIL\AppData\Local\Programs\Python\Python38\Scripts>pip install pymongo

A d
Client MongoDB en Python

Créer une base de données

A I
Pour créer une base de données dans MongoDB, commencez par créer un objet
MongoClient, puis spécifiez une URL de connexion avec l'adresse IP correcte et

import pymongo
A N
le nom de la base de données que vous souhaitez créer.

N A
myclient = pymongo.MongoClient("mongodb://localhost:27017/")

il
mydb = myclient["mydatabase"]
E
A d
Client MongoDB en Python

Créer une collection

A I
Pour créer une collection dans MongoDB, utilisez l'objet de base de données et
spécifiez le nom de la collection que vous souhaitez créer.

import pymongo
A N
N A
myclient = pymongo.MongoClient("mongodb://localhost:27017/")
mydb = myclient["mydatabase"]

mycol = mydb["persons"]
il E
A d
Client MongoDB en Python

Insérer un document

A I
Pour insérer un enregistrement, ou un document comme on l'appelle dans
MongoDB, dans une collection, nous utilisons la insert_one()méthode.

A N
Le premier paramètre de la insert_one()méthode est un dictionnaire contenant le
(s) nom (s) et valeur (s) de chaque champ du document que vous souhaitez
insérer.
import pymongo
N A
il E
myclient = pymongo.MongoClient("mongodb://localhost:27017/")

d
mydb = myclient["mydatabase"]
mycol = mydb["persons"]

A
mydict = { "nom": "NACIRI", "prenom": "Hassan" }

x = mycol.insert_one(mydict)
print(x.inserted_id)
Client MongoDB en Python

Insérer plusieurs documents

utilisons la méthode insert_many().


A I
Pour insérer plusieurs documents dans une collection dans MongoDB, nous

import pymongo

A N
myclient = pymongo.MongoClient("mongodb://localhost:27017/")
mydb = myclient["mydatabase"]
mycol = mydb["persons"]

N A
mylist = [

il E
{ "nom": "NACIRI", "prenom": "Mohamed"},

]
A d
{ "nom": "JALIL", "prenom": "Hasnaa"},
{ "nom": "RAHRAMOUI", "prenom": "Kenza"},

x = mycol.insert_many(mylist)

#print list of the _id values of the inserted documents:


print(x.inserted_ids)
Client MongoDB en Python

Chercher un document

utiliser la méthode find_one().


A I
Pour sélectionner les données d'une collection dans MongoDB, nous pouvons

import pymongo
A N
La méthode find_one() renvoie la première occurrence de la sélection.

N A
myclient = pymongo.MongoClient("mongodb://localhost:27017/")
mydb = myclient["mydatabase"]
mycol = mydb["persons"]

il E
x = mycol.find_one()

print(x) A d
Client MongoDB en Python

Chercher plusieurs documents

A I
La méthode find() renvoie toutes les occurrences de la sélection.
Le premier paramètre de la méthode find() est un objet de requête. Dans cet

documents de la collection.
A N
exemple, nous utilisons un objet de requête vide, qui sélectionne tous les

import pymongo

N A
il
mydb = myclient["mydatabase"] E
myclient = pymongo.MongoClient("mongodb://localhost:27017/")

A
for x in mycol.find():
print(x)
d
mycol = mydb["persons"]
Client MongoDB en Python

Renvoyer uniquement certains champs

inclure dans le résultat.


A I
Le deuxième paramètre de la find()méthode est un objet décrivant les champs à

import pymongo

A N
mydb = myclient["mydatabase"]
N A
myclient = pymongo.MongoClient("mongodb://localhost:27017/")

mycol = mydb["persons"]

il E
for x in mycol.find({},{ "_id": 0, "nom": 1, "prenom": 1 }):
print(x)

A d
Client MongoDB en Python

Filtrer le résultat

filtrer le résultat à l'aide d'un objet de requête.


A I
Lorsque vous recherchez des documents dans une collection, vous pouvez

pour limiter la recherche.


A N
Le premier argument de la méthode find() est un objet de requête et est utilisé

import pymongo

N A
myclient = pymongo.MongoClient("mongodb://localhost:27017/")
mydb = myclient["mydatabase"]
mycol = mydb["persons"]
il E
A d
myquery = { "nom": "NACIRI" }

mydoc = mycol.find(myquery)

for x in mydoc:
print(x)
Client MongoDB en Python

Requête avancée

comme valeurs dans l'objet de requête.


A I
Pour effectuer des requêtes avancées, vous pouvez utiliser des modificateurs

A N
Par exemple, pour trouver les documents où le champ "adresse" commence par
la lettre "S" ou plus (par ordre alphabétique), utilisez le modificateur supérieur à
{"$gt": "S"}
import pymongo
N A
mydb = myclient["mydatabase"]
il E
myclient = pymongo.MongoClient("mongodb://localhost:27017/")

mycol = mydb["persons"]

A d
myquery = { "nom": { "$gt": "N" } }

mydoc = mycol.find(myquery)
for x in mydoc:
print(x)
Client MongoDB en Python

Filtre avec des expressions régulières

A I
Pour rechercher uniquement les documents dont le champ "adresse" commence
par la lettre "S", utilisez l'expression régulière {"$regex": "^S"}:
import pymongo

A N
mydb = myclient["mydatabase"]
mycol = mydb["persons"]
N A
myclient = pymongo.MongoClient("mongodb://localhost:27017/")

il E
myquery = { "nom": { "$regex": "^N" } }

A d
mydoc = mycol.find(myquery)

for x in mydoc:
print(x)
Client MongoDB en Python

Supprimer un document

A I
Pour supprimer un document, nous utilisons la delete_one()méthode.
Le premier paramètre de la méthode delete_one() est un objet de requête
définissant le document à supprimer.

A N
import pymongo

N A
il
mydb = myclient["mydatabase"] E
myclient = pymongo.MongoClient("mongodb://localhost:27017/")

d
mycol = mydb["Persons"]

A
myquery = { "nom": "SAFIR" }

mycol.delete_one(myquery)
Client MongoDB en Python

Supprimer plusieurs documents

A I
Pour supprimer plusieurs documents, utilisez la méthode delete_many().
Le premier paramètre de la méthode delete_many() est un objet de requête
définissant les documents à supprimer.

A N
import pymongo

N A
myclient = pymongo.MongoClient("mongodb://localhost:27017/")

il
mydb = myclient["mydatabase"]
mycol = mydb["Persons"] E
A d
myquery = { "nom": {"$regex": "^N"} }

x = mycol.delete_many(myquery)

print(x.deleted_count, " documents deleted.")


Client MongoDB en Python

Modifier un document

A I
Vous pouvez mettre à jour un enregistrement ou un document comme il est
appelé dans MongoDB, en utilisant la méthode update_one().

définissant le document à mettre à jour.


A N
Le premier paramètre de la méthode update_one() est un objet de requête

import pymongo

N A
myclient = pymongo.MongoClient("mongodb://localhost:27017/")
mydb = myclient["mydatabase"]
mycol = mydb["Persons"]

il E
A d
myquery = { "nom": "MANSOURI" }
newvalues = { "$set": { "prenom": "Hassan" } }

mycol.update_one(myquery, newvalues)
#print "customers" after the update:
for x in mycol.find():
print(x)
Client MongoDB en Python

Modifier plusieurs documents

utilisez la méthode update_many().


A I
Pour mettre à jour tous les documents qui répondent aux critères de la requête,

import pymongo

A N
mydb = myclient["mydatabase"]
mycol = mydb["customers"]
N A
myclient = pymongo.MongoClient("mongodb://localhost:27017/")

il E
myquery = { "address": { "$regex": "^S" } }

A d
newvalues = { "$set": { "name": "Minnie" } }

x = mycol.update_many(myquery, newvalues)

print(x.modified_count, "documents updated.")


A I
Chapitre 3
A N
A
Cassandra
N
il E
A d
Introduction

Apache Cassandra est un système de stockage (base de données) open source,

A I
distribué et décentralisé / distribué, pour gérer de très grandes quantités de
données structurées réparties à travers le monde. Il fournit un service hautement
disponible sans point de défaillance unique.

A N
Historique de Cassandra
N A
• Cassandra a été développée sur Facebook pour la recherche dans la boîte de
réception.
il E
A d
• Il a été open source par Facebook en juillet 2008.
• Cassandra a été acceptée dans l'incubateur Apache en mars 2009.
• Il est devenu un projet Apache de haut niveau depuis février 2010.
Architecture

Cassandra utilise le protocole Gossip en arrière-plan pour permettre aux nœuds

La principale caractéristique de Cassandra A I


de communiquer entre eux et de détecter tout nœud défectueux dans le cluster.

est de stocker des données sur plusieurs


nœuds sans point de défaillance unique. A N
N A
il E
Cassandra stocke les données sur différents
nœuds avec une architecture de mode

d
distribuée peer to peer.

A
Architecture

Composants de Cassandra

est utilisé pour la récupération après incident.


A I
Chaque opération d'écriture est écrite dans Commit Log. Le journal de validation

A N
Après les données écrites dans le journal de validation, les données sont écrites
dans Mem-table. Les données sont écrites temporairement dans Mem-table.

N A
Lorsque Mem-table atteint un certain seuil, les données sont vidées dans un
fichier disque SSTable.

il E
A d
Modèle de données
Colonne

du triplet :
A I
La colonne est la plus petite unité de donnée de Cassandra. Elle est constituée

•Nom

A N
•Valeur : Maximum 2G. Elle n'est pas obligatoire.
A
•Timestamp : Sauvegarde la mise à jour la plus récente.
N
il E
A d
Une colonne dans cassandra n'a pas le même sens que dans un SGBDR. Il s'agit
là d'un attribut d'un enregistrement.
Modèle de données
Ligne

par une clé.


A I
Une ligne est un ensemble de colonnes (jusqu'à 2 Milliards). Elle est identifiée

N
C'est l'équivalent d'une ligne dans un SGBDR, c'est donc un enregistrement.

A
N A
il E
Exemple
A d
Modèle de données
Column Family
Une Column Family est un regroupement de lignes.

A I
A N
N A
il E
A d
Modèle de données
Column Family
Une Column Family est un regroupement de lignes.

A I
A N
N A
il E
A d
Modèle de données
Column Family

I
Une Column Family est l'équivalent d'une Table dans un SGBDR.

A
A N
On peut d'ailleurs y ajouter des "métadonnées", en quelque sorte des "entêtes"
de colonnes. Néanmoins, les colonnes définies ne seront pas forcément
exploités lors de la création de ligne.
N A
il E
Il existe deux types de familles de colonnes
• statique : les colonnes sont définies lors de la création ou modification de la

A d
famille de colonnes ;
• dynamique : les colonnes sont définies lors de la création ou modification
d'une ligne.
Modèle de données
Keyspace
Un KeySpace est un
regroupement de Column
A I
Family. Il équivaut au
schéma dans un SGBDR.
A N
N A
il E
A d
Langage CQL
Créer un KeySpace
Syntaxe
CREATE KEYSPACE <identifier> WITH <properties>
A I
C.à.d:
A N
A
CREATE KEYSPACE "KeySpace Name"
WITH replication = {'class': 'Strategy name', 'replication_factor' : 'No.Of replicas'};

CREATE KEYSPACE "KeySpace Name"


E N
d
AND durable_writes = 'Boolean value';
il
WITH replication = {'class': 'Strategy name', 'replication_factor' : 'No.Of replicas'}

Exemple A
CREATE KEYSPACE test WITH REPLICATION = { 'class' : 'SimpleStrategy', 'replication_factor' : 1 };
La valeur par défaut de durable_writes est true.
Langage CQL
Créer un KeySpace
La stratégie de copie (replication)
Il existe 2 types de stratégies :
A I
A N
SimpleStrategy : à utiliser uniquement lorsque le cluster est composé d'un
unique data-center et une seule rack. La première copie est placée dans le noeud

N A
déterminé à partir de la clé de partition, les suivants sont placés sur les noeuds
voisins dans le sens des aiguilles d'une montre.

il E
A d
NetworkTopologyStrategy : à utiliser lorsque le cluster est déployé sur
plusieurs data-centers. Cette stratégie permet de spécifier le nombre de copies
voulu dans chaque data-center.

Pour la suite, nous nous intéresserons uniquement à la SimpleStrategy.


Langage CQL
Créer un KeySpace
La stratégie de copie (replication)

A I
A N
N A
il E
A d
Langage CQL
Créer un KeySpace
durable_writes

A I
A N
Lorsqu'une demande d'écriture est reçue, le noeud écrit d'abord une copie des
données dans une structure à ajout uniquement sur disque appelée commitlog .

N A
Ensuite, il écrit les données dans une structure en mémoire appelée memtable .
Lorsque la mémtable est pleine ou atteint une certaine taille, elle est vidée vers

il E
une structure immuable sur disque appelée SSTable . La définition d' écritures
durables sur true garantit que les données sont écrites dans le journal de

A d
validation. Dans le cas où le nœud redémarre, les tables de mémoire ont disparu
car elles résident en mémoire. Cependant, les tables de mémoire peuvent être
reconstruites en relisant le commitlog, car la structure du disque ne sera pas
effacée même avec les redémarrages de nœuds.
Langage CQL
Créer un KeySpace
durable_writes

A I
A N
N A
il E
A d
Langage CQL
Vérifier les KeySpaces DESCRIBE keyspaces;
ou
I
SELECT * FROM system_schema.keyspaces;

A
Utiliser un KeySpaces use school;
A N
N A
Modifier un KeySpaces

il E ALTER KEYSPACE school


WITH replication = {'class':'NetworkTopologyStrategy',

d
'replication_factor' : 3};

A
Supprimer un KeySpaces DROP KEYSPACE school;
Langage CQL
Création d'une table
CREATE TABLE emp(
emp_id int PRIMARY KEY,
A I
emp_name text,
emp_city text,
A N
emp_sal varint,
emp_phone varint
N A
);
il E
Vérification
A d select * from emp
Langage CQL
Modification d'une table
Ajout d'une colonne
Suppression d'une colonne
I
ALTER TABLE emp ADD emp_email text;

A
N
ALTER TABLE emp DROP emp_email;

Détruire une table DROP TABLE emp;

A A
Effacer une table
N
TRUNCATE emp;

E
Appliquer un batch
d il BEGIN BATCH
... INSERT INTO emp (emp_id, emp_city, emp_name,

A emp_phone, emp_sal) values( 4,'Rabat','Adil',0677205790,


30000);
... UPDATE emp SET emp_sal = 50000 WHERE emp_id =3;
... DELETE emp_city FROM emp WHERE emp_id = 2;
... APPLY BATCH;
Langage CQL
Les opérations CRUD
Ajouter une ligne

A I
INSERT INTO emp ( emp_id, emp_name, emp_city, emp_phone, emp_sal )
VALUES(1,'Rabat','Adil', 0677205790, 50000);
Modifier une ligne
A N
N A
UPDATE emp SET emp_city ='Casa', emp_sal = 50000 WHERE emp_id = 2;
Sélectionner une ligne

il E
A d
SELECT * FROM emp WHERE emp_sal=50000;
Suppression de données d'une table
DELETE emp_sal FROM emp WHERE emp_id=3;
Suppression d'une ligne entière
DELETE FROM emp WHERE emp_id=3;
Langage CQL
Exercice
Soit le schéma suivant:

A I
A N
N A
il E
A d
1) Créer un keyspace ‘Mediatheque’
2) Créer les column family nécessaires.
Pour faciliter les exercices suivants, nous allons aussi créer une table user qui ne
contiendra que le login, nom et prénom des utilisateurs créés.
Langage CQL
Exercice
3) Insérer les vidéos suivantes et vérifier que l'insertion est correcte.
Id Video_name Video_updoaded
A I
Login
1
2
KeyboardCat
NyanCat
now
now
A N Cschmidt
saraj00n

N A
4) Ajouter ensuite l'utilisateur suivant (sans vidéo) : MasterTroll (Jean Fabrice)
5) Vérifier l'insertion dans la table vidéo, puis recherchez les vidéos de
l'utilisateur 'saraj00n'.

il E
5) Insérer le commentaires suivants :

A d
1 - le 15/01/2017 à 12h00, saraj00n a écrit 'first' sur la vidéo 'Keyboard Cat'
2 - le 15/01/2017 à 12h05, MasterTroll a écrit 'thats lame' sur la vidéo
'Keyboard Cat’
Langage CQL
Exercice
6) Insérer cet utilisateur :

A I
INSERT INTO users (client_id , nom, prenom , age) VALUES ('saraj00n',
'Sarah', 'Junior');
Que se passe-t-il ?
A N
son nom pour PAUL
N A
L'utilisateur MasterTroll décide de dévoiler son identité au grand jour, il change

il E
L'utilisateur Jean PAUL se fait banir, supprimer l'utilisateur
Supprimez la column family users.
Supprimer le keyspace.
A d
Langage CQL
Correction
1)

A I
CREATE KEYSPACE Mediatheque WITH REPLICATION = {
'class' : 'SimpleStrategy', 'replication_factor' :
1 };
A N
2)CREATE TABLE videos (
N A
video_id uuid,

il
video_name varchar, E
A d
video_uploaded timestamp,
user_login varchar,
PRIMARY KEY(video_id));
Langage CQL
Correction
CREATE TABLE user_videos_index (
login varchar,
A I
video_id uuid,
video_name varchar,
A N
A
PRIMARY KEY(login, video_id));

N
video_id uuid,
il E
CREATE TABLE comments_by_video (

A d
user_login varchar,
comment_dat timestamp,
comment varchar,
PRIMARY KEY(video_id, user_login));
Langage CQL
Correction

A I
CREATE TABLE comments_by_user ( user_login
varchar, video_id uuid, comment_dat timestamp,
comment varchar,

A N
PRIMARY KEY(user_login, video_id));

N A
CREATE TABLE users (
login varchar,
il E
firstname varchar,
A
lastname varchar,
d
PRIMARY KEY(login));
Langage CQL
Correction

'chris', 'SCHMIDT');
A I
INSERT INTO users(login, firstname, lastname) VALUES ('cschmidt',

'Sarah', 'JUNE');
A N
INSERT INTO users(login, firstname, lastname) VALUES ('saraj00n',

INSERT INTO users(login, firstname, lastname) VALUES ('MasterTroll',


'Jean', 'FABRICE');

N A
INSERT INTO videos (video_id, video_name, video_uploaded, user_login)

il E
VALUES (uuid(),'Keyboard Cat', dateof(now()), 'cshmidt');
INSERT INTO user_videos_index (login, video_id, video_name) VALUES

A d
('cschmidt', the generated uuid, 'Keyboard Cat');
INSERT INTO videos (video_id, video_name, video_uploaded, user_login)
VALUES (uuid(),'nyan cat', dateof(now()), 'saraj00n');
INSERT INTO user_videos_index (login, video_id, video_name) VALUES
('saraj00n', the generated uuid, 'nyan cat');
SELECT * FROM videos;
SELECT video_name FROM user_videos_index WHERE login='saraj00n';
Langage CQL
Correction

A I
INSERT INTO comments_by_user (user_login, video_id, comment_dat, comment)
VALUES (saraj00n, generated uuid, '1484481600', 'first');

A N
INSERT INTO comments_by_videos (video_id, user_login, comment_dat,
comment) VALUES (generated uuid, saraj00n, '1484481600', 'first');
INSERT INTO comments_by_user (user_login, video_id, comment_dat, comment)

N A
VALUES (MasterTroll, generated uuid, '1484481900', 'thats lame');
INSERT INTO comments_by_videos (video_id, user_login, comment_dat,

lame');

il E
comment) VALUES (generated uuid, 'MasterTroll', 1484481900, 'thats

d
SELECT * FROM comments_by_user;
SELECT * FROM comments_by_video;

A
Langage CQL
Les types complexes
Les listes

A I
N
CREATE TABLE "school".personne (
id int,
age int,
enfants list<text>,
A A
nom text,
prenom text,
E N
il
PRIMARY KEY (id)
);

A d
Langage CQL
Les types complexes
Les listes
insert into personne JSON
A I
N
'{"id":1,"nom":"AMZIL","prenom":"Kamal","age":35}';

A
insert into personne JSON
A
'{"id":2,"nom":"MOUHTADI","prenom":"Salah","age":35,"enfants":["Hamza",
"Meriem","Wael"]}‘;
N
il E
update personne set enfants=['Fatima','Hanane'] where id=1;

A d
update personne set enfants=enfants+['Mohamed','Karim'] where id=1;

update personne set enfants[2]='Nada' where id=1;

delete enfants[2] from personne where id=1;


Langage CQL
Les types complexes
Les Maps
CREATE TABLE school.teacher ( A I
id int,
age int,
A N
nom text,
N A
enfants MAP<text,int>,

prenom text,

il E
PRIMARY KEY (id)
);

A d
Langage CQL
Les types complexes
Les Maps

A I
Insertion
insert into "teacher" JSON '{
A N
Insertion
update "teacher"
"id":1,
"nom":"KHALIFI",
N A set enfants['Khawla']=16
where id=1;
"prenom":"Hamza",
"age":48,
il E
"enfants":{
"Khawla":12,
"Brahim":23 A d Suppression
delete enfants['Khawla']
} from "teacher"
}'; where id=1;
Langage CQL
Les types complexes
Création d’un type utilisateur

A I
CREATE TYPE "school".enfant (
prenom text,
A N
age int,
sexe text
N A
);
il E
A d
Langage CQL
Les types complexes
Avec le type MAP<text,enfant>
Insertion
A I
"id":1,
A N
insert into "Personne" JSON '{

"nom":"TAHIRI",
"prenom":"Mohamed",
N A
"age":47,
"enfants":{
il E
A d
"1":{"prenom":"Adam","age":15,"sexe":"H"},
"2":{"prenom":"Kawtar","age":10,"sexe":"F"},
"3":{"prenom":"Imad","age":5,"sexe":"H"}
}
}';
L’API Java
La dépendance Maven

I
Nous devons définir la dépendance Cassandra suivante dans le pom.xml
A
<dependency>
A N
<groupId>com.datastax.cassandra</groupId>

<version>3.1.0</version>
N A
<artifactId>cassandra-driver-core</artifactId>

</dependency>
il E
A d
L’API Java
La connexion au serveur Cassandra
Créons tout d’abord la classe « CassandraConnector »
public class CassandraConnector {
private Cluster cluster;
A I
private Session session;

A N
A
public void connect(String node, Integer port) {
cluster = Cluster.builder().addContactPoint(node)
.withPort(port)
.build();

E N
il
session = cluster.connect();
System.out.println("Connecté");
}

A d
public Session getSession() { return this.session; }
public void close() {
session.close();
cluster.close();
}
}
L’API Java
La connexion au serveur Cassandra
Tester la connexion avec la classe « ClientCassandra »
public class ClientCassandra {
A I
N
public static void main(String[] args) {
CassandraConnector connector=new CassandraConnector();
connector.connect("localhost", 9042);
connector.close();
A A
}

E N
il
}

A d
L’API Java
Créer un KeySpace
Créons notre espace-clé « Ecole »:
public void createKeyspace(
A I
N
String keyspaceName, String replicationStrategy, int
replicationFactor) {

A A
String query="CREATE KEYSPACE IF NOT EXISTS "+keyspaceName
+" WITH replication = {'class':'"+replicationStrategy

N
+"','replication_factor':"+replicationFactor+"};";

E
il
session.execute(query);
}

A d
L’API Java
Créer un une columnFamily
Créons la table « Etudiants »:

A I
public void createTable(String keyspace,String tablename,

N
HashMap<String,String> columns) {
session.execute("use "+keyspace);

int size=columns.size();
A A
String query= "CREATE TABLE IF NOT EXISTS "+tablename+"(";

int i=1;

E N
Set<String> keys=columns.keySet();

il
for(String key:keys) {
query+=key+" "+columns.get(key);

i++;
} A d
if (i!=size) {query+=",";}else {query+=");";}

session.execute(query);
}
A I
Chapitre 4
A N
A
Neo4J
N
il E
A d
Introduction

Qu'est-ce qu'une base de données orientée graphe?

A I
La base de données orientée graphe est une base de données utilisée pour
modéliser les données sous forme de graphe. Ici, les nœuds d'un graphe

nœuds.
A N
représentent les entités tandis que les relations décrivent l'association de ces

N A
Neo4j est une base de données orientée graphe populaire. Les autres bases de

il E
données graphiques sont Oracle NoSQL Database, OrientDB,

d
HypherGraphDB, GraphBase, InfiniteGraph et AllegroGraph.

A
Introduction

Modèle de données

son format de stockage de graphe natif.


A I
Neo4j utilise Native GPE (Graph Processing Engine) pour fonctionner avec

A N
Les principaux éléments constitutifs du modèle de données Graph DB sont:

• Noeuds N A
• Des relations
il E
• Propriétés

A d
Ci-contre un exemple simple
de graphique de propriété.
Introduction

Modèle de données
Exemple: Facebook
A I
A N
N A
il E
A d
Installation

Visitez le site officiel de Neo4j en utilisant https://neo4j.com/ . En cliquant, ce


lien vous mènera à la page d'accueil du site Web neo4j.
Télécharger Neo4J
A I
A N
N A
il E
A d
Blocs de construction

Modèle de données

A I
La base de données de graphes Neo4j a les blocs de construction suivants -

• Noeuds
A N


Propriétés
Des relations
N A


Étiquettes
Navigateur de données
il E
A d
Blocs de construction

Nœud

I
Le nœud est une unité fondamentale d'un graphe. Il contient des propriétés
A
N
avec des paires clé-valeur comme indiqué dans l'image suivante.

A
N A
il E
A d
Ici, Node Name = "Employee" et il contient un ensemble de propriétés sous
forme de paires clé-valeur.
Blocs de construction

Propriétés

I
La propriété est une paire clé-valeur pour décrire les nœuds de graphique et les
A
relations.
Key = Value
A N
N A
Où Key est une chaîne et la valeur peut être représentée à l'aide de n'importe
quel type de données Neo4

il E
A d
Blocs de construction

Des relations

A I
Les relations sont un autre élément constitutif majeur d'une base de données de
graphes. Il connecte deux nœuds comme illustré dans la figure suivante.

A N
N A
il E
Ici, Emp et Dept sont deux nœuds différents. "WORKS_FOR" est une relation

A d
entre les nœuds Emp et Dept.
Comme cette marque de flèche de relation représente une relation entre le
nœud "Emp" et le nœud "Dept", cette relation est connue sous le nom de
"relation entrante" vers le nœud "Dept" et "relation sortante" vers le nœud
"Emp".
Blocs de construction

Des relations

I
Comme les nœuds, les relations peuvent également contenir des propriétés
A
sous forme de paires clé-valeur.

A N
N A
il E
A d
Blocs de construction

Étiquettes

A I
L'étiquette associe un nom commun à un ensemble de nœuds ou de relations.
Un nœud ou une relation peut contenir une ou plusieurs étiquettes. Nous
N
pouvons créer de nouvelles étiquettes pour les nœuds ou relations existants.
A
existants.
N A
Nous pouvons supprimer les étiquettes existantes des nœuds ou relations

il E
Du diagramme précédent, nous pouvons observer qu'il y a deux nœuds.

A d
Le nœud du côté gauche a une étiquette: "Emp" et le nœud du côté droit a une
étiquette: "Dept".

La relation entre ces deux nœuds a également une étiquette: "WORKS_FOR".


CQL

CQL signifie Cypher Query Language. Comme Oracle Database a un langage

I
de requête SQL, Neo4j a CQL comme langage de requête.
A
Neo4j CQL
A N
• Est un langage de requête pour Neo4j Graph Database.

• Suit SQL comme la syntaxe.


N A
• Est un langage déclaratif de correspondance de modèles.

il E
• La syntaxe est très simple et dans un format lisible par l'homme.
• Comme Oracle SQL

A d
• Neo4j CQL a des commandes pour effectuer des opérations de base de
données.
CQL
Création d'un nœud

nœud à créer avec la clause CREATE. CREATE(Hassan)


A I
Vous pouvez créer un nœud dans Neo4j en spécifiant simplement le nom du

l'invite dollar.
A N
Pour vérifier la création du type de nœud, exécutez la requête suivante dans

A
MATCH (n) RETURN n

N
il E
A d
La clause CREATE de Neo4j CQL est également utilisée pour créer plusieurs nœuds en même
temps. Pour ce faire, vous devez transmettre les noms des nœuds à créer, séparés par une virgule.
CQL
Création d'un nœud avec une étiquette

l'aide d'étiquettes.
A I
Une étiquette dans Neo4j est utilisée pour regrouper (classer) les nœuds à

A
CREATE(Hassan:Etudiant)N
N A
Vous pouvez également créer plusieurs étiquettes pour un seul nœud. Vous
E
devez spécifier les étiquettes du nœud en les séparant par deux points «:».
il
A d
CREATE(Hassan:Personne:Etudiant)
CQL
Créer un nœud avec des propriétés

A I
Les propriétés sont les paires clé-valeur à l'aide desquelles un nœud stocke des
données. Vous pouvez créer un nœud avec des propriétés à l'aide de la clause

les accolades de fleurs "{}".


A N
CREATE. Vous devez spécifier ces propriétés séparées par des virgules dans

A
CREATE(kamal:Etudiant{nom:"AMZIL",prenom:"Kamal",age:23})
N
Retour du nœud créé

il E
Nous pouvons utiliser la clause RETURN avec CREATE pour afficher le
nœud nouvellement créé.
A d
CREATE(kamal:Etudiant{nom:"AMZIL",prenom:"Kamal",age:23}) return kamal
CQL
Créer des relations

A I
Nous pouvons créer une relation en utilisant la clause CREATE. Nous
spécifierons la relation entre les accolades carrées «[]» en fonction de la

A N
direction de la relation entre le trait d'union «-» et la flèche «→»,
CREATE(Khalid:Etudiant{nom:"SALMI",prenom:"Khalid",age:21})

N A
CREATE(Math:Filière{nom:"Info",Coefficient:4})

E
CREATE (Khalid)-[r:inscrit_dans]->(Math)
il
A d
CQL
Création d'une relation entre les nœuds existants

la clause MATCH .
A I
Vous pouvez également créer une relation entre les nœuds existants à l'aide de

MATCH (a:Etudiant), (b:Filière) A N


N A
WHERE a.name = "MANSOURI" AND b.name = "Informatique"

RETURN a,b
il E
CREATE (a)-[r:inscrit_dans]->(b)

A d
CQL
Création d'une relation avec l'étiquette et les propriétés

clause CREATE.
A I
Vous pouvez créer une relation avec l'étiquette et les propriétés à l'aide de la

MATCH (a:Etudiant), (b:Filière) A N


N A
WHERE a.name = "MANSOURI" AND b.name = "Informatique"

RETURN a,b
il E
CREATE (a)-[r:inscrit_dans{date: "19/09/2019", Etat: "actif "}]->(b)

A d
CQL
Création d'un chemin complet

A
chemin peut être créé à l'aide de la clause create.I
Dans Neo4j, un chemin est formé en utilisant des relations continues. Un

CREATE
A N
N A
(j:Joueur{nom:"NAKACH",prenom:"Ibrahim",age:36})-
[r1:capitain]->(e:Equipe{nom:"Wydad"})-

il E
[r2:vinqueur{année:2019}]->(c:Championnat{nom:"Botola
Marocaine"})
A d
CQL
Fusion d'un nœud avec une étiquette

A I
Vous pouvez fusionner un nœud dans la base de données en fonction de
l'étiquette à l'aide de la clause MERGE. Si vous essayez de fusionner un nœud

Sinon, le nœud actuel sera créé.


A N
basé sur l'étiquette, Neo4j vérifie s'il existe un nœud avec l'étiquette donnée.

N
merge (n:Joueur{nom:"NAKACH"}) return nA
il E
A d
CQL
OnCreate et OnMatch

A I
Vous pouvez fusionner un nœud dans la base de données en fonction de
l'étiquette à l'aide de la clause MERGE. Si vous essayez de fusionner un nœud

Sinon, le nœud actuel sera créé.


A N
basé sur l'étiquette, Neo4j vérifie s'il existe un nœud avec l'étiquette donnée.

merge (n:Joueur{nom:"NAKACH"})
N A
il
ON MATCH SET n.isFound = "true"
E
ON CREATE SET n.isCreated = "true"

return n
A d
CQL
Fusionner une relation

de la clause MERGE.
A I
Tout comme les nœuds, vous pouvez également fusionner les relations à l'aide

Créer d’abord les deux nœuds suivants:


create (e:Equipe{nom:"RAJA"}) return e A N
N A
create (j:Joueur{nom:"BANOUN",prénom:"Badr",age:26}) return j
MATCH (a:Joueur), (b:Equipe)
il E
WHERE a.nom = "BANOUN" AND b.nom = "RAJA"

RETURN a, b A d
MERGE (a)-[r:CapitainDe]->(b)
CQL
Définition d'une propriété

nœud.
A I
À l'aide de la clause SET, vous pouvez créer une nouvelle propriété dans un

MATCH (j:Joueur{nom:"BANOUN"})

A
set j.titres = 2, ancienneté = 6 N
return j
N A
il E
MATCH (j:Joueur{nom:"NAKACH"})

A
return j d
set j.titres = 7, ancienneté = 6
CQL
Suppression d'une propriété

I
Vous pouvez supprimer une propriété existante en lui passant la valeur NULL .

A
MATCH (j:Joueur{nom:"BANOUN"})
set j.titres = null
A N
return j
N A
il E
MATCH (j:Joueur{nom:"NAKACH"})

A
return j d
set j.titres = null
CQL
Définition d'une étiquette sur un nœud

comme indiqué ci-dessous.


A I
Avant de poursuivre avec l'exemple, créez d'abord un nœud «Anderson»

N
create (n{nom:"Anderson",prenom:"Bobley",age:27}) return n
A
MATCH(n{nom:"Anderson"})
N A
set n:Joueur
il E
return n
A d
CQL
Suppression de tous les nœuds et relations

données à l'aide de la clause DELETE


A I
Voici la requête pour supprimer tous les nœuds et les relations dans la base de

MATCH (n) DETACH DELETE n


A N
Suppression d'un nœud particulier
N A
Pour supprimer un nœud particulier, vous devez spécifier les détails du nœud à

il E
la place de «n» dans la requête ci-dessus.

A d
MATCH(n{nom:"Anderson"})
DETACH DELETE n
CQL
Suppression d'une propriété
Vous pouvez supprimer une propriété d'un nœud à l'aide de MATCH avec la
clause REMOVE.
A I
REMOVE j.titres A N
MATCH (j:Joueur{nom:"BANOUN"})

return j
N A
E
Suppression d'une étiquette d'un nœud
il
A d
Semblable à la propriété, vous pouvez également supprimer une étiquette d'un
nœud existant à l'aide de la clause remove.
MATCH (j:Joueur{nom:"BANOUN"})
REMOVE j:Joueur
return j