Tutoriel sur une introduction à Neo4j, une base de données orientée graphe

Nous n'avons jamais créé et stocké autant de données qu'à l'heure actuelle. Dès que nous naviguons sur Internet nous produisons des données, via les tracker pour les statistiques, les réseaux sociaux, nos achats en ligne, nos emails… 

Hier grâce aux ordinateurs, aujourd'hui via nos smartphones et demain avec l'Internet des objets, le volume de données ne va faire qu'augmenter. Bref, nous sommes en plein dans le BigData.

Mais que se passerait-il si nous arrivions à mettre en relation toutes ces données ? Simplement, nous ferions comme Facebook, Google, LinkedIn ou eBay.

Ces grands acteurs du Web ont bien compris que connecter ou lier les données permet d'accroître considérablement leur valeur. Ainsi, nous ne sommes plus uniquement dans le Bigdata mais également dans l'ère du LinkedData : les données deviennent de plus en plus complexes et connectées.

Il vient alors une question : comment modéliser, stocker et requêter ces relations entre les données ?

Dès qu'on doit stocker des données, on pense aux bases de données relationnelles. Mais sont-elles faites pour stocker des données connectées ?

Lorsqu'on veut créer une relation entre deux objets, il est fréquent de devoir créer une table n-tiers permettant de les lier.

Ceci implique que nous devons modifier le schéma de la base pour chaque nouvelle relation qu'on veut créer. Dans notre contexte, cette non-flexibilité allonge les temps de développement.

De plus, en SQL, la description d'une relation se traduit par l'ajout d'un « JOIN ». Or, avec des données connectées, on obtient rapidement des requêtes avec beaucoup de JOIN, ce qui les rend complexes et donc difficilement maintenables.

De surcroît, plus on a de données dans une table et moins bonnes sont les performances. Pour calculer le résultat, les moteurs SQL font (quasiment) le produit cartésien de chacune des tables.

Dans notre contexte, les bases relationnelles sont inappropriées, surtout si l'on veut faire du temps réel :

• schéma non flexible ;
• mauvaises performances ;
• code complexe et difficilement maintenable.

Il existe trois familles de NoSQL :

• document : MongoDB, CouchBase ;
• colonne : HBase, Cassandra ;
• clef-valeur : Redis, Riak.

Toutefois, aucune de ces familles ne convient puisqu'il n'existe aucun moyen de modéliser, stocker ou requêter les relations. La seule manière de lier des objets est de créer des relations implicites et de réaliser nos « jointures » dans le code de nos applications.

De surcroît, ces bases ne sont pas transactionnelles (cf. ACID). En somme, elles ne sont pas faites pour y stocker des données connectées.

Les bases de données orientées graphes vous permettent de modéliser, stocker et requêter en temps réel vos données connectées. Ici, on ne parle plus de table ou de document, mais de nœud et de relation. Le principe est simple : ce que vous modélisez sur un tableau blanc est votre modèle physique !

Neo4j est une base de données orientée graphe, libre (sous licence GPLv3) et écrite en Java. Développée par Neo Technology (une société suédoise dont le siège est aux US), les premières lignes de codes datent de l'année 2000 et la version 1.0 est sortie en 2010.

Ceci en fait l'une des premières bases de données orientées graphes, mais aussi l'une des plus évoluées et robustes.

Ses principales caractéristiques sont les suivantes :

• transaction : c'est une base de données transactionnelle, respectueuse des principes ACID ;
• haute disponibilité : via la mise en place d'un cluster ;
• volumétrie : stocker et requêter des milliards de nœuds et de relations ;
• Cypher : un langage de requête graphe déclaratif, simple et efficace ;
• schemaless : pas de schéma préétabli.

Les bases de données orientées graphes tournent autour de trois concepts : les nœuds, les relations et leurs propriétés. Quoi de mieux qu'un graphe pour expliquer ces concepts !

L'unité fondamentale qui forme un graphe est le nœud. Les nœuds sont des enregistrements composés de propriétés de type clef/valeur, sans schéma préétabli. Généralement, ils représentent une entité du modèle.

Pour différencier les nœuds, Neo4j apporte la notion de label. Ceux-ci permettent de donner un rôle ou un type à un nœud (un nœud peut avoir plusieurs labels).

Ainsi, ceci nous permet de créer des nœuds de ce genre :

I-C-3-a. Les relations▲

Les relations entre les nœuds sont la clef de voûte des graphes, c'est ce qui permet de lier des données et de créer des structures comme des listes, des arbres, des maps… 

Neo4j les définit comme étant constituées d'un nœud de départ, d'arrivée (donc une relation avec un sens) et d'un type. De plus, tout comme les nœuds, elles sont également un enregistrement, et donc peuvent avoir des propriétés de type clef/valeur.

Si l'on reprend notre précédent exemple, voici ce qu'on peut réaliser :

I-C-3-b. Les propriétés▲

Dans les sections précédentes, nous avons vu que les nœuds et les relations peuvent avoir des propriétés. Leurs types possibles correspondent aux types primitifs de Java, ou à un tableau de type primitif.

Les nœuds sont représentés avec des parenthèses, ce qui ressemble à des cercles : ()

Si vous avez besoin d'identifier le nœud dans votre requête (dans une clause WHERE par exemple), il suffit de lui donner un nom : (monNoeud)

Pour spécifier un label, il suffit de l'ajouter comme ceci : (monNoeud:monLabel)

Voici quelques exemples :

• () : n'importe quel nœud ;
• (:Personne) : un nœud avec le label Personne ;
• (n:Personne) : un nœud identifié dans la variable n avec le label Personne ;
• (n:Personne:Acteur) : un nœud identifié dans la variable n avec le label Personne et Acteur.

Les relations sont représentées par deux tirets avec un '>', ce qui ressemble à une flèche : -->

Si vous avez besoin d'identifier la relation dans votre requête, vous pouvez lui donner un nom comme ceci : -[maRelation]->

Pour spécifier le type de la relation, il suffit de l'ajouter comme ceci : -[maRelation:MON_TYPE]->

Voici quelques exemples :

• (a)--(b) : n'importe quelle relation entre le nœud a et b (peu importe la direction) ;
• (a)-[:AMI]->(b) : relation de type AMI depuis le nœud a vers le nœud b ;
• (a)-[r:AMI|CONNAIT]->(b) : relation identifiée dans la variable r de type AMI ou CONNAIT depuis le nœud a vers le nœud b.

Maintenant que vous savez décrire vos motifs, nous allons voir comment réaliser vos requêtes avec le tutoriel de la section suivante.

I-E-1-a. Prérequis▲

I-E-1-b. Téléchargement▲

I-E-1-c. Installation▲

Une fois votre serveur démarré, vous pouvez prendre votre navigateur préféré et vous rendre à L'URL suivante : http://localhost:7474/browser

Neo4j est livré avec un client web, vous permettant de requêter et naviguer dans votre graphe. C'est l'outil du quotidien des développeurs.

On y trouve :

• en rouge : l'espace de saisie de la requête ;
• en vert : l'espace d'affichage du résultat de la requête qu'on peut afficher sous forme de graphe ou de tableau (cf. zone bleue).

L'objectif de cet exercice est de vous permettre de manipuler le langage Cypher.

• Tout d'abord, vous allez créer un nœud grâce à la clause CREATE :

CREATE (vous:Personne { nom:"Vous" })
RETURN vous

Vous pouvez ajouter d'autres attributs à votre nœud comme ceci CREATE (vous:Personne { nom:"Benoit", twitter:'logisima', …? })

• Vous aimez Neo4j, non ? Alors créez un nœud « Neo4j » et positionnez-y une relation de type AIME avec votre nœud.

MATCH  (vous:Personne { nom:"Vous"})
CREATE (vous)-[aime:AIME]->(neo:Database:NoSql:Graph {nom:"Neo4j" })
RETURN vous,aime,neo

(vous:Personne { nom:  "benoit"  }) permet de récupérer un nœud avec le label Personne et ayant benoit comme valeur pour la propriété nom.

À présent, nous allons ajouter vos amis dans le graphe :

MATCH (vous:Personne { nom:"Vous" })
FOREACH (nom in ["Thibaut","Anne","Fabien","Charlotte","Elise"] |
  CREATE (vous)-[:AMI]->(:Personne { nom: nom })
)

Foreach permet d'exécuter une opération pour chaque élément de la liste.

• De Thibaut :

MATCH
    (neo:Database { nom:"Neo4j" }),
    (thibaut:Personne { nom:"Thibaut" })
CREATE (thibaut)-[:AMI]->(:Personne:Expert { nom:"Linda" })-[:COMPETENCE]->(neo)

• Puis d'Anne :

MATCH (neo:Database { nom:"Neo4j" })
MATCH (anne:Person { nom:"Johan" })
CREATE (anne)-[:AMI]->(:Personne:Expert { nom:"Maxime"})-[:COMPETENCE]->(neo)

MATCH
    (vous:Personne { nom: "Vous" }),
    (expert:Personne)-[:COMPETENCE]->(db:Database { nom: "Neo4j" }),
    p = shortestPath( (vous)-[:AMI*..5]-(expert) )
RETURN p,db

(vous)-[:AMI*..5]-(expert) permet de décrire un chemin dans le graphe, ici un chemin entre vous et un expert qui est une connaissance de niveau 5 au maximum. En y ajoutant la fonction shortestpath, on cherche uniquement le chemin le plus court.

Si vous voulez tout savoir sur Cypher, il existe une fiche qui référence toutes ses fonctionnalités : http://neo4j.com/docs/stable/cypher-refcard/

Vous pouvez également regarder les exemples qui sont livrés avec Neo4j. Ceux-ci sont disponibles directement dans le browser comme le montre l'image ci-dessous. Une fois que vous avez cliqué sur l'un d'entre eux, il ne vous reste plus qu'à suivre les instructions affichées dans l'encadré.

Si vous connaissez les outils tels que JSfiddle, plunker ou codePen pour le développement web, eh bien la console Neo4j (http://console.neo4j.org) fait la même chose, mais pour Neo4j.

Cet outil vous permet de créer en ligne une base Neo4j, de la requêter, mais surtout de la partager. C'est idéal pour commencer à s'amuser avec Neo4j puisque cela ne nécessite aucune installation.

C'est également pratique pour partager avec la communauté son modèle de données lorsqu'on a un problème de modélisation ou de requête.

Graphe gist (http://graphgist.neo4j.com) vous permet de réaliser une documentation « vivante » de votre projet. Au lieu d'avoir des extraits de code figés, ici vos requêtes Cypher sont exécutées dans une console Neo4j, ce qui rend vos exemples dynamiques.

Cet outil est beaucoup utilisé pour rédiger des cas d'utilisation : on y définit une problématique et l'on y démontre comment Neo4j peut répondre via une série de requêtes Cypher.

Ainsi, je suis certain que vous trouverez sur cette page http://graphgist.neo4j.com/#!/gists/all, un gist se rapprochant de votre cas d'utilisation.

Peu importe votre langage de programmation préféré, vous y trouverez un driver fait pour vous : http://neo4j.com/developer/language-guides/

N'oubliez pas, vous n'êtes pas seul, la communauté peut vous aider.

Voici la liste des endroits où vous pouvez trouver de l'aide :

• le forum Developpez.com dédié au NoSQL : https://www.developpez.net/forums/f1743/bases-donnees/nosql/ ;
• le Google Group de la communauté française : https://groups.google.com/forum/#!forum/neo4jfr ;
• le Google Group de la communauté internationale : https://groups.google.com/forum/#!forum/neo4j ;
• le slack (équivalent à un IRC) des utilisateurs : https://neo4j-users.slack.com/ ;
• Stackoverflow : http://stackoverflow.com/questions/tagged/neo4j.

N'hésitez pas à y poser vos questions !