Cette page explique comment utiliser les chemins de graphique dans Spanner Graph.
Dans les bases de données orientées graphe, le type de données de chemin de graphique représente une séquence de nœuds entrelacés avec des arêtes et montre comment ces nœuds et ces arêtes sont liés. Pour en savoir plus sur le type de données de tracé, consultez la section Type de tracé du graphique.
Avec le langage Spanner Graph (GQL), vous pouvez créer des chemins de graphique et y effectuer des requêtes. Les exemples de ce document utilisent le même schéma Spanner Graph que celui présenté sur la page Configurer et interroger Spanner Graph.
Créer un chemin de graphique
Vous pouvez créer un chemin de graphique en créant une variable de chemin dans un modèle de graphique ou avec la fonction PATH.
Nous vous recommandons de créer un chemin de graphique à l'aide de la variable de chemin. Le format pour créer une variable de chemin d'accès est le suivant:
MATCH p = PATH_PATTERN
Pour en savoir plus, consultez la section Modèle de graphique.
Exemple
Dans l'exemple suivant, la requête identifie des tendances de transferts d'argent entre des comptes au cours de FinGraph.
GRAPH FinGraph
MATCH p = (src:Account {id: 16})-[t1:Transfers]->(mid:Account)-[t2:Transfers]->
(dst:Account {id: 7})
RETURN TO_JSON(p) AS full_path;
Résultat
| full_path |
|---|
| [{"identifier": ..., "properties": {"id": 16, ...}, ...}, {"identifier": ..., "properties": {"amount": 300.0, ...}, ...}, ...] |
Le résultat indique que la requête a trouvé le modèle Account -> Transfers -> Account dans la base de données.
Interroger un chemin de graphique
Vous pouvez utiliser les fonctions spécifiques au chemin suivantes pour interroger un chemin de graphique. Pour en savoir plus sur les requêtes Spanner Graph, consultez la présentation des requêtes.
EDGES
La fonction EDGES renvoie tous les arcs d'un chemin de graphique. Pour en savoir plus sur la sémantique, consultez EDGES.
Exemple
Cette requête trouve un chemin entre deux comptes qui passent par un compte intermédiaire.
Il renvoie la valeur de l'arête Transfers secondaire du chemin, qui peut être comprise entre src et mid ou entre mid et dst.
GRAPH FinGraph
MATCH p = (src:Account {id: 7})-[t1:Transfers]->{1,3}(mid:Account)-[t2:Transfers]->
{1,3}(dst:Account {id: 16})
LET second_edge = EDGES(p)[1]
RETURN DISTINCT src.id AS src, dst.id AS dst, second_edge.amount AS second_edge_amount;
Résultat
| src | dst | second_edge_amount |
|---|---|---|
| 7 | 16 | 300 |
NODES
La fonction NODES renvoie tous les nœuds d'un chemin de graphique. Pour en savoir plus sur la sémantique, consultez NODES.
Exemple
Cette requête trouve le chemin de graphique de deux transferts, puis renvoie une liste JSON représentant le chemin.
GRAPH FinGraph
MATCH p = (src:Account)-[t1:Transfers]->(mid:Account)-[t2:Transfers]->(dst:Account)
RETURN TO_JSON(NODES(p)) AS nodes;
Résultat
| nœuds |
|---|
| [{"identifier": "...", "properties": {"id": 16}, ...}, {"identifier": "...", "properties": {"id": 20, ...}, ...] |
| … |
PATH_FIRST
La fonction PATH_FIRST recherche le premier nœud d'un chemin de graphique. Pour en savoir plus sur la sémantique, consultez PATH_FIRST.
Exemple
Cette requête recherche le premier nœud dans un chemin de graphique de deux transferts. Il renvoie le libellé du nœud Account et le pseudo du compte.
GRAPH FinGraph
MATCH p = -[:Transfers]->{1,3}(dst:Account{id: 7})
RETURN DISTINCT PATH_FIRST(p).id AS can_reach_target;
Résultat
| can_reach_target |
|---|
| 7 |
| 16 |
| 20 |
PATH_LAST
La fonction PATH_LAST trouve le dernier nœud d'un chemin de graphique. Pour en savoir plus sur la sémantique, consultez PATH_LAST.
Exemple
Cette requête recherche le dernier nœud dans un chemin de graphique de deux transferts. Il renvoie le libellé du nœud Account et le pseudo du compte.
GRAPH FinGraph
MATCH p =(start:Account{id: 7})-[:Transfers]->{1,3}
RETURN DISTINCT PATH_LAST(p).id as can_reach_target;
Résultat
| can_reach_target |
|---|
| 7 |
| 16 |
| 20 |
PATH_LENGTH
La fonction PATH_LENGTH détermine le nombre d'arêtes dans un chemin de graphique. Pour en savoir plus sur la sémantique, consultez PATH_LENGTH.
Exemple
Cette requête permet de trouver le nombre d'arêtes dans un chemin de graphique contenant un à trois transferts.
GRAPH FinGraph
MATCH p = (src:Account)-[e:Transfers]->{1,3}(dst:Account)
RETURN PATH_LENGTH(p) AS num_transfers, COUNT(*) AS num_paths;
Résultat
| num_transfers | num_paths |
|---|---|
| 1 | 5 |
| 2 | 7 |
| 3 | 11 |
IS_ACYCLIC
La fonction IS_ACYCLIC vérifie si un chemin de graphique comporte des nœuds en répétition. Elle renvoie TRUE si une répétition est détectée, sinon elle renvoie FALSE. Pour en savoir plus sur la sémantique, consultez IS_ACYCLIC.
Exemple
Cette requête vérifie si ce chemin de graphique comporte des nœuds en répétition.
GRAPH FinGraph
MATCH p = (src:Account)-[t1:Transfers]->(mid:Account)-[t2:Transfers]->(dst:Account)
RETURN IS_ACYCLIC(p) AS is_acyclic_path, src.id AS source_account_id,
mid.id AS mid_account_id, dst.id AS dst_account_id;
Résultat
| is_acyclic_path | source_account_id | mid_account_id | dst_account_id |
|---|---|---|---|
| TRUE | 16 | 20 | 7 |
| TRUE | 20 | 7 | 16 |
| TRUE | 20 | 7 | 16 |
| FALSE | 16 | 20 | 16 |
| TRUE | 7 | 16 | 20 |
| TRUE | 7 | 16 | 20 |
| FALSE | 20 | 16 | 20 |
IS_TRAIL
La fonction IS_TRAIL vérifie si un chemin de graphique comporte des arêtes répétées. Elle renvoie TRUE si une répétition est détectée, sinon elle renvoie FALSE. Pour en savoir plus sur la sémantique, consultez IS_TRAIL.
Exemple
Cette requête vérifie si ce chemin de graphique comporte des arêtes répétées.
GRAPH FinGraph
MATCH p = (src:Account)-[t1:Transfers]->(mid1:Account)-[t2:Transfers]->
(mid2:Account)-[t3:Transfers]->(dst:Account)
WHERE src.id < dst.id
RETURN IS_TRAIL(p) AS is_trail_path, t1.id AS t1_id, t2.id AS t2_id, t3.id AS t3_id;
Résultat
| is_trail_path | t1_id | t2_id | t3_id |
|---|---|---|---|
| FALSE | 16 | 20 | 16 |
| TRUE | 7 | 16 | 20 |
| TRUE | 7 | 16 | 20 |
Modes de chemin
Dans Spanner Graph, le comportement par défaut consiste à renvoyer tous les chemins, y compris ceux avec des nœuds et des arêtes répétés. Vous pouvez utiliser les modes de chemin d'accès suivants pour inclure ou exclure des chemins d'accès comportant des nœuds et des arêtes répétés. Pour en savoir plus sur la sémantique, consultez la documentation sur Pathmode.
WALK
Le mode de chemin WALK renvoie tous les chemins, y compris ceux avec des nœuds et des arêtes répétés. WALK est le mode de chemin par défaut.
Exemple
La requête suivante illustre l'utilisation du mode de chemin WALK sur un modèle de chemin non quantifié. Le premier chemin d'accès dans les résultats utilise le même bord pour t1 et t3.
GRAPH FinGraph
MATCH p = WALK (src:Account)-[t1:Transfers]->(mid1:Account)-[t2:Transfers]->
(mid2:Account)-[t3:Transfers]->(dst:Account)
WHERE src.id < dst.id
RETURN t1.id AS transfer1_id, t2.id AS transfer2_id, t3.id AS transfer3_id;
Résultat
| transfer1_id | transfer2_id | transfer3_id |
|---|---|---|
| 16 | 20 | 16 |
| 7 | 16 | 20 |
| 7 | 16 | 20 |
ACYCLIC
Le mode de chemin ACYCLIC filtre les chemins comportant des nœuds en répétition.
Exemple
La requête suivante montre comment utiliser le mode de chemin ACYCLIC sur un modèle de chemin non quantifié.
Le chemin avec des nœuds src et dst égaux est filtré.
GRAPH FinGraph
MATCH p = ACYCLIC (src:Account)-[t1:Transfers]->(mid:Account)-[t2:Transfers]->(dst:Account)
RETURN src.id AS account1_id, mid.id AS account2_id, dst.id AS account3_id;
Résultat
| account1_id | account2_id | account3_id |
|---|---|---|
| 20 | 7 | 16 |
| 20 | 7 | 16 |
| 7 | 16 | 20 |
| 7 | 16 | 20 |
| 16 | 20 | 7 |
TRAIL
Le mode de chemin TRAIL filtre les chemins comportant des arêtes répétées.
Exemple
La requête suivante illustre l'utilisation du mode de chemin TRAIL sur un modèle de chemin non quantifié. Le chemin dont les arêtes t1 et t3 sont égales est filtré.
GRAPH FinGraph
MATCH p = TRAIL (src:Account)-[t1:Transfers]->(mid1:Account)-[t2:Transfers]->
(mid2:Account)-[t3:Transfers]->(dst:Account)
RETURN
t1.id AS transfer1_id, t2.id AS transfer2_id, t3.id AS transfer3_id;
Résultat
| transfer1_id | transfer2_id | transfer3_id |
|---|---|---|
| 16 | 20 | 7 |
| 16 | 20 | 7 |
| 20 | 7 | 16 |
| 20 | 7 | 16 |
| 7 | 16 | 20 |
| 7 | 16 | 20 |
| 7 | 16 | 20 |
| 7 | 16 | 20 |
| 20 | 16 | 20 |
Préfixe de recherche de chemin
Vous pouvez utiliser un préfixe de recherche de chemin pour limiter un modèle de chemin afin de renvoyer le chemin le plus court de chaque partition de données. Pour en savoir plus sur la sémantique, consultez la section Préfixe de recherche de chemin.
ANY SHORTEST
Le préfixe de recherche de chemin ANY SHORTEST renvoie le chemin le plus court (celui avec le moins d'arêtes) qui correspond au format de chaque partition de données. S'il existe plusieurs chemins les plus courts par partition, renvoie l'un d'eux.
Exemple
La requête suivante correspond à n'importe quel chemin entre chaque paire de [a, b].
GRAPH FinGraph
MATCH p = ANY SHORTEST (a:Account)-[t:Transfers]->{1,4}(b:Account)
WHERE a.is_blocked
LET total_amount = SUM(t.amount)
RETURN a.id AS account1_id, total_amount, b.id AS account2_id;
Résultat
| account1_id | total_amount | account2_id |
|---|---|---|
| 16 | 500 | 16 |
| 16 | 800 | 7 |
| 16 | 300 | 20 |
Règles de conversion
Pour en savoir plus, consultez les règles de conversion GRAPH_PATH.
Exemple de cas d'utilisation
Dans l'exemple de cas d'utilisation suivant, vous constatez que tous les comptes ont été acheminés via un à trois comptes, à partir de l'ID de compte 20.
GRAPH FinGraph
MATCH p = (start:Account {id: 20})-[:Transfers]->{1,3}(dst:Account)
RETURN DISTINCT dst.id AS dst;
Résultat
| dst |
|---|
| 7 |
| 16 |
| 20 |
Toutefois, une requête qui renvoie l'ID de compte 20 peut être trop large, car elle commence par l'ID de compte 20. Pour afficher des résultats plus spécifiques, vous pouvez forcer votre requête à n'afficher que des chemins de graphique acycliques sans nœuds répétés.
Pour ce faire, vous pouvez procéder comme suit:
- Utilisez
MATCH p = ACYCLIC <path_pattern>; ou - Appliquer un filtre
IS_ACYCLIC(p)dans votre requête
La requête suivante utilise MATCH p = ACYCLIC PATH_PATTERN:
GRAPH FinGraph
MATCH p = ACYCLIC (start:Account {id: 20})-[:Transfers]->{1,3}(dst:Account)
RETURN DISTINCT dst.id AS dst;
Résultat
| dst |
|---|
| 7 |
| 16 |
Si vous souhaitez connaître le premier compte via lequel l'argent est transféré, vous pouvez exécuter la requête suivante:
GRAPH FinGraph
MATCH p = ACYCLIC (start:Account {id: 20})(-[:Transfers]->
(nexts:Account)){1,3}(dst:Account)
RETURN dst.id AS dst, ARRAY_AGG(DISTINCT nexts[0].id) AS unique_starts;
Cette requête n'est pas conventionnelle, car elle introduit une nouvelle variable dans le chemin quantifié à l'aide de nexts pour obtenir le résultat. Avec les variables de chemin, vous pouvez simplifier la requête:
GRAPH FinGraph
MATCH p = ACYCLIC (start:Account {id: 20})-[:Transfers]->{1,3}(dst:Account)
RETURN dst.id AS dst, ARRAY_AGG(DISTINCT NODES(p)[OFFSET(1)].id) AS unique_starts;
L'utilisation de NODES(p) renvoie tous les nœuds du chemin. Comme le compte de nœud de premier niveau est spécifié comme start, le suivant (au premier décalage) est le premier compte par lequel l'argent est transféré.
Résultat
| dst | unique_starts |
|---|---|
| 7 | 16, 7 |
Les chemins sont plus utiles lorsqu'il existe plusieurs chemins quantifiés. Vous pouvez ajouter une contrainte selon laquelle les chemins trouvés à partir de start doivent passer par l'ID de compte 7:
GRAPH FinGraph
MATCH p = ACYCLIC (start:Account {id: 20})-[:Transfers]->
{1,3}(mid:Account {id: 7})-[:Transfers]->{1,3}(dst:Account)
RETURN dst.id AS dst,
ARRAY_AGG(DISTINCT NODES(p)[OFFSET(1)].id) AS unique_starts;
Bien que l'instruction MATCH ait changé, le reste de la requête n'a pas besoin d'être modifié. Sans utiliser de variables de chemin, il est parfois impossible pour Spanner de savoir de manière statique quel chemin quantifié inspecter.
À l'aide d'une variable de chemin, vous pouvez obtenir la somme de tous les transferts:
GRAPH FinGraph
MATCH p = ACYCLIC (start:Account {id: 20})-[:Transfers]->
{1,3}(mid:Account {id: 7})-[:Transfers]->{1,3}(dst:Account)
LET all_transfers = EDGES(p)
LET transfer_amounts = SUM(all_transfers.amount)
RETURN dst.id AS dst,
ARRAY_AGG(DISTINCT NODES(p)[OFFSET(1)].id) AS participating_neighbor_nodes, transfer_amounts;
Résultat
| dst | participating_neighbor_nodes | transfer_amounts |
|---|---|---|
| 16 | 7 | 600 |
| 16 | 7 | 800 |