TP : Découverte de Neo4j et du langage Cypher

De WIKOM

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.

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).

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;

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",
  {}
)

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.

Structure des fichiers CSV

Fichier persons.csv (personnes avec leurs attributs) :

name,age,city
Alice,30,Paris
Bob,25,Lyon
Carol,35,Paris
David,28,Lyon

Fichier friendships.csv (amitiés entre personnes) :

person1,person2
Alice,Bob
Alice,Carol
Bob,David

Ces fichiers doivent être placés dans un répertoire accessible par Neo4j. Si vous utilisez Neo4j Desktop, vous pouvez placer vos fichiers dans le répertoire import du dossier de la base de données (souvent situé sous neo4j/data/databases/<nom_base>/import).

Importer les noeuds de personnes

Pour charger les personnes et créer des noeuds, nous allons utiliser LOAD CSV :

Exécuter la commande suivante dans Neo4j Browser pour importer chaque ligne de persons.csv en tant que noeud Person.

LOAD CSV WITH HEADERS FROM 'file:///persons.csv' AS row
CREATE (p:Person {name: row.name, age: toInteger(row.age), city: row.city});
  • LOAD CSV WITH HEADERS : indique que le fichier CSV contient une ligne d'en-têtes.
  • AS row : chaque ligne est appelée row et ses colonnes sont accessibles par row.nom_colonne.
  • toInteger(row.age) : transforme la valeur de age en entier.

Vérifiez les noeuds créés :

MATCH (p:Person) RETURN p;

Importer les noeuds de villes (optionnel)

Si les villes sont listées séparément, vous pouvez les charger depuis un fichier cities.csv (structure : name), avec la commande :

LOAD CSV WITH HEADERS FROM 'file:///cities.csv' AS row
MERGE (c:City {name: row.name});

MERGE assure qu’une ville n'est créée qu'une seule fois, même si elle est mentionnée plusieurs fois.

Créer des relations d'amitié entre personnes

Une fois les noeuds de Person créés, importez les relations FRIEND depuis friendships.csv :

Exécuter la commande suivante pour établir des relations d’amitié :

LOAD CSV WITH HEADERS FROM 'file:///friendships.csv' AS row
MATCH (p1:Person {name: row.person1})
MATCH (p2:Person {name: row.person2})
CREATE (p1)-[:FRIEND]->(p2);
  • Ici, nous utilisons MATCH pour trouver les noeuds correspondant aux noms dans friendships.csv, puis CREATE pour créer une relation FRIEND entre eux.
  • Ce chargement suppose que les noms sont uniques pour chaque personne dans le graphe.

Vérifiez les relations créées :

MATCH (p1:Person)-[:FRIEND]->(p2:Person) RETURN p1.name, p2.name;

Import plus complexe : chargement de villes avec relations LIVES_IN

Si vous souhaitez créer des noeuds de villes en même temps que vous chargez des personnes et établir la relation LIVES_IN :

LOAD CSV WITH HEADERS FROM 'file:///persons.csv' AS row
MERGE (c:City {name: row.city})
CREATE (p:Person {name: row.name, age: toInteger(row.age)})
CREATE (p)-[:LIVES_IN]->(c);

Dans cet exemple, chaque ligne du fichier persons.csv :

  • Crée un noeud City s'il n'existe pas déjà (grâce à MERGE).
  • Crée un noeud Person avec les propriétés indiquées.
  • Crée une relation LIVES_IN reliant la personne à sa ville.

Requêtes de vérification

Après le chargement, exécutez les requêtes suivantes pour vérifier vos données :

Lister toutes les personnes et leurs villes :

MATCH (p:Person)-[:LIVES_IN]->(c:City)
RETURN p.name, p.age, c.name AS city;

Lister toutes les relations d'amitié :

MATCH (p1:Person)-[:FRIEND]->(p2:Person)
RETURN p1.name AS Person1, p2.name AS Person2;

Afficher tout le graphe pour visualiser les connexions :

MATCH (n) RETURN n;

Conclusion

Avec LOAD CSV, Neo4j permet d'importer des fichiers CSV et de transformer ces données en noeuds et relations, facilitant ainsi l'intégration de données externes. Ce processus est particulièrement utile pour les jeux de données volumineux où la création manuelle serait laborieuse.

En continuant, vous pouvez essayer de charger des données réelles, par exemple des réseaux de transport, des réseaux sociaux plus grands, ou des réseaux de collaboration pour vous familiariser davantage avec LOAD CSV.

Récupérée de « https://wiki.komansamparle.fr/index.php?title=TP_:_Découverte_de_Neo4j_et_du_langage_Cypher&oldid=2710 »