TP : Découverte de Neo4j et du langage Cypher

TP : Découverte de Neo4j et du langage Cypher

Objectif

Apprendre à :

1. Comprendre les bases de données orientées graphes.
2. Installer et configurer Neo4j.
3. Manipuler les données de graphe avec Cypher (création de noeuds, relations, requêtes).
4. Interroger et analyser des données de graphe.

1. Introduction aux bases de données orientées graphe

Neo4j est une base de données orientée graphe, idéale pour gérer des réseaux sociaux, des chaînes logistiques, des réseaux de dépendance, etc. Dans ce modèle :

• Noeuds : Les entités de votre graphe (par exemple : Person, City).
• Relations : Les connexions entre les noeuds (par exemple : FRIEND, LIVES_IN).
• Propriétés : Attributs stockés pour chaque noeud ou relation (par exemple : name, age, date).

2. Mise en place de Neo4j

Installation de Neo4j

1. Télécharger Neo4j : Rendez-vous sur Neo4j Download Center pour télécharger la version compatible avec votre système d'exploitation.
2. Installer Neo4j Desktop :
   • Suivez les instructions d'installation fournies sur le site.
   • Lancez Neo4j Desktop et créez un projet en cliquant sur “New Project” (nommez-le "TP_Neo4j").
   • Créez une base de données (Database) dans votre projet et démarrez-la.
3. Accéder à Neo4j Browser :
   • Ouvrez Neo4j Browser pour exécuter les requêtes Cypher.
   • Par défaut, accédez-y à l'adresse suivante : http://localhost:7474.
4. Se connecter :
   • Par défaut, utilisez l'utilisateur neo4j et le mot de passe défini lors de l’installation.

Modélisation du graphe : Cas d'un réseau social simple

Dans ce TP, nous allons modéliser un réseau social. Voici les éléments principaux :

1. Noeuds :
   • Person : chaque personne possède des attributs name, age, et city.
   • City : ville avec l'attribut name.
2. Relations :
   • FRIEND : relation d'amitié entre deux personnes.
   • LIVES_IN : relation entre une personne et sa ville.
3. Exemple de données :
   • Noeuds :
     • Alice, 30 ans, vit à Paris.
     • Bob, 25 ans, vit à Lyon.
     • Carol, 35 ans, vit à Paris.
   • Relations :
     • Alice est amie avec Bob et Carol.
     • Alice et Carol vivent à Paris ; Bob vit à Lyon.

Création du graphe avec Cypher

Étape 1 : Création des noeuds

• Dans Neo4j Browser, exécutez les commandes Cypher pour créer les noeuds.

CREATE (a:Person {name: 'Alice', age: 30, city: 'Paris'});
CREATE (b:Person {name: 'Bob', age: 25, city: 'Lyon'});
CREATE (c:Person {name: 'Carol', age: 35, city: 'Paris'});

CREATE (paris:City {name: 'Paris'});
CREATE (lyon:City {name: 'Lyon'});

Étape 2 : Création des relations

• Maintenant, créez les relations entre les noeuds.

// Amis
MATCH (a:Person {name: 'Alice'}), (b:Person {name: 'Bob'})
CREATE (a)-[:FRIEND]->(b);

MATCH (a:Person {name: 'Alice'}), (c:Person {name: 'Carol'})
CREATE (a)-[:FRIEND]->(c);

// Lien avec les villes
MATCH (a:Person {name: 'Alice'}), (paris:City {name: 'Paris'})
CREATE (a)-[:LIVES_IN]->(paris);

MATCH (c:Person {name: 'Carol'}), (paris:City {name: 'Paris'})
CREATE (c)-[:LIVES_IN]->(paris);

MATCH (b:Person {name: 'Bob'}), (lyon:City {name: 'Lyon'})
CREATE (b)-[:LIVES_IN]->(lyon);

• Vérifiez que vos noeuds et relations ont été correctement créés en exécutant :

MATCH (n) RETURN n;

Manipulation des données

Ajouter des informations supplémentaires

• Ajouter un nouveau noeud pour David, un ami de Bob vivant à Lyon

CREATE (d:Person {name: 'David', age: 28, city: 'Lyon'});

MATCH (b:Person {name: 'Bob'}), (d:Person {name: 'David'})
CREATE (b)-[:FRIEND]->(d);

MATCH (d:Person {name: 'David'}), (lyon:City {name: 'Lyon'})
CREATE (d)-[:LIVES_IN]->(lyon);

Modifier des données

• Changer la ville de Bob pour Paris :

MATCH (b:Person {name: 'Bob'})
SET b.city = 'Paris';

MATCH (b)-[r:LIVES_IN]->(lyon:City {name: 'Lyon'})
DELETE r;

MATCH (b), (paris:City {name: 'Paris'})
CREATE (b)-[:LIVES_IN]->(paris);

Requêtes Cypher : Interroger le graphe

Requêtes de base

• Lister les noms de toutes les personnes :

MATCH (p:Person) RETURN p.name;

• Trouver les personnes vivant à Paris :

MATCH (p:Person)-[:LIVES_IN]->(c:City {name: 'Paris'})
RETURN p.name;

• Trouver tous les amis d'Alice :

MATCH (a:Person {name: 'Alice'})-[:FRIEND]->(friend)
RETURN friend.name;

• Trouver les amis des amis de Bob :

MATCH (b:Person {name: 'Bob'})-[:FRIEND]->()-[:FRIEND]->(fof)
RETURN DISTINCT fof.name;

Requêtes avancées

• Trouver toutes les personnes âgées de plus de 30 ans et vivant à Paris :

MATCH (p:Person)-[:LIVES_IN]->(c:City {name: 'Paris'})
WHERE p.age > 30
RETURN p.name, p.age;

• Lister toutes les personnes avec leur nombre d’amis :

MATCH (p:Person)-[:FRIEND]->(f)
RETURN p.name AS person, COUNT(f) AS friend_count
ORDER BY friend_count DESC;

• Lister toutes les villes avec le nombre d’habitants :

MATCH (c:City)<-[:LIVES_IN]-(p:Person)
RETURN c.name AS city, COUNT(p) AS population
ORDER BY population DESC;

7. Suppression de noeuds et relations

• Supprimer la relation d'amitié entre Alice et Carol :

MATCH (a:Person {name: 'Alice'})-[r:FRIEND]->(c:Person {name: 'Carol'})
DELETE r;

• Supprimer un noeud et toutes ses relations (par exemple, le noeud David) :

MATCH (d:Person {name: 'David'})
DETACH DELETE d;

8. Export des résultats

• Exporter une requête en CSV (optionnel) :
  • Neo4j permet d’exporter le résultat de requêtes en CSV. Par exemple, pour exporter les personnes et leur nombre d'amis :

CALL apoc.export.csv.query(
  "MATCH (p:Person)-[:FRIEND]->(f) RETURN p.name AS person, COUNT(f) AS friend_count",
  "/path/to/export/friends_count.csv",
  {}
)

9. Chargement de données avec LOAD CSV

Objectif de cette partie

Nous allons voir comment :

1. Charger un fichier CSV contenant des données.
2. Créer des noeuds et des relations en utilisant les données importées.
3. Utiliser LOAD CSV pour des imports plus complexes.

Exemple de fichier CSV

Supposons que vous ayez un fichier persons.csv qui contient des informations sur des personnes et un autre fichier friendships.csv qui contient des relations d'amitié entre elles.

9.1 Structure des fichiers CSV

Fichier persons.csv (personnes avec leurs attributs) :