Atelier fondamental 2 — Neo4j : un nœud, des propriétés, une relation

Durée

25 min

Module

1/7

Prérequis

le labo tourne (etat affiche nœuds : 872), Neo4j Browser ouvert et connecté

Tu vas construire

deux nœuds à toi, Alice et Bob, reliés par une flèche, puis reliés au vrai graphe du cours, avant de tout effacer proprement

Livrable

la table de l'étape 8 (Alice, ses deux relations, leurs cibles)

Comment lire cette page. Dix étapes, une requête à la fois. Pour chacune : la requête à taper, ce que Neo4j Browser affiche, et ce qu'il faut regarder. Tape toi-même chaque requête. Les blocs « Pour bien comprendre » sont facultatifs. Si le labo n'est pas démarré ou si etat ne dit pas nœuds : 872, retourne à la pratique guidée, section En bref (kit : https://github.com/hrhouma2/aiopsatlas-recherche-graphes-labo-fr).

Objectif

Dans la pratique guidée, tu as compté 872 nœuds et 3 712 relations chargés par un script, et tu as regardé des bulles et des flèches que quelqu'un d'autre avait dessinées. Ici, tu dessines les tiennes. Un nœud vide d'abord, pour voir qu'un nœud c'est juste ça ; puis tu lui donnes un nom, un âge, une ville ; puis un deuxième nœud, et une flèche entre les deux ; puis une flèche vers un cours du vrai jeu de données. À la fin, le compteur de etat monte à 874, et tu le ramènes à 872 en supprimant ce que tu as créé, avec l'erreur qu'il faut avoir vue une fois pour comprendre ce qu'est une relation.

Le vocabulaire en une image

Un nœud est une bulle. Une étiquette dit de quel genre de bulle il s'agit (Personne, Cours, Ville) : c'est l'équivalent du nom de la table. Une propriété est une valeur écrite dans la bulle (nom: "Alice", age: 30) : une colonne. Une relation est une flèche entre deux bulles ; elle a un type en majuscules (CONNAIT, AIME), un sens, et peut porter ses propres propriétés. En SQL, la flèche serait une clé étrangère ou une table de jointure ; ici c'est un objet à part entière, que tu crées, lis et supprimes comme un nœud.

Deux règles d'écriture Cypher à retenir : une bulle s'écrit entre parenthèses (p:Personne), une flèche entre crochets avec un tiret et une pointe -[:CONNAIT]->. La lettre devant les deux-points (p, a, r) est un nom temporaire que tu choisis pour réutiliser l'objet dans la même requête.

Où taper, et comment lire la réponse

Ouvre http://localhost:7474, connecte-toi (neo4j / aiopsatlas2026, URL localhost:7687). L'éditeur est la ligne neo4j$ en haut. Tu envoies avec Ctrl + Entrée (Cmd + Entrée sur macOS) ou le bouton ▶ à droite. Chaque requête ouvre un cadre sous l'éditeur, le plus récent en haut.

Un cadre affiche deux choses. En haut, une ligne verte de bilan : Created 1 node, added 1 label, Set 1 property, Deleted 2 nodes… C'est elle qui te dit ce que la requête a changé. En dessous, si la requête a un RETURN, le résultat en trois vues : Graph (les bulles et les flèches), Table (les valeurs en colonnes), Raw (le JSON brut). Une requête sans RETURN n'affiche que le bilan et Completed after … ms.

Étape 1 — Créer un nœud, juste une étiquette

CREATE (p:Personne) RETURN p

Ce que la requête demande : crée une bulle portant l'étiquette Personne, appelle-la p le temps de la requête, et montre-la-moi.

Bilan : Created 1 node, added 1 label, puis Started streaming 1 record after 1 ms and completed after 2 ms.

À regarder : vue Graph, une seule bulle, et à droite dans Results overview : Nodes (1) avec la pastille Personne (1). Clique sur la bulle : le panneau ne liste aucune propriété. C'est un nœud minimal : une étiquette, rien d'autre. Équivalent SQL : INSERT INTO personne DEFAULT VALUES, dans une table qui n'aurait aucune colonne.

Étape 2 — Lui donner une valeur

MATCH (p:Personne) SET p.nom = 'Alice' RETURN p

Ce que la requête demande : trouve les bulles Personne (il n'y en a qu'une), écris dedans nom = 'Alice', montre-la.

Bilan : Set 1 property.

À regarder : la bulle porte maintenant Alice en légende (Browser affiche par défaut la première propriété texte). Clique dessus : nom: Alice. Équivalent SQL : UPDATE personne SET nom = 'Alice'.

Étape 3 — Plusieurs valeurs d'un coup

MATCH (p:Personne {nom: 'Alice'}) SET p.age = 30, p.ville = 'Montréal' RETURN p

Ce que la requête demande : trouve la bulle Personne dont le nom est Alice, écris deux valeurs de plus.

Bilan : Set 2 properties.

À regarder : la bulle, en cliquant, montre nom: Alice, age: 30, ville: Montréal. Le {nom: 'Alice'} entre accolades est un filtre : « celle dont nom vaut Alice », le WHERE nom = 'Alice' de SQL. Il ne change rien ici (une seule Personne), mais dès l'étape suivante il devient indispensable.

Étape 4 — Créer un nœud avec ses valeurs en une fois

CREATE (b:Personne {nom: 'Bob', age: 25}) RETURN b

Ce que la requête demande : crée une bulle Personne qui a tout de suite nom et age.

Bilan : Created 1 node, set 2 properties, added 1 label.

Regarde maintenant tes deux bulles en tableau :

MATCH (p:Personne) RETURN p.nom, p.age, p.ville

Vue Table :

p.nom    p.age  p.ville
"Alice"  30     "Montréal"
"Bob"    25     null

À regarder : null pour la ville de Bob : il n'a pas cette propriété. En SQL ce serait une cellule vide de la colonne ville ; ici, la case n'existe pas du tout. Équivalent SQL : SELECT nom, age, ville FROM personne.

Étape 5 — Relier Alice à Bob

MATCH (a:Personne {nom: 'Alice'}), (b:Personne {nom: 'Bob'})
CREATE (a)-[:CONNAIT]->(b)

Ce que la requête demande : trouve Alice, appelle-la a ; trouve Bob, appelle-le b ; crée une flèche de type CONNAIT qui part de a et arrive sur b.

Bilan : Created 1 relationship, puis Completed after … ms. Pas de résultat : il n'y a pas de RETURN.

Regarde la flèche :

MATCH (a:Personne)-[r]->(b:Personne) RETURN a, r, b

Ce que la requête demande : toutes les flèches, quel que soit leur type ([r] sans :TYPE), qui vont d'une Personne à une Personne.

À regarder : vue Graph, deux bulles et une flèche avec CONNAIT écrit dessus, dans le sens Alice → Bob. À droite, Results overview : Nodes (2), Relationships (1) avec la pastille CONNAIT (1). Équivalent SQL : INSERT INTO connait (personne_source, personne_cible) VALUES (id_alice, id_bob), dans une table de jointure que tu aurais dû créer avant.

Étape 6 — Une valeur sur la flèche

MATCH (:Personne {nom: 'Alice'})-[r:CONNAIT]->(:Personne {nom: 'Bob'})
SET r.depuis = 2024
RETURN r

Ce que la requête demande : trouve la flèche CONNAIT qui va d'Alice à Bob, appelle-la r, écris dessus depuis = 2024.

Bilan : Set 1 property.

Lis tout en tableau :

MATCH (a:Personne)-[r:CONNAIT]->(b:Personne)
RETURN a.nom, type(r), r.depuis, b.nom

a.nom    type(r)    r.depuis  b.nom
"Alice"  "CONNAIT"  2024      "Bob"

À regarder : type(r) donne le type de la flèche ; r.depuis sa propriété, exactement comme p.nom pour une bulle. Une relation se traite comme un nœud : on la trouve, on la nomme, on lit et on écrit dedans. Les bulles sans nom temporaire, (:Personne {…}), sont celles dont tu n'as pas besoin après : tu peux omettre la lettre.

Étape 7 — La flèche a un sens

MATCH (:Personne {nom: 'Bob'})-[:CONNAIT]->(x) RETURN x.nom

Ce que la requête demande : qui Bob connaît-il ? Les bulles x au bout d'une flèche CONNAIT qui part de Bob.

(no changes, no records)

À regarder : zéro ligne. La seule flèche va d'Alice vers Bob ; aucune ne part de Bob. Maintenant sans la pointe :

MATCH (:Personne {nom: 'Bob'})-[:CONNAIT]-(x) RETURN x.nom

x.nom
"Alice"

-[:CONNAIT]- sans > : « une flèche CONNAIT entre Bob et x, dans un sens ou dans l'autre ». Alice apparaît. Retiens : à l'écriture, le sens est obligatoire ; à la lecture, tu choisis d'en tenir compte ou pas. C'est ce qui rend « qui est lié à qui » si court à écrire en Cypher.

Étape 8 — Relier ta bulle au vrai graphe

MATCH (a:Personne {nom: 'Alice'}), (c:Cours {id: 'C0001'})
CREATE (a)-[:AIME]->(c)

Ce que la requête demande : trouve Alice, trouve le cours C0001 du jeu de données, crée une flèche AIME de l'une vers l'autre.

Bilan : Created 1 relationship.

Alice est maintenant reliée à une bulle qui existait avant toi. Regarde tout ce qui part d'elle :

MATCH (a:Personne {nom: 'Alice'})-[r]->(x)
RETURN a.nom, type(r), labels(x)[0] AS type_cible, coalesce(x.nom, x.titre) AS cible

a.nom    type(r)    type_cible  cible
"Alice"  "AIME"     "Cours"     "Docker expliqué simplement"
"Alice"  "CONNAIT"  "Personne"  "Bob"

À regarder : deux lignes, deux types de flèche, deux types de cible. labels(x)[0] donne l'étiquette de la bulle au bout ; coalesce(x.nom, x.titre) prend nom s'il existe, sinon titre (Bob a un nom, le cours a un titre). C'est ta table-livrable : garde-la. En SQL, il aurait fallu une jointure par table de cible et un UNION ; ici, une seule ligne de MATCH.

Passe en vue Graph sur MATCH (a:Personne {nom: 'Alice'})-[r]->(x) RETURN a, r, x : Alice au centre, Bob d'un côté, le cours de l'autre, en deux couleurs (une par étiquette).

Étape 9 — Compter

MATCH (n) RETURN count(n) AS noeuds

noeuds
874

872 + tes 2 bulles. Par étiquette :

MATCH (n) RETURN labels(n)[0] AS label, count(*) ORDER BY label

label         count(*)
"Competence"  22
"Cours"       504
"Etudiant"    300
"Personne"    2
"Professeur"  30
"Ville"       16

À regarder : une sixième ligne, Personne 2. Dans un terminal, .\labo.ps1 etat ou ./labo.sh etat affiche maintenant ✔ Neo4j répond — nœuds : 874. Le script et Neo4j Browser comptent la même chose par deux chemins : c'est la vérification croisée de la pratique guidée, appliquée à ce que tu as créé toi-même.

Étape 10 — Nettoyer, et rencontrer l'erreur qui explique tout

Essaie d'abord la suppression naïve :

MATCH (p:Personne) DELETE p

Neo.ClientError.Schema.ConstraintValidationFailed
Cannot delete node<874>, because it still has relationships. To delete this node, you must first delete its relationships.

À regarder : un cadre rouge, rien supprimé. Neo4j refuse d'effacer une bulle qui a encore des flèches : une flèche sans bulle au bout n'aurait pas de sens. Le numéro node<874> est l'identifiant interne de la première bulle qu'il a tenté de supprimer ; chez toi il diffère. C'est l'équivalent d'une violation de clé étrangère en SQL, avec une différence : ici, le remède tient en un mot.

MATCH (p:Personne) DETACH DELETE p

Ce que la requête demande : trouve les bulles Personne, détache-les (supprime leurs flèches), puis supprime-les.

Bilan : Deleted 2 nodes, deleted 2 relationships.

Deux nœuds, deux relations : CONNAIT et AIME. Le cours C0001 n'a pas été touché, seule la flèche qui y menait a disparu. Vérifie :

MATCH (n) RETURN count(n) AS noeuds

noeuds
872

MATCH (n) RETURN labels(n)[0] AS label, count(*) ORDER BY label rend à nouveau cinq lignes, sans Personne, et etat dit nœuds : 872.

Vérification finale

• Tu as créé un nœud avec une seule étiquette et vu qu'il n'a aucune propriété.
• Tu lui as donné nom, puis age et ville, avec SET, en le retrouvant d'abord avec MATCH.
• Tu as créé Bob avec ses valeurs en une requête, et vu null là où une propriété manque.
• Tu as créé CONNAIT entre deux bulles existantes, mis depuis dessus, et lu type(r) et r.depuis en table.
• Tu sais dire pourquoi (Bob)-[:CONNAIT]->(x) ne rend rien et (Bob)-[:CONNAIT]-(x) rend Alice.
• Tu as relié Alice au cours C0001 et gardé la table à deux lignes de l'étape 8 comme livrable.
• Tu as vu l'erreur Cannot delete node … because it still has relationships, puis DETACH DELETE a rendu Deleted 2 nodes, deleted 2 relationships.
• MATCH (n) RETURN count(n) et etat disent 872.

Si ça coince