Présentation des requêtes de graphe

BigQuery Graph vous permet d'écrire des requêtes de graphe pour mettre en correspondance des modèles de nœuds, d'arêtes et de chemins, et parcourir les relations à l'aide du langage GQL (Graph Query Language). Les exemples de ce document font référence à un graphique appelé FinGraph, qui montre les relations entre les personnes, les comptes qu'elles possèdent et les transferts entre comptes. Pour en savoir plus sur la définition du graphique, consultez l'exemple FinGraph.

Structure d'une requête

Une requête de graphique se compose du nom du graphique, suivi d'une ou de plusieurs instructions de requête linéaire. Chaque requête linéaire contient une ou plusieurs instructions, qui vous permettent d'utiliser les données du graphe pour trouver des correspondances de motifs, définir des variables, filtrer et transformer les données intermédiaires, et renvoyer des résultats. Vous exécutez une requête de graphe de la même manière que vous exécutez une requête SQL dans BigQuery.

Exemple de structure de requête de graphe.
Exemple de structure d'une requête de graphique.

Correspondance de modèles de graphes

La mise en correspondance de modèles de graphes recherche des modèles spécifiques dans votre graphe. Les modèles les plus basiques sont les modèles d'éléments, tels que les modèles de nœuds qui correspondent aux nœuds et les modèles d'arêtes qui correspondent aux arêtes.

Modèles de nœuds

Un motif de nœud correspond aux nœuds de votre graphique. Ce modèle contient des parenthèses correspondantes, qui peuvent éventuellement inclure une variable de modèle de graphe, une expression d'étiquette et des filtres de propriété.

Rechercher tous les nœuds

La requête suivante renvoie tous les nœuds du graphe. La variable n, une variable de modèle de graphique, est liée aux nœuds correspondants. Dans ce cas, le modèle de nœud correspond à tous les nœuds du graphe.

GRAPH graph_db.FinGraph
MATCH (n)
RETURN LABELS(n) AS label, n.id;

Cette requête renvoie label et id :

label id
Account 7
Account 16
Account 20
Person 1
Person 2
Person 3

Rechercher tous les nœuds associés à un libellé spécifique

La requête suivante correspond à tous les nœuds du graphe qui ont l'étiquette Person. La requête renvoie l'étiquette et certaines propriétés des nœuds correspondants.

GRAPH graph_db.FinGraph
MATCH (p:Person)
RETURN LABELS(p) AS label, p.id, p.name;

Cette requête renvoie les propriétés suivantes des nœuds correspondants :

label id name
Person 1 Alex
Person 2 Dana
Person 3 Lee

Rechercher tous les nœuds correspondant à une expression d'étiquette

Vous pouvez créer une expression d'étiquette avec un ou plusieurs opérateurs logiques. Par exemple, la requête suivante correspond à tous les nœuds du graphe qui portent l'étiquette Person ou Account. La variable de modèle de graphe n expose toutes les propriétés des nœuds portant l'étiquette Person ou Account.

GRAPH graph_db.FinGraph
MATCH (n:Person|Account)
RETURN LABELS(n) AS label, n.id, n.birthday, n.create_time;

Notez les points suivants dans les résultats de cette requête :

  • Tous les nœuds ont la propriété id.
  • Les nœuds correspondant au libellé Account possèdent la propriété create_time, mais pas la propriété birthday. La propriété birthday est NULL pour ces nœuds.
  • Les nœuds correspondant au libellé Person possèdent la propriété birthday, mais pas la propriété create_time. La propriété create_time est NULL pour ces nœuds.
label id birthday create_time
Account 7 NULL 2020-01-10T14:22:20.222Z
Account 16 NULL 2020-01-28T01:55:09.206Z
Account 20 NULL 2020-02-18T13:44:20.655Z
Person 1 1991-12-21T08:00:00Z NULL
Person 2 1980-10-31T08:00:00Z NULL
Person 3 1986-12-07T08:00:00Z NULL

Rechercher tous les nœuds correspondant à l'expression d'étiquette et au filtre de propriété

La requête suivante correspond à tous les nœuds du graphe qui ont l'étiquette Person et la propriété id égale à 1 :

GRAPH graph_db.FinGraph
MATCH (p:Person {id: 1})
RETURN LABELS(p) AS label, p.id, p.name, p.birthday;

Le résultat ressemble à ce qui suit :

label id name birthday
Person 1 Alex 1991-12-21T08:00:00Z

Vous pouvez utiliser la clause WHERE pour former des conditions de filtrage plus complexes sur les étiquettes et les propriétés.

La requête suivante utilise la clause WHERE pour filtrer les nœuds dont la propriété birthday est antérieure à 1990-01-10 :

GRAPH graph_db.FinGraph
MATCH (p:Person WHERE p.birthday < '1990-01-10')
RETURN LABELS(p) AS label, p.name, p.birthday;

Le résultat ressemble à ce qui suit :

label name birthday
Person Dana 1980-10-31T08:00:00Z
Person Lee 1986-12-07T08:00:00Z

Modèles Edge

Un motif d'arête correspond aux arêtes ou aux relations entre les nœuds. Les modèles de périphérie sont entourés de crochets ([]) et incluent des symboles tels que -, -> ou <- pour indiquer les directions. Un motif d'arête peut éventuellement inclure une variable de motif de graphique à lier aux arêtes correspondantes.

Rechercher toutes les arêtes avec des étiquettes correspondantes

Cette requête renvoie toutes les arêtes du graphe avec l'étiquette Transfers. La requête lie la variable de motif de graphe e aux arêtes correspondantes.

GRAPH graph_db.FinGraph
MATCH -[e:Transfers]->
RETURN e.Id as src_account, e.order_number;

Le résultat ressemble à ce qui suit :

src_account order_number
7 304330008004315
7 304120005529714
16 103650009791820
20 304120005529714
20 302290001255747

Rechercher toutes les arêtes correspondant à l'expression d'étiquette et au filtre de propriété

Le modèle d'arête de la requête suivante utilise une expression d'étiquette et un filtre de propriété pour rechercher toutes les arêtes étiquetées Transfers qui correspondent à un numéro de commande spécifié :

GRAPH graph_db.FinGraph
MATCH -[e:Transfers {order_number: "304120005529714"}]->
RETURN e.Id AS src_account, e.order_number;

Le résultat ressemble à ce qui suit :

src_account order_number
7 304120005529714
20 304120005529714

Rechercher toutes les arêtes à l'aide d'un modèle d'arête de direction

Vous pouvez utiliser le modèle d'arête any direction (-[]-) dans une requête pour faire correspondre les arêtes dans les deux sens. La requête suivante recherche tous les transferts avec un compte bloqué :

GRAPH graph_db.FinGraph
MATCH (account:Account)-[transfer:Transfers]-(:Account {is_blocked:true})
RETURN transfer.order_number, transfer.amount;

Le résultat ressemble à ce qui suit :

order_number amount
304330008004315 300
304120005529714 100
103650009791820 300
302290001255747 200

Formats de chemin

Un modèle de chemin d'accès est créé à partir de modèles de nœuds et d'arêtes alternés.

Rechercher tous les chemins d'accès à partir d'un nœud spécifique à l'aide d'un modèle de chemin d'accès

La requête suivante recherche tous les transferts vers un compte initiés à partir d'un compte appartenant à Person avec id égal à 2.

Chaque résultat correspondant représente un chemin d'accès à partir d'un nœud Person lorsque id est égal à 2 via un nœud Account connecté à l'aide d'un bord Owns, dans un autre nœud Account à l'aide d'un bord Transfers.

GRAPH graph_db.FinGraph
MATCH
  (p:Person {id: 2})-[:Owns]->(account:Account)-[t:Transfers]->
  (to_account:Account)
RETURN
  p.id AS sender_id, account.id AS from_id, to_account.id AS to_id;

Le résultat ressemble à ce qui suit :

sender_id from_id to_id
2 20 7
2 20 16

Formats de chemin d'accès quantifiés

Un modèle quantifié répète un modèle dans une plage spécifiée.

Assurer la correspondance d'un modèle d'arête quantifié

Pour rechercher des chemins de longueur variable, vous pouvez appliquer un quantificateur à un modèle de périphérie. La requête suivante illustre ce point en recherchant les comptes de destination qui se trouvent à un, deux ou trois transferts d'un Account source avec une valeur id de 7.

La requête applique le quantificateur {1, 3} au modèle d'arête -[e:Transfers]->. Cela indique à la requête de faire correspondre les chemins qui répètent le modèle d'arête Transfers une, deux ou trois fois. La clause WHERE permet d'exclure le compte source des résultats. La fonction ARRAY_LENGTH permet d'accéder à l'e group variable.

GRAPH graph_db.FinGraph
MATCH (src:Account {id: 7})-[e:Transfers]->{1, 3}(dst:Account)
WHERE src != dst
RETURN src.id AS src_account_id, ARRAY_LENGTH(e) AS path_length, dst.id AS dst_account_id;

Le résultat ressemble à ce qui suit :

src_account_id path_length dst_account_id
7 1 16
7 1 16
7 3 16
7 3 16
7 2 20
7 2 20

Certaines lignes des résultats sont répétées. En effet, plusieurs chemins correspondant au modèle peuvent exister entre les mêmes nœuds source et de destination, et la requête les renvoie tous.

Correspondance avec un format de chemin d'accès quantifié

La requête suivante recherche les chemins entre les nœuds Account avec un à deux bords Transfers via des comptes intermédiaires bloqués.

Le format de chemin d'accès entre parenthèses est quantifié, et sa clause WHERE spécifie les conditions du format répété.

GRAPH graph_db.FinGraph
MATCH
  (src:Account)
  ((a:Account)-[:Transfers]->(b:Account {is_blocked:true}) WHERE a != b){1,2}
    -[:Transfers]->(dst:Account)
RETURN src.id AS src_account_id, dst.id AS dst_account_id;

Le résultat ressemble à ce qui suit :

src_account_id dst_account_id
7 20
7 20
20 20

Variables de groupe

Une variable de modèle de graphique déclarée dans un modèle quantifié devient une variable de groupe lorsqu'elle est accessible en dehors de ce modèle. Il est ensuite lié à un tableau d'éléments de graphique correspondants.

Vous pouvez accéder à une variable de groupe en tant que tableau. Ses éléments de graphique sont conservés dans l'ordre de leur apparition le long des chemins correspondants. Vous pouvez agréger une variable de groupe à l'aide de l'agrégation horizontale.

Variable de groupe d'accès

Dans l'exemple suivant, la variable e est accessible comme suit :

  • En tant que variable de modèle de graphique liée à un seul bord dans la clause WHERE e.amount > 100 lorsqu'elle se trouve dans le modèle quantifié.
  • En tant que variable de groupe liée à un tableau d'éléments de périphérie dans ARRAY_LENGTH(e) dans l'instruction RETURN lorsqu'elle se trouve en dehors du modèle quantifié.
  • En tant que variable de groupe liée à un tableau d'éléments de périphérie, qui est agrégé par SUM(e.amount) en dehors du modèle quantifié. Il s'agit d'un exemple d'agrégation horizontale.
GRAPH graph_db.FinGraph
MATCH
  (src:Account {id: 7})-[e:Transfers WHERE e.amount > 100]->{0,2}
  (dst:Account)
WHERE src.id != dst.id
LET total_amount = SUM(e.amount)
RETURN
  src.id AS src_account_id, ARRAY_LENGTH(e) AS path_length,
  total_amount, dst.id AS dst_account_id;

Le résultat ressemble à ce qui suit :

src_account_id path_length total_amount dst_account_id
7 1 300 16
7 2 600 20

Préfixes de recherche de chemin d'accès

Pour limiter les chemins d'accès correspondants au sein de groupes qui partagent des nœuds source et de destination, vous pouvez utiliser le préfixe de recherche de chemin d'accès ANY, ANY SHORTEST ou ANY CHEAPEST. Vous ne pouvez appliquer ces préfixes qu'avant un modèle de chemin d'accès complet, et vous ne pouvez pas les appliquer entre parenthèses.

Correspondance à l'aide de ANY

La requête suivante recherche tous les comptes uniques accessibles qui se trouvent à un ou deux Transfers d'un nœud Account donné.

Le préfixe de recherche de chemin ANY garantit que la requête ne renvoie qu'un seul chemin entre une paire unique de nœuds src et dst Account. Dans l'exemple suivant, bien que vous puissiez atteindre le nœud Account avec {id: 16} dans deux chemins d'accès différents à partir du nœud Account source, la requête ne renvoie qu'un seul chemin d'accès.

GRAPH graph_db.FinGraph
MATCH ANY (src:Account {id: 7})-[e:Transfers]->{1,2}(dst:Account)
LET ids_in_path = ARRAY_CONCAT(ARRAY_AGG(e.Id), [dst.Id])
RETURN src.id AS src_account_id, dst.id AS dst_account_id, ids_in_path;

Le résultat ressemble à ce qui suit :

src_account_id dst_account_id ids_in_path
7 16 7,16
7 20 7,16,20

Correspondance à l'aide de ANY SHORTEST

Le préfixe de recherche de chemin ANY SHORTEST renvoie un seul chemin pour chaque paire de nœuds source et de destination, sélectionné parmi ceux ayant le nombre minimal d'arêtes.

Par exemple, la requête suivante recherche l'un des chemins les plus courts entre un nœud Account avec une valeur id de 7 et un nœud Account avec une valeur id de 20. La requête prend en compte les chemins comportant une à trois arêtes Transfers.

GRAPH graph_db.FinGraph
MATCH ANY SHORTEST (src:Account {id: 7})-[e:Transfers]->{1, 3}(dst:Account {id: 20})
RETURN src.id AS src_account_id, dst.id AS dst_account_id, ARRAY_LENGTH(e) AS path_length;

Le résultat ressemble à ce qui suit :

src_account_id dst_account_id path_length
7 20 2

Mettre en correspondance à l'aide de ANY CHEAPEST

Le préfixe de recherche de chemin ANY CHEAPEST garantit que pour chaque paire de comptes source et de destination, la requête ne renvoie qu'un seul chemin avec le coût de calcul total minimal.

La requête suivante recherche un chemin avec le coût de calcul total minimal entre les nœuds Account. Ce coût est basé sur la somme de la propriété amount des bords Transfers. La recherche prend en compte les chemins comportant un à trois bords Transfers.

GRAPH graph_db.FinGraph
MATCH ANY CHEAPEST (src:Account)-[e:Transfers COST e.amount]->{1,3}(dst:Account)
LET total_cost = sum(e.amount)
RETURN src.id AS src_account_id, dst.id AS dst_account_id, total_cost;

Le résultat ressemble à ce qui suit :

src_account_id dst_account_id total_cost
7 7 900
7 16 100
7 20 400
16 7 800
16 16 500
16 20 300
20 7 500
20 16 200
20 20 500

Modèles de graphes

Un modèle de graphe se compose d'un ou de plusieurs modèles de chemin d'accès, séparés par une virgule (,). Les modèles de graphe peuvent contenir une clause WHERE, qui vous permet d'accéder à toutes les variables de modèle de graphe dans les modèles de chemin d'accès pour former des conditions de filtrage. Chaque modèle de chemin d'accès produit un ensemble de chemins d'accès.

Mettre en correspondance à l'aide d'un modèle de graphe

La requête suivante identifie les comptes intermédiaires et leurs propriétaires impliqués dans des transactions d'un montant supérieur à 200, par lesquelles des fonds sont transférés d'un compte source vers un compte bloqué.

Les modèles de chemin d'accès suivants forment le modèle de graphique :

  • Le premier modèle recherche les chemins où le transfert s'effectue d'un compte vers un compte bloqué à l'aide d'un compte intermédiaire.
  • Le deuxième modèle recherche les chemins d'un compte vers la personne qui en est propriétaire.

La variable interm sert de lien commun entre les deux modèles de chemin d'accès, ce qui nécessite que interm fasse référence au même nœud d'élément dans les deux modèles de chemin d'accès. Cela crée une opération d'équijointure basée sur la variable interm.

GRAPH graph_db.FinGraph
MATCH
  (src:Account)-[t1:Transfers]->(interm:Account)-[t2:Transfers]->(dst:Account),
  (interm)<-[:Owns]-(p:Person)
WHERE dst.is_blocked = TRUE AND t1.amount > 200 AND t2.amount > 200
RETURN
  src.id AS src_account_id, dst.id AS dst_account_id,
  interm.id AS interm_account_id, p.id AS owner_id;

Le résultat ressemble à ce qui suit :

src_account_id dst_account_id interm_account_id owner_id
20 16 7 1

Instructions de requête linéaires

Vous pouvez enchaîner plusieurs instructions de graphe pour former une instruction de requête linéaire. Les instructions sont exécutées dans l'ordre dans lequel elles apparaissent dans la requête.

  • Chaque instruction prend en entrée la sortie de l'instruction précédente. L'entrée est vide pour la première instruction.

  • Le résultat de la dernière instruction est le résultat final.

Par exemple, vous pouvez utiliser des instructions de requête linéaire pour trouver le transfert maximal vers un compte bloqué. La requête suivante recherche le compte et son propriétaire ayant effectué le transfert sortant le plus important vers un compte bloqué.

GRAPH graph_db.FinGraph
MATCH (src_account:Account)-[transfer:Transfers]->(dst_account:Account {is_blocked:true})
ORDER BY transfer.amount DESC
LIMIT 1
MATCH (src_account:Account)<-[owns:Owns]-(owner:Person)
RETURN src_account.id AS account_id, owner.name AS owner_name;

Le tableau suivant illustre ce processus en montrant les résultats intermédiaires transmis entre chaque instruction. Par souci de concision, seules certaines propriétés sont affichées.

Affirmation Résultat intermédiaire (abrégé) 
MATCH
  (src_account:Account)
    -[transfer:Transfers]->
  (dst_account:Account {is_blocked:true})
src_account transfer dst_account
{id: 7} {amount: 300.0} {id: 16, is_blocked: true}
{id: 7} {amount: 100.0} {id: 16, is_blocked: true}
{id: 20} {amount: 200.0} {id: 16, is_blocked: true} 

ORDER BY transfer.amount DESC
src_account transfer dst_account
{id: 7} {amount: 300.0} {id: 16, is_blocked: true}
{id: 20} {amount: 200.0} {id: 16, is_blocked: true}
{id: 7} {amount: 100.0} {id: 16, is_blocked: true} 

LIMIT 1
src_account transfer dst_account
{id: 7} {amount: 300.0} {id: 16, is_blocked: true} 

MATCH
  (src_account:Account)
    <-[owns:Owns]-
  (owner:Person)
src_account transfer dst_account owns Propriétaire
{id: 7} {amount: 300.0} {id: 16, is_blocked: true} {person_id: 1, account_id: 7} {id: 1, name: Alex} 
RETURN
  src_account.id AS account_id,
  owner.name AS owner_name
account_id owner_name
7 Alex

Le résultat ressemble à ce qui suit :

account_id owner_name
7 Alex

Instruction return

L'instruction RETURN spécifie ce qu'il faut renvoyer à partir des modèles correspondants. Elle peut accéder aux variables de modèle de graphe et inclure des expressions et d'autres clauses, telles que ORDER BY et GROUP BY.

BigQuery Graph ne permet pas de renvoyer des éléments de graphique en tant que résultats de requête. Pour renvoyer l'intégralité de l'élément graphique, utilisez la fonction TO_JSON.

Renvoyer les éléments du graphique au format JSON

GRAPH graph_db.FinGraph
MATCH (n:Account {id: 7})
-- Returning a graph element in the final results is NOT allowed. Instead, use
-- the TO_JSON function or explicitly return the graph element's properties.
RETURN TO_JSON(n) AS n;

Le résultat ressemble à ce qui suit :

n
{"identifier":"mUZpbkdyYXBoLkFjY291bnQAeJEO","kind":"node","labels":["Account"],"properties":{"create_time":"2020-01-10T14:22:20.222Z","id":7,"is_blocked":false,"nick_name":"Vacation Fund"}}

Composer des requêtes plus volumineuses avec le mot clé NEXT

Vous pouvez enchaîner plusieurs instructions de requête linéaire de graphe à l'aide du mot clé NEXT. La première instruction reçoit une entrée vide, et la sortie de chaque instruction suivante devient l'entrée de la suivante.

L'exemple suivant recherche le propriétaire du compte ayant le plus de transferts entrants en enchaînant plusieurs instructions linéaires de graphe. Vous pouvez utiliser la même variable, par exemple account, pour faire référence au même élément de graphique dans plusieurs instructions linéaires.

GRAPH graph_db.FinGraph
MATCH (:Account)-[:Transfers]->(account:Account)
RETURN account, COUNT(*) AS num_incoming_transfers
GROUP BY account
ORDER BY num_incoming_transfers DESC
LIMIT 1

NEXT

MATCH (account:Account)<-[:Owns]-(owner:Person)
RETURN account.id AS account_id, owner.name AS owner_name, num_incoming_transfers;

Le résultat ressemble à ce qui suit :

account_id owner_name num_incoming_transfers
16 Lee 3

Vous pouvez également combiner des instructions de requête linéaires avec des opérateurs d'ensemble.

Fonctions et expressions

Vous pouvez utiliser toutes les fonctions GoogleSQL (fonctions d'agrégation et scalaires), les opérateurs et les expressions conditionnelles dans les requêtes de graphe. BigQuery Graph est également compatible avec les fonctions GQL et les opérateurs GQL qui ne peuvent être utilisés que dans les requêtes de graphe.

La requête suivante inclut un mélange de fonctions et d'opérateurs GQL et SQL dans une requête de graphe :

GRAPH graph_db.FinGraph
MATCH (person:Person)-[o:Owns]->(account:Account)
WHERE person IS SOURCE OF o
RETURN person, ARRAY_AGG(account.nick_name) AS accounts
GROUP BY person

NEXT

RETURN
  LABELS(person) AS labels,
  accounts,
  CONCAT(person.city, ", ", person.country) AS location,
  TO_JSON(person) AS person
LIMIT 1;

Le résultat ressemble à ce qui suit :

labels comptes emplacement Personne
Person ["Vacation Fund"] Adelaide, Australia {"identifier":"mUZpbkdyYXBoLlBlcnNvbgB4kQI=","kind":"node","labels":["Person"],"properties":{"birthday":"1991-12-21T08:00:00Z","city":"Adelaide","country":"Australia","id":1,"name":"Alex"}}

Sous-requêtes

Une sous-requête est une requête imbriquée dans une autre requête. Les règles suivantes s'appliquent aux sous-requêtes dans les requêtes de graphe :

  • Une sous-requête est placée entre accolades {}.
  • Une sous-requête commence par une clause GRAPH pour spécifier le graphe concerné. Le graphique spécifié n'a pas besoin d'être identique à celui utilisé dans la requête externe.
  • Une variable de modèle de graphique déclarée en dehors du champ d'application de la sous-requête ne peut pas être déclarée à nouveau dans la sous-requête, mais elle peut être référencée dans des expressions ou des fonctions de la sous-requête.

Utiliser une sous-requête pour trouver le nombre total de transferts depuis chaque compte

La requête suivante illustre l'utilisation de la sous-requête VALUE. La sous-requête est entourée d'accolades {} précédées du mot clé VALUE. La requête renvoie le nombre total de transferts initiés à partir d'un compte.

GRAPH graph_db.FinGraph
MATCH (p:Person)-[:Owns]->(account:Account)
RETURN p.name, account.id AS account_id, VALUE {
  GRAPH graph_db.FinGraph
  MATCH (a:Account)-[transfer:Transfers]->(:Account)
  WHERE a = account
  RETURN COUNT(transfer) AS num_transfers
} AS num_transfers;

Le résultat ressemble à ce qui suit :

nom account_id num_transfers
Alex 7 2
Dana 20 2
Lee 16 1

Pour obtenir la liste des expressions de sous-requête compatibles, consultez Sous-requêtes BigQuery Graph.

Paramètres de requête

Vous pouvez interroger BigQuery Graph avec des paramètres. Pour en savoir plus, consultez la syntaxe et découvrez comment exécuter des requêtes paramétrées.

La requête suivante correspond aux nœuds Person dont la valeur id correspond à un paramètre de requête :

GRAPH graph_db.FinGraph
MATCH (person:Person {id: @id})
RETURN person.name;

Interroger des graphiques et des tables ensemble

Vous pouvez combiner des requêtes de graphe et des requêtes SQL à l'aide de l'opérateur GRAPH_TABLE.

L'opérateur GRAPH_TABLE prend une requête de graphique linéaire et renvoie son résultat sous forme de tableau pouvant être intégré à une requête SQL. Cette interopérabilité vous permet d'enrichir les résultats des requêtes de graphe avec du contenu non graphique, et inversement.

Par exemple, vous pouvez créer une table CreditReports et insérer quelques rapports de solvabilité, comme illustré dans l'exemple suivant :

CREATE TABLE graph_db.CreditReports (
  person_id     INT64 NOT NULL,
  create_time   TIMESTAMP NOT NULL,
  score         INT64 NOT NULL,
  PRIMARY KEY (person_id, create_time) NOT ENFORCED
);

INSERT INTO graph_db.CreditReports (person_id, create_time, score)
VALUES
  (1,"2020-01-10 06:22:20.222", 700),
  (2,"2020-02-10 06:22:20.222", 800),
  (3,"2020-03-10 06:22:20.222", 750);

Ensuite, vous pouvez identifier des personnes spécifiques grâce à la mise en correspondance de modèles de graphes dans GRAPH_TABLE et joindre les résultats de la requête de graphe à la table CreditReports pour récupérer les cotes de crédit.

SELECT
  gt.person.id,
  credit.score AS latest_credit_score
FROM GRAPH_TABLE(
  graph_db.FinGraph
  MATCH (person:Person)-[:Owns]->(:Account)-[:Transfers]->(account:Account {is_blocked:true})
  RETURN DISTINCT person
) AS gt
JOIN graph_db.CreditReports AS credit
  ON gt.person.id = credit.person_id
ORDER BY credit.create_time;

Le résultat ressemble à ce qui suit :

person_id latest_credit_score
1 700
2 800

Étapes suivantes