Instruction MATCH

Vue d’ensemble

L’instruction MATCH vous permet de spécifier des motifs de graphe à rechercher dans le graphe. C'est l'instruction fondamentale pour récupérer des données du graphe et les lier à des variables à utiliser dans les parties ultérieures de la requête.

<match statement> ::=  
  [ "OPTIONAL" ] "MATCH" <graph pattern> [ <graph pattern yield clause> ]

<graph pattern yield clause> ::=  
  "YIELD" <graph pattern yield item> [ { "," <graph pattern yield item> }... ]

<graph pattern yield item> ::= <element variable> | <path variable>

Détails

• Vous pouvez utiliser le mot-clé OPTIONAL avec MATCH. La différence clé entre MATCH et OPTIONAL MATCH réside dans leur gestion des motifs non concordants :
  • MATCH : Si le motif ne correspond pas, aucun enregistrement n'est retourné.
  • OPTIONAL MATCH : Si le motif ne correspond pas, la requête retourne une valeur null.
• L'instruction MATCH prend en charge la clause WHERE pour appliquer des conditions de recherche au motif de graphe.
• L'instruction MATCH prend en charge la clause YIELD du motif de graphe pour sélectionner des variables à exposer dans les parties ultérieures de la requête.

Exemple de Graphe

Les exemples suivants s'exécutent sur ce graphe :

Pour créer ce graphe, exécutez la requête suivante sur un graphe vide :

INSERT (rowlock:User {_id: 'U01', name: 'rowlock'}),
       (brainy:User {_id: 'U02', name: 'Brainy'}),
       (purplechalk:User {_id: 'U03', name: 'purplechalk'}),
       (mochaeach:User {_id: 'U04', name: 'mochaeach'}),
       (lionbower:User {_id: 'U05', name: 'lionbower'}),
       (c01:Club {_id: 'C01', since: 2005}),
       (c02:Club {_id: 'C02', since: 2005}),
       (rowlock)-[:Follows {createdOn: '2024-1-5'}]->(brainy),
       (mochaeach)-[:Follows {createdOn: '2024-2-10'}]->(brainy),
       (brainy)-[:Follows {createdOn: '2024-2-1'}]->(purplechalk),
       (purplechalk)-[:Follows {createdOn: '2024-5-3'}]->(lionbower),
       (brainy)-[:Joins {memberNo: 1}]->(c01),
       (lionbower)-[:Joins {memberNo: 2}]->(c01),
       (mochaeach)-[:Joins {memberNo: 9}]->(c02)

Correspondance de Tous les Nœuds

Pour correspondre à tous les nœuds, utilisez un motif de nœud sans filtres d'étiquette ni de propriété.

MATCH (n)
RETURN n

Résultat : n

Correspondance de Toutes les Arêtes

Pour correspondre à toutes les arêtes, utilisez un motif d'arête sans filtres d'étiquette ni de propriété. Notez qu'un motif d'arête ne peut être utilisé qu'avec des motifs de nœuds de chaque côté, formant un motif de chemin.

MATCH ()-[e]-()
RETURN e

Résultat : e

Étant donné que la direction de l'arête n'est pas spécifiée dans la requête ci-dessus, chaque arête du graphe est retournée deux fois. Deux chemins sont considérés comme distincts lorsque leurs séquences d'éléments diffèrent.

Pour retourner toutes les arêtes sans duplication dans le graphe, vous pouvez spécifier la direction de l'arête explicitement soit en sortie (>) soit en entrée (<).

MATCH ()<-[e]-()
RETURN e

Résultat : e

Correspondance avec des Étiquettes

Le motif de nœud et le motif d'arête supportent l’expression d'étiquette pour spécifier une ou plusieurs étiquettes de nœuds et d'arêtes.

Cette requête récupère tous les nœuds étiquetés Club :

MATCH (n:Club)
RETURN n

Résultat : n

Cette requête récupère tous les nœuds connectés à Brainy avec des arêtes sortantes étiquetées Follows ou Joins :

MATCH (:User {name: 'Brainy'})-[:Follows|Joins]->(n)
RETURN n

Résultat : n

Correspondance avec Spécification de Propriété Clé-Valeur

La spécification de propriété d'élément peut être incluse dans les motifs de nœuds et les motifs d'arêtes qui appliquent des égalités jointes pour filtrer les nœuds et arêtes avec des paires clé-valeur.

Cette requête récupère les nœuds étiquetés Club dont le code et since ont des valeurs spécifiques :

MATCH (n:Club {_id: 'C01', since: 2005})
RETURN n

Résultat : n

Cette requête récupère le membre du club C01 dont memberNo est 1 :

MATCH (:Club {code: 'C01'})<-[:Joins {memberNo: 1}]->(n)
RETURN n

Résultat : n

Correspondance avec des Arêtes Abrégées

Lorsque les étiquettes et les propriétés des arêtes ne sont pas pertinentes, et que les variables ne sont pas nécessaires pour une référence ultérieure, vous pouvez simplifier en utilisant des motifs d'arêtes abrégés. La direction des arêtes peut toujours être spécifiée si nécessaire.

Cette requête récupère les nœuds connectés avec mochaeach par n'importe quelle arête sortante :

MATCH (:User {name: 'mochaeach'})->(n)
RETURN n

Résultat : n

Correspondance de Chemins

Cette requête récupère le name des utilisateurs suivis par mochaeach, et le code des clubs rejoints par ces utilisateurs :

MATCH p = (:User {name: 'mochaeach'})-[:Follows]->(:User)-[:Joins]->(:Club)
RETURN p

Résultat :

Correspondance avec Clauses WHERE

La clause WHERE peut être utilisée de manière optionnelle dans un motif d'élément, une expression de chemin parenthésée, ou immédiatement après un motif de graphe lorsque le motif de graphe est utilisé dans l'instruction MATCH pour spécifier diverses conditions de recherche.

Clause WHERE de Motif d'Élément

Cette requête récupère les chemins à 1 pas avec des arêtes sortantes étiquetées Follows, où la propriété createdOn des arêtes est supérieure à une date spécifiée :

MATCH p = ()-[e:Follows WHERE e.createdOn > '2024-4-1']->()
RETURN p

Résultat :

Clause WHERE de Motif de Chemin Parenthésé

Cette requête récupère des chemins d'un à deux pas contenant des arêtes étiquetées Follows, où la propriété createdOn de ces arêtes est inférieure à la valeur spécifiée :

MATCH p = (()-[e:Follows]->() WHERE e.createdOn < "2024-2-5"){1,2}
RETURN p

Résultat :

Clause WHERE de Motif de Graphe

Cette requête récupère les membres du club C01 dont memberNo est supérieur à 1 :

MATCH (c:Club)<-[e:Joins]->(n)
WHERE c._id = 'C01' AND e.memberNo > 1
RETURN n

Résultat : n

Correspondance de Chemins Quantifiés

Un motif de chemin quantifié construit un chemin dans lequel soit l'ensemble du chemin soit un segment de celui-ci est répété un nombre de fois spécifié.

Utilisation des Arêtes Quantifiées

Cette requête récupère les nœuds distincts liés à lionbower en 1 à 3 sauts :

MATCH (:User {name: 'lionbower'})-[]-{1,3}(n)
RETURN DISTINCT n._id AS IDs

Résultat :

Utilisation des Chemins Quantifiés

Cette requête récupère les chemins qui commencent par des sous-chemins d'un à deux pas contenant des arêtes étiquetées Follows, où la propriété createdOn de ces arêtes est supérieure à la valeur spécifiée, et ces sous-chemins doivent se connecter au nœud C01:

MATCH p = (()-[e:Follows]->() WHERE e.createdOn > "2024-1-31"){1,2}()-({_id:"C01"})
RETURN p

Résultat :

Correspondance de Chemins les Plus Courts

Un chemin le plus court entre deux nœuds est le chemin qui a le moins d'arêtes.

Cette requête récupère tous les chemins les plus courts entre lionbower et purplechalk dans un rayon de 5 sauts :

MATCH p = ALL SHORTEST (n1:User)-[]-{,5}(n2:User)
WHERE n1.name = 'lionbower' AND n2.name = 'purplechalk'
RETURN p

Résultat :

Correspondance de Chemins Multiples Connectés

Lorsque l'instruction MATCH contient deux ou plusieurs motifs de chemin connectés par les variables d'éléments communs, le résultat final est produit en effectuant l'équi-jointure sur les variables communes des ensembles de résultats des différents motifs de chemin.

Cette requête récupère les nœuds étiquetés Club, qui sont connectés avec des nœuds qui ont des relations avec à la fois rowlock et purplechalk :

MATCH ({name: 'rowlock'})-(x)-({name: 'purplechalk'}), (x)-[]-(y:Club)
RETURN y

Résultat : y

Correspondance de Chemins Multiples Déconnectés

Lorsque l'instruction MATCH contient deux ou plusieurs motifs de chemin déconnectés (c'est-à-dire sans variables d'éléments communs), le résultat final est produit en effectuant le produit cartésien des ensembles de résultats des différents motifs de chemin.

Cette requête récupère les nœuds étiquetés Club, et les nœuds étiquetés User qui suivent d'autres après 2024-2-1 :

MATCH (c:Club), (u:User)-[f:Follows WHERE f.createdOn > '2024-2-1']->()
RETURN c._id, u.name

Résultat :

OPTIONAL MATCH

Conservation des Enregistrements pour Toutes les Sous-requêtes

Dans les deux requêtes ci-dessous, la variable u est d'abord liée à trois nœuds (mochaeach, rowlock, et purplechalk) connectés à Brainy dans une instruction MATCH. Cette variable u est ensuite référencée dans la deuxième instruction MATCH, ce qui conduit à des sous-requêtes. Dans chaque sous-requête, un nœud de u est utilisé pour faciliter la correspondance du motif de chemin. Si un nœud ne donne pas lieu à une correspondance, il sera exclu des parties ultérieures de la requête à moins que OPTIONAL MATCH ne soit utilisé, ce qui retourne une valeur null à la place.

MATCH (:User {name: "Brainy"})-[]-(u:User)
MATCH (u)-[:Joins]-(c:Club)
RETURN u.name, c._id

Résultat :

MATCH (:User {name: "Brainy"})-[:Follows]-(u:User)
OPTIONAL MATCH (u)-[:Joins]-(c:Club)
RETURN u.name, c._id

Résultat :

Maintien du Fonctionnement de la Requête

Dans le cas où une instruction produit un résultat vide, la requête s'arrête effectivement à ce point, car il n'y a pas de données sur lesquelles les instructions ultérieures peuvent opérer.

Dans cette requête, la deuxième instruction MATCH échoue à trouver une correspondance pour purplechalk rejoignant un club, entraînant une table de travail vide. Par conséquent, la requête se termine et l'instruction MATCH suivante, qui aurait pu récupérer des données, n'est pas exécutée.

MATCH (n:User {name: "purplechalk"})
MATCH (n)-[:Joins]-(c:Club)
MATCH (m:User {name: "lionbower"})
RETURN n.name, c._id, m.name

Résultat : Pas de Données Retournées

Pour empêcher la requête de se terminer prématurément, vous pouvez utiliser OPTIONAL MATCH car cela permet à la valeur null d'être transmise à l'instruction suivante.

MATCH (n:User {name: "purplechalk"})
OPTIONAL MATCH (n)-[:Joins]-(c:Club)
MATCH (m:User {name: "lionbower"})
RETURN n.name, c._id, m.name

Résultat :

Vérification de l'Existence des Arêtes

Cette requête retourne les utilisateurs qui n'ont pas de followers :

MATCH (n:User)
OPTIONAL MATCH p = (n)<-[:Follows]-() WHERE p IS NULL
RETURN COLLECT_LIST(n.name) AS Names

Résultat :

Graph Pattern YIELD Clause

La clause YIELD du motif de graphe peut être utilisée de manière optionnelle pour sélectionner des variables à exposer dans les parties ultérieures de la requête.

MATCH (n:User)-[:Joins]->(c:Club)
YIELD c
RETURN *

Résultat : n