Le langage Cypher

Cypher est le langage déclaratif utilisé par Neo4j pour manipuler des bases de données orientées graphe.

déclaratif signifie que l'on décrit ce que l'on souhaite obtenir, et Neo4j choisit la meilleure manière de parcourir le graphe.

Alors que le langage SQL cherche des lignes dans des tables, Cypher cherche des chemins dans un graphe.

Le modèle de données

Les nœuds (Nodes)

Les entités de données dans une base de données de graphe Neo4j sont appelées nœuds. Les noeuds sont mentionnés dans Cypher en utilisant des parenthèses ( ).

Par exemple :

• une personne
• une entreprise
• une ville
• un produit

(p)

Les étiquettes (Labels)

Les étiquettes sont utilisées pour spécifier le ou les types de nœuds spécifiques. Un nœud peut être assigné à une ou plusieurs étiquettes.

(p:Personne)

(p:Personne:Client)

Les propriétés (Properties)

Les propriétés sont définies dans des accolades { }, et sont utilisées pour fournir aux nœuds des informations spécifiques. Les propriétés sont comparables aux colonnes d'une table SQL et peuvent également être interrogées pour améliorer la capacité à sélectionner les données.

(p:Personne {
    nom: "Dupont",
    prenom: "Jean",
    age: 32
})

Les variables

Les variables permettent de référencer des nœuds spécifiés dans les clauses suivantes. Dans les exemples précédent p est une variable.

Les relations (Relationships)

Les nœuds d'un graphe peuvent être reliés par des relations. Une relation doit avoir un nœud de départ, un nœud de fin, et exactement un type. Les relations sont représentées dans Cypher avec des flèches (par exemple - ->) indiquant la direction de la relation. Contrairement aux nœuds, l'information dans un modèle de relation doit être enfermée par des crochets [ ].

Une relation possède :

• une direction,
• une seule étiquette,
• éventuellement des propriétés.

(p)-[:AMI]->(a)

(p)-[:ACHAT {
    date: date(),
    montant: 120
}]->(commande)

Les chemins (Paths)

Les chemins d'un graphe sont constitués de nœuds et de relations connectés. L'exploration de ces chemins se trouve au cœur même de Cypher.

Les motifs (Patterns)

Un motif est un requête déclarative utilisé pour naviguer, décrire et extraire des données à partir d'un graphe. Toute requête Cypher repose sur un motif.

(Personne)-[:TRAVAILLE_POUR]->(Entreprise)

Un motif de graphe décrit des données à l'aide d'une syntaxe similaire à la manière dont les nœuds et les relations d'un graphe à propriétés sont dessinés sur un tableau blanc. Sur un tableau blanc, les nœuds sont représentés par des cercles et les relations par des flèches. Cypher représente les cercles par une paire de parenthèses (``), et les flèches par des tirets accompagnés du symbole « supérieur à » ou « inférieur à » :

()-->()<--()

Commandes

CREATE

Créer un nœud.

CREATE
(:Ville {nom:"Nancy"}),
(:Ville {nom:"Paris"})

Créer une relation. On sélectionne 2 nœuds, puis on créé la route entre les deux nœud.

MATCH
(a:Ville {nom:"Nancy"}),
(b:Ville {nom:"Paris"})
CREATE
(a)-[:ROUTE]->(b)

MATCH

MATCH recherche des motifs.

Toutes les requêtes commencent généralement par MATCH.

MATCH (p:Personne)
RETURN p

Cette requête signifie :

retrouver tous les nœuds ayant le label Personne.

Recherche avec propriété

MATCH (p:Personne {nom:"Dupont"})
RETURN p

WHERE

WHERE permet de filtrer.

MATCH (p:Personne)
WHERE p.age > 30
RETURN p

Plusieurs conditions :

WHERE p.age > 30
AND p.ville = "Nancy"

LIKE est remplacé par plusieurs opérateurs.

STARTS WITH

ENDS WITH

CONTAINS

Exemple

MATCH (p:Personne)
WHERE p.nom STARTS WITH "Du"
RETURN p

RETURN

RETURN indique les informations à afficher.

Retourner le nœud entier :

RETURN p

Seulement quelques propriétés :

RETURN
p.nom,
p.age

Renommer les colonnes :

RETURN
p.nom AS Nom,
p.age AS Age

Les relations

On peut rechercher des relations.

MATCH
(p)-[:AMI]->(a)

RETURN p,a

On peut ignorer le sens.

MATCH
(p)-[:AMI]-(a)

Ou rechercher le sens inverse.

MATCH
(p)<-[:AMI]-(a)

Plusieurs relations

Cypher est particulièrement puissant ici.

Deux relations :

MATCH

(p)-[:AMI]->()-[:AMI]->(x)

RETURN x

Le nœud intermédiaire est volontairement anonyme.

Longueur variable

Cypher sait parcourir un graphe sur plusieurs niveaux.

MATCH

(p)-[:AMI*]->(x)

Tous les chemins.

Limiter :

[:AMI*1..3]

Entre 1 et 3 relations.

Exactement 2 :

[:AMI*2]

MERGE

MERGE est probablement l'instruction la plus importante après MATCH.

Elle signifie :

retrouve cet élément,

sinon crée-le.

MERGE
(p:Ville {nom:"Nancy"})

Si Nancy existe :

rien n'est créé.

Sinon :

Nancy est créée.

---

On peut distinguer les deux cas.

MERGE (p:Ville {nom:"Nancy"})

ON CREATE

SET p.creation = datetime()

ON MATCH

SET p.nbAcces =
coalesce(p.nbAcces,0)+1

SET

Modifier des propriétés.

MATCH (p)
SET p.age = 35

Plusieurs modifications.

SET

p.nom="Martin",
p.age=40

DELETE

Supprimer un nœud.

DELETE p

Si le nœud possède des relations :

DETACH DELETE p

Les relations sont supprimées automatiquement.

13. REMOVE

Supprimer une propriété.

REMOVE p.age

Supprimer un label.

REMOVE p:Client

14. ORDER BY

Tri.

ORDER BY p.age

Décroissant.

ORDER BY p.age DESC

15. LIMIT

Limiter les résultats.

LIMIT 10

16. Les fonctions d'agrégation

Comme en SQL, vous pouvez utiliser des fonctions d'agrégation

Fonction	Syntaxe
Compter	count(p)
Moyenne	avg()
Somme	sum()
Maximum	max()
Minimum	min()

MATCH (p)
RETURN count(p)

17. WITH

WITH permet de créer un pipeline.

Exemple.

MATCH (p:Personne)

WITH p

WHERE p.age>30

RETURN p

On peut également agréger.

MATCH (p)

WITH count(*) AS nb

RETURN nb

18. OPTIONAL MATCH

Comparable à un LEFT JOIN.

MATCH (p:Personne)

OPTIONAL MATCH

(p)-[:MARIÉ]->(c)

RETURN p,c

Les personnes sans conjoint sont tout de même retournées.

19. UNWIND

Transformer une liste en lignes.

UNWIND

["Paris","Nancy","Lyon"]

AS ville

RETURN ville

Résultat :

Paris

Nancy

Lyon

20. Les paramètres

Toujours préférer les paramètres.

Au lieu de

MATCH

(p {nom:"Martin"})

écrire

MATCH

(p {nom:$nom})

avec

{
  "nom":"Martin"
}

Cela évite les injections et améliore les performances.

21. Les chemins

Cypher peut retourner un chemin complet.

MATCH

chemin=(a)-[:AMI*]->(b)

RETURN chemin

Le résultat contient :

• les nœuds
• les relations
• leur ordre

22. Fonctions utiles

Quelques fonctions intégrées :

labels(n)

type(r)

properties(n)

keys(n)

elementId(n)

Exemple.

MATCH (n)

RETURN labels(n)