Voir la source de TP : Découverte de Neo4j et du langage Cypher


== Objectif ==
Apprendre à :

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

== Prérequis ==
# Avoir Neo4j installé sur votre machine (ou accéder à une instance Neo4j dans le cloud).
#*[[Préparer son environnement Neo4j]]
# Avoir accès à Neo4j Browser ou [https://neo4j.com/download/ Neo4j Desktop].

== Partie 1 : Mise en place de l'environnement ==

# '''Installation de Neo4j''' : Suivez les instructions d'installation de Neo4j pour votre système d'exploitation depuis le site officiel [https://neo4j.com/download/ Neo4j Download Center].
# '''Lancer Neo4j''' : Une fois installé, démarrez le serveur Neo4j et ouvrez le Neo4j Browser pour commencer.
# '''Créer un projet dans Neo4j Browser''' : Dans Neo4j Browser, créez un nouveau projet que vous appellerez "TP_Neo4j".

== 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 : <code>Person</code>, <code>City</code>).
* '''Relations''' : Les connexions entre les noeuds (par exemple : <code>FRIEND</code>, <code>LIVES_IN</code>).
* '''Propriétés''' : Attributs stockés pour chaque noeud ou relation (par exemple : <code>name</code>, <code>age</code>, <code>date</code>).

== Mise en place de Neo4j ==

=== Installation de Neo4j ===

# '''Télécharger Neo4j''' : Rendez-vous sur Neo4j Download Center pour télécharger la version compatible avec votre système d'exploitation.
# '''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.
# '''Accéder à Neo4j Browser''' :
#* Ouvrez <code>Neo4j Browser</code> pour exécuter les requêtes Cypher.
#* Par défaut, accédez-y à l'adresse suivante : <code><nowiki>http://localhost:7474</nowiki></code>.
# '''Se connecter''' :
#* Par défaut, utilisez l'utilisateur <code>neo4j</code> 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 :

# '''Noeuds''' :
#* <code>Person</code> : chaque personne possède des attributs <code>name</code>, <code>age</code>, et <code>city</code>.
#* <code>City</code> : ville avec l'attribut <code>name</code>.
# '''Relations''' :
#* <code>FRIEND</code> : relation d'amitié entre deux personnes.
#* <code>LIVES_IN</code> : relation entre une personne et sa ville.
# '''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.'''
<syntaxhighlight lang="cypher">
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'});
</syntaxhighlight>

=== Étape 2 : Création des relations ===

* '''Maintenant, créez les relations entre les noeuds.'''
<syntaxhighlight lang="cypher">
// 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);

</syntaxhighlight>

* '''Vérifiez que vos noeuds et relations ont été correctement créés en exécutant :'''
<syntaxhighlight lang="cypher">
MATCH (n) RETURN n;
</syntaxhighlight>
== Manipulation des données ==

=== Ajouter des informations supplémentaires ===

* '''Ajouter un nouveau noeud pour David, un ami de Bob vivant à Lyon'''
<syntaxhighlight lang="cypher">
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);

</syntaxhighlight>

=== Modifier des données ===

* '''Changer la ville de Bob pour Paris''' :
<syntaxhighlight lang="cypher">
MATCH (b:Person {name: 'Bob'})
SET b.city = 'Paris';

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

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

== Requêtes Cypher : Interroger le graphe ==

=== Requêtes de base ===

* '''Lister les noms de toutes les personnes''' :
<syntaxhighlight lang="cypher">
MATCH (p:Person) RETURN p.name;
</syntaxhighlight>
*
* '''Trouver les personnes vivant à Paris''' :
<syntaxhighlight lang="cypher">
MATCH (p:Person)-[:LIVES_IN]->(c:City {name: 'Paris'})
RETURN p.name;
</syntaxhighlight>
*
* '''Trouver tous les amis d'Alice''' :
<syntaxhighlight lang="cypher">
MATCH (a:Person {name: 'Alice'})-[:FRIEND]->(friend)
RETURN friend.name;
</syntaxhighlight>
*
* '''Trouver les amis des amis de Bob''' :
<syntaxhighlight lang="cypher">
MATCH (b:Person {name: 'Bob'})-[:FRIEND]-()-[:FRIEND]-(fof)
RETURN DISTINCT fof.name;
</syntaxhighlight>
#

=== Requêtes avancées ===

* '''Trouver toutes les personnes âgées de plus de 30 ans et vivant à Paris''' :
<syntaxhighlight lang="cypher">
MATCH (p:Person)-[:LIVES_IN]->(c:City {name: 'Paris'})
WHERE p.age > 30
RETURN p.name, p.age;
</syntaxhighlight>
*
* '''Lister toutes les personnes avec leur nombre d’amis''' :
<syntaxhighlight lang="cypher">
MATCH (p:Person)-[:FRIEND]-(f)
RETURN p.name AS person, COUNT(f) AS friend_count
ORDER BY friend_count DESC;
</syntaxhighlight>
*
* '''Lister toutes les villes avec le nombre d’habitants''' :
<syntaxhighlight lang="cypher">
MATCH (c:City)<-[:LIVES_IN]-(p:Person)
RETURN c.name AS city, COUNT(p) AS population
ORDER BY population DESC;
</syntaxhighlight>
#

== 7. Suppression de noeuds et relations ==

* '''Supprimer la relation d'amitié entre Alice et Carol''' :
<syntaxhighlight lang="cypher">
MATCH (a:Person {name: 'Alice'})-[r:FRIEND]->(c:Person {name: 'Carol'})
DELETE r;
</syntaxhighlight>
*
* '''Supprimer un noeud et toutes ses relations''' (par exemple, le noeud David) :
<syntaxhighlight lang="cypher">
MATCH (d:Person {name: 'David'})
DETACH DELETE d;
</syntaxhighlight>
#

== Chargement de données avec <code>LOAD CSV</code> ==

=== Objectif de cette partie ===
Nous allons voir comment :

# Charger un fichier CSV contenant des données.
# Créer des noeuds et des relations en utilisant les données importées.
# Utiliser <code>LOAD CSV</code> pour des imports plus complexes.

=== Exemple de fichier CSV ===
Supposons que vous ayez un fichier <code>persons.csv</code> qui contient des informations sur des personnes et un autre fichier <code>friendships.csv</code> qui contient des relations d'amitié entre elles.

==== Structure des fichiers CSV ====
'''Fichier <code>persons.csv</code>''' (personnes avec leurs attributs) :<syntaxhighlight lang="cypher">
name,age,city
Alice,30,Paris
Bob,25,Lyon
Carol,35,Paris
David,28,Lyon

</syntaxhighlight>'''Fichier <code>friendships.csv</code>''' (amitiés entre personnes) :<syntaxhighlight lang="cypher">
person1,person2
Alice,Bob
Alice,Carol
Bob,David
</syntaxhighlight>
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 <code>import</code> du dossier de la base de données (souvent situé sous <code>neo4j/data/databases/<nom_base>/import</code>).

=== Importer les noeuds de personnes ===
Pour charger les personnes et créer des noeuds, nous allons utiliser <code>LOAD CSV</code> :

'''Exécuter la commande suivante''' dans Neo4j Browser pour importer chaque ligne de <code>persons.csv</code> en tant que noeud <code>Person</code>.<syntaxhighlight lang="cypher">
LOAD CSV WITH HEADERS FROM 'file:///persons.csv' AS row
CREATE (p:Person {name: row.name, age: toInteger(row.age), city: row.city});
</syntaxhighlight>

* <code>LOAD CSV WITH HEADERS</code> : indique que le fichier CSV contient une ligne d'en-têtes.
* <code>AS row</code> : chaque ligne est appelée <code>row</code> et ses colonnes sont accessibles par <code>row.nom_colonne</code>.
* <code>toInteger(row.age)</code> : transforme la valeur de <code>age</code> en entier.

'''Vérifiez les noeuds créés''' :<syntaxhighlight lang="cypher">
MATCH (p:Person) RETURN p;
</syntaxhighlight>

=== Importer les noeuds de villes (optionnel) ===
Si les villes sont listées séparément, vous pouvez les charger depuis un fichier <code>cities.csv</code> (structure : <code>name</code>), avec la commande :<syntaxhighlight lang="cypher">
LOAD CSV WITH HEADERS FROM 'file:///cities.csv' AS row
MERGE (c:City {name: row.name});
</syntaxhighlight><code>MERGE</code> 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 <code>Person</code> créés, importez les relations <code>FRIEND</code> depuis <code>friendships.csv</code> :

'''Exécuter la commande suivante''' pour établir des relations d’amitié :<syntaxhighlight lang="cypher">
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);
</syntaxhighlight>

* Ici, nous utilisons <code>MATCH</code> pour trouver les noeuds correspondant aux noms dans <code>friendships.csv</code>, puis <code>CREATE</code> pour créer une relation <code>FRIEND</code> entre eux.
* Ce chargement suppose que les noms sont uniques pour chaque personne dans le graphe.

'''Vérifiez les relations créées''' :<syntaxhighlight lang="cypher">
MATCH (p1:Person)-[:FRIEND]->(p2:Person) RETURN p1.name, p2.name;
</syntaxhighlight>

=== Import plus complexe : chargement de villes avec relations <code>LIVES_IN</code> ===
Si vous souhaitez créer des noeuds de villes en même temps que vous chargez des personnes et établir la relation <code>LIVES_IN</code> :<syntaxhighlight lang="cypher">
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);
</syntaxhighlight>Dans cet exemple, chaque ligne du fichier <code>persons.csv</code> :

* Crée un noeud <code>City</code> s'il n'existe pas déjà (grâce à <code>MERGE</code>).
* Crée un noeud <code>Person</code> avec les propriétés indiquées.
* Crée une relation <code>LIVES_IN</code> 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''' :<syntaxhighlight lang="cypher">
MATCH (p:Person)-[:LIVES_IN]->(c:City)
RETURN p.name, p.age, c.name AS city;
</syntaxhighlight>'''Lister toutes les relations d'amitié''' :<syntaxhighlight lang="cypher">
MATCH (p1:Person)-[:FRIEND]->(p2:Person)
RETURN p1.name AS Person1, p2.name AS Person2;
</syntaxhighlight>'''Afficher tout le graphe pour visualiser les connexions''' :<syntaxhighlight lang="cypher">
MATCH (n) RETURN n;
</syntaxhighlight>

=== Conclusion ===
Avec <code>LOAD CSV</code>, 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 <code>LOAD CSV</code>. 
#
*