Ce document présente le langage de requête de graphe avec Spanner Graph, y compris sa syntaxe pour la correspondance de motifs de graphe. Il vous explique également comment exécuter des requêtes sur votre graphe. Avec Spanner Graph, vous pouvez exécuter des requêtes pour trouver des modèles, parcourir des relations et obtenir des insights à partir de vos données de graphe de propriétés.
Les exemples de ce document utilisent le schéma de graphique que vous créez dans Configurer et interroger Spanner Graph. Ce schéma est illustré dans le diagramme suivant :
Exécuter une requête Spanner Graph
Vous pouvez utiliser la console Google Cloud , Google Cloud CLI, les bibliothèques clientes, l'API REST ou l'API RPC pour exécuter une requête Spanner Graph.
Console Google Cloud
Les étapes suivantes vous expliquent comment exécuter une requête dans la consoleGoogle Cloud . Ces étapes supposent que vous disposez d'une instance nommée test-instance contenant une base de données nommée example-db. Pour savoir comment créer une instance avec une base de données, consultez Configurer et interroger Spanner Graph.
Dans la console Google Cloud , accédez à la page Instances Spanner.
Cliquez sur l'instance nommée
test-instance.Sous Bases de données, cliquez sur la base de données nommée
example-db.Ouvrez Spanner Studio, puis cliquez sur Nouvel onglet ou utilisez l'onglet de l'éditeur.
Saisissez une requête dans l'éditeur de requête.
Cliquez sur Exécuter.
CLI gcloud
Pour envoyer des requêtes à l'aide de l'outil de ligne de commande gcloud CLI, procédez comme suit :
Si ce n'est pas déjà fait, installez la gcloud CLI.
Dans gcloud CLI, exécutez la commande suivante :
Pour en savoir plus, consultez le guide de démarrage rapide de la CLI Spanner.
API REST
Pour envoyer des requêtes à l'aide de l'API REST, utilisez l'une des commandes suivantes :
Pour en savoir plus, consultez Interroger des données à l'aide de l'API REST et Premiers pas avec Spanner à l'aide de REST.
API RPC
Pour envoyer des requêtes à l'aide de l'API RPC, utilisez l'une des commandes suivantes :
Bibliothèques clientes
Pour savoir comment exécuter une requête avec une bibliothèque cliente Spanner, consultez les ressources suivantes :
- Exécuter une requête à l'aide de la bibliothèque cliente Spanner C++
- Effectuer des requêtes à l'aide de la bibliothèque cliente Spanner C#
- Exécuter une requête à l'aide de la bibliothèque cliente Spanner Go
- Interroger à l'aide de la bibliothèque cliente Spanner Java
- Effectuer des requêtes à l'aide de la bibliothèque cliente Spanner Node.js
- Interroger à l'aide de la bibliothèque cliente Spanner PHP
- Exécuter une requête à l'aide de la bibliothèque cliente Spanner pour Python
- Exécuter une requête à l'aide de la bibliothèque cliente Spanner Ruby
Pour en savoir plus sur les bibliothèques clientes Spanner, consultez la présentation des bibliothèques clientes Spanner.
Visualiser les résultats des requêtes Spanner Graph
Vous pouvez afficher une représentation visuelle des résultats de vos requêtes Spanner Graph dans Spanner Studio, dans la console Google Cloud . Une visualisation de requête vous permet de voir comment les éléments renvoyés (nœuds et arêtes) sont connectés. Cela peut révéler des tendances, des dépendances et des anomalies difficiles à identifier lorsque vous consultez les résultats dans un tableau. Pour afficher une visualisation d'une requête, celle-ci doit renvoyer des nœuds complets au format JSON. Sinon, vous ne pouvez voir les résultats de la requête que sous forme de tableau. Pour en savoir plus, consultez Utiliser les visualisations de requêtes Spanner Graph.
Structure des requêtes Spanner Graph
Une requête Spanner Graph se compose de plusieurs éléments, tels que le nom du graphique de propriétés, les modèles de nœuds et d'arêtes, et les quantificateurs. Vous utilisez ces composants pour créer une requête qui trouve des modèles spécifiques dans votre graphique. Chaque composant est décrit dans la section Correspondance des modèles de graphiques de ce document.
La requête de la figure 2 illustre la structure de base d'une requête Spanner Graph. La requête commence par spécifier le graphique cible, FinGraph, à l'aide de la clause GRAPH. La clause MATCH définit ensuite le modèle à rechercher. Dans ce cas, il s'agit d'un nœud Person connecté à un nœud Account via un bord Owns. La clause RETURN spécifie les propriétés des nœuds correspondants à renvoyer.
Correspondance de modèles de graphiques
La mise en correspondance des modèles de graphiques permet de trouver des modèles spécifiques dans votre graphique. Les modèles les plus élémentaires 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 modèle 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 graphique, une expression de libellé et des filtres de propriété.
Rechercher tous les nœuds
La requête suivante renvoie tous les nœuds du graphique. 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 graphique.
GRAPH FinGraph
MATCH (n)
RETURN LABELS(n) AS label, n.id;
Cette requête renvoie label et id :
| étiquette | id |
|---|---|
| Compte | 7 |
| Compte | 16 |
| Compte | 20 |
| Personne | 1 |
| Personne | 2 |
| Personne | 3 |
Rechercher tous les nœuds portant un libellé spécifique
La requête suivante correspond à tous les nœuds du graphique qui comportent le libellé Person.
La requête renvoie les propriétés label, id et name des nœuds correspondants.
GRAPH 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 :
| étiquette | id | nom |
|---|---|---|
| Personne | 1 | Alex |
| Personne | 2 | Dana |
| Personne | 3 | Lee |
Trouver tous les nœuds correspondant à une expression de libellé
Vous pouvez créer une expression de libellé avec un ou plusieurs opérateurs logiques. Par exemple, la requête suivante correspond à tous les nœuds du graphique qui comportent le libellé Person ou Account. La variable de modèle de graphique n expose toutes les propriétés des nœuds portant le libellé Person ou Account.
GRAPH FinGraph
MATCH (n:Person|Account)
RETURN LABELS(n) AS label, n.id, n.birthday, n.create_time;
Dans les résultats suivants de cette requête :
- Tous les nœuds ont la propriété
id. - Les nœuds correspondant au libellé
Accountpossèdent la propriétécreate_time, mais pas la propriétébirthday. La propriétébirthdayestNULLpour ces nœuds. - Les nœuds correspondant au libellé
Personpossèdent la propriétébirthday, mais pas la propriétécreate_time. La propriétécreate_timeestNULLpour ces nœuds.
| étiquette | id | birthday | create_time |
|---|---|---|---|
| Compte | 7 | NULL | 2020-01-10T14:22:20.222Z |
| Compte | 16 | NULL | 2020-01-28T01:55:09.206Z |
| Compte | 20 | NULL | 2020-02-18T13:44:20.655Z |
| Personne | 1 | 1991-12-21T08:00:00Z | NULL |
| Personne | 2 | 1980-10-31T08:00:00Z | NULL |
| Personne | 3 | 1986-12-07T08:00:00Z | NULL |
Rechercher tous les nœuds correspondant à l'expression de libellé et au filtre de propriété
Cette requête correspond à tous les nœuds du graphique qui comportent le libellé Person et où la propriété id est égale à 1.
GRAPH FinGraph
MATCH (p:Person {id: 1})
RETURN LABELS(p) AS label, p.id, p.name, p.birthday;
Voici les résultats de la requête :
| étiquette | id | nom | birthday |
|---|---|---|---|
| Personne | 1 | Alex | 1991-12-21T08:00:00Z |
Vous pouvez utiliser la clause WHERE pour créer des conditions de filtrage plus complexes sur les libellés et les propriétés.
La requête suivante utilise la clause WHERE pour former une condition de filtrage plus complexe sur les propriétés. Il correspond à tous les nœuds du graphique qui ont le libellé Person et dont la propriété birthday est antérieure à 1990-01-10.
GRAPH FinGraph
MATCH (p:Person WHERE p.birthday < '1990-01-10')
RETURN LABELS(p) AS label, p.name, p.birthday;
Voici les résultats de la requête :
| étiquette | nom | birthday |
|---|---|---|
| Personne | Dana | 1980-10-31T08:00:00Z |
| Personne | 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 motifs de bordure sont placés entre 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.
Trouver tous les nœuds avec des libellés correspondants
Cette requête renvoie tous les nœuds du graphique portant le libellé Transfers. La requête lie la variable de motif de graphique e aux arêtes correspondantes.
GRAPH FinGraph
MATCH -[e:Transfers]->
RETURN e.Id as src_account, e.order_number
Voici les résultats de la requête :
| src_account | order_number |
|---|---|
| 7 | 304330008004315 |
| 7 | 304120005529714 |
| 16 | 103650009791820 |
| 20 | 304120005529714 |
| 20 | 302290001255747 |
Rechercher tous les nœuds correspondant à l'expression de libellé et au filtre de propriété
Le modèle d'arête de cette requête utilise une expression de libellé et un filtre de propriété pour trouver toutes les arêtes libellées avec Transfers qui correspondent à un order_number spécifié.
GRAPH FinGraph
MATCH -[e:Transfers {order_number: "304120005529714"}]->
RETURN e.Id AS src_account, e.order_number
Voici les résultats de la requête :
| src_account | order_number |
|---|---|
| 7 | 304120005529714 |
| 20 | 304120005529714 |
Trouver toutes les arêtes à l'aide d'un motif 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 FinGraph
MATCH (account:Account)-[transfer:Transfers]-(:Account {is_blocked:true})
RETURN transfer.order_number, transfer.amount;
Voici les résultats de la requête :
| order_number | amount |
|---|---|
| 304330008004315 | 300 |
| 304120005529714 | 100 |
| 103650009791820 | 300 |
| 302290001255747 | 200 |
Formats de chemin
Un modèle de chemin est créé à partir de modèles de nœuds et d'arêtes alternés.
Trouver tous les chemins à partir d'un nœud spécifique à l'aide d'un modèle de chemin
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 de Person {id: 2} à travers un Account connecté à l'aide de l'arête Owns, dans un autre Account à l'aide de l'arête Transfers.
GRAPH 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;
Voici les résultats de la requête :
| sender_id | from_id | to_id |
|---|---|---|
| 2 | 20 | 7 |
| 2 | 20 | 16 |
Formats de chemin quantifiés
Un modèle quantifié répète un modèle dans une plage spécifiée.
Faire correspondre un motif de bord quantifié
Pour trouver des chemins de longueur variable, vous pouvez appliquer un quantificateur à un modèle d'arête. La requête suivante illustre ce point en recherchant les comptes de destination qui se trouvent à un à trois transferts d'un Account source avec un 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 est utilisée pour accéder à e group variable. Pour en savoir plus, consultez Variable de groupe d'accès.
GRAPH 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;
Voici les résultats de la requête :
| src_account_id | path_length | dst_account_id |
|---|---|---|
| 7 | 1 | 16 |
| 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.
Faire correspondre un format de chemin quantifié
La requête suivante recherche les chemins entre les nœuds Account avec un ou 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 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;
Voici les résultats de la requête :
| 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 consultée en dehors de ce modèle. Il se lie ensuite à 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 :
- Variable de modèle de graphique liée à un seul bord dans la clause
WHEREe.amount > 100lorsqu'elle se trouve dans le modèle quantifié. - Variable de groupe liée à un tableau d'éléments d'arête dans
ARRAY_LENGTH(e)dans l'instructionRETURNlorsqu'elle se trouve en dehors du modèle quantifié. - Variable de groupe liée à un tableau d'éléments de bord, agrégée par
SUM(e.amount)en dehors du modèle quantifié. Il s'agit d'un exemple d'agrégation horizontale.
GRAPH 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;
Voici les résultats de la requête :
| src_account_id | path_length | total_amount | dst_account_id |
|---|---|---|---|
| 7 | 1 | 300 | 16 |
| 7 | 2 | 600 | 20 |
Préfixes de recherche de chemin
Pour limiter les chemins correspondants dans les groupes qui partagent des nœuds source et de destination, vous pouvez utiliser le préfixe de recherche de chemin d'accès ANY ou ANY SHORTEST.
Vous ne pouvez appliquer ces préfixes qu'avant un modèle de chemin d'accès entier, et non à l'intérieur de parenthèses.
Correspondance avec ANY
La requête suivante recherche tous les comptes uniques accessibles qui se trouvent à une ou deux Transfers d'un nœud Account donné.
Le préfixe de recherche de chemin d'accès ANY garantit que la requête ne renvoie qu'un seul chemin d'accès 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 source Account, la requête ne renvoie qu'un seul chemin d'accès.
GRAPH 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;
Voici les résultats de la requête :
| src_account_id | dst_account_id | ids_in_path |
|---|---|---|
| 7 | 16 | 7,16 |
| 7 | 20 | 7,16,20 |
Modèles de graphiques
Un modèle de graphique se compose d'un ou plusieurs modèles de chemin d'accès, séparés par une virgule (,). Les modèles de graphique peuvent contenir une clause WHERE, qui vous permet d'accéder à toutes les variables de modèle de graphique dans les modèles de chemin d'accès pour former des conditions de filtrage. Chaque modèle de chemin d'accès produit une collection de chemins d'accès.
Faire correspondre à l'aide d'un modèle de graphique
La requête suivante identifie les comptes intermédiaires et leurs propriétaires impliqués dans des transactions dont le montant dépasse 200 €, par le biais desquels des fonds sont transférés d'un compte source vers un compte bloqué.
Les formats de chemin suivants forment le format de graphique :
- Le premier modèle recherche les chemins où le transfert a lieu d'un compte vers un compte bloqué à l'aide d'un compte intermédiaire.
- Le deuxième modèle trouve les chemins d'un compte à son 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'équi-jointure basée sur la variable interm.
GRAPH 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;
Voici les résultats de la requête :
| 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 graphique 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 permet de trouver le compte et son propriétaire ayant effectué le plus grand transfert sortant vers un compte bloqué.
GRAPH 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})
|
|
||||||||||||
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
|
|
Voici les résultats de la requête :
| account_id | owner_name |
|---|---|
7 |
Alex |
Instruction return
L'instruction RETURN spécifie ce qui doit être renvoyé à partir des modèles correspondants. Elle peut accéder aux variables de modèle de graphique et inclure des expressions et d'autres clauses, telles que ORDER BY et GROUP BY.
Spanner Graph ne permet pas de renvoyer des éléments de graphe en tant que résultats de requête. Pour renvoyer l'intégralité de l'élément de graphique, utilisez la fonction TO_JSON ou la fonction SAFE_TO_JSON.
Parmi ces deux fonctions, nous vous recommandons d'utiliser SAFE_TO_JSON.
Renvoyer des éléments de graphique au format JSON
GRAPH 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;
GRAPH FinGraph
MATCH (n:Account {id: 7})
-- Certain fields in the graph elements, such as TOKENLIST, can't be returned
-- in the TO_JSON function. In those cases, use the SAFE_TO_JSON function instead.
RETURN SAFE_TO_JSON(n) AS n;
Voici les résultats de la requête :
| 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 longues avec le mot clé NEXT
Vous pouvez enchaîner plusieurs instructions de requête linéaire de graphique à 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 permet de trouver le propriétaire du compte ayant reçu le plus de transferts entrants en enchaînant plusieurs instructions linéaires de graphique. 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 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;
Voici les résultats de la requête :
| account_id | owner_name | num_incoming_transfers |
|---|---|---|
16 |
Lee |
3 |
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 Spanner Graph. Spanner Graph est également compatible avec les fonctions et opérateurs spécifiques aux graphiques.
Fonctions et opérateurs intégrés
Les fonctions et les opérateurs suivants sont utilisés dans GQL :
PROPERTY_EXISTS(n, birthday): renvoie sinpossède la propriétébirthday.LABELS(n): renvoie les libellés dentels qu'ils sont définis dans le schéma du graphique.PROPERTY_NAMES(n): renvoie les noms de propriétés den.TO_JSON(n): renvoienau format JSON. Pour en savoir plus, consultez la section concernant la fonctionTO_JSON.
le prédicat PROPERTY_EXISTS, la fonction LABELS et la fonction TO_JSON, ainsi que d'autres fonctions intégrées telles que ARRAY_AGG et CONCAT.
GRAPH FinGraph
MATCH (person:Person)-[:Owns]->(account:Account)
RETURN person, ARRAY_AGG(account.nick_name) AS accounts
GROUP BY person
NEXT
RETURN
LABELS(person) AS labels,
TO_JSON(person) AS person,
accounts,
CONCAT(person.city, ", ", person.country) AS location,
PROPERTY_EXISTS(person, is_blocked) AS is_blocked_property_exists,
PROPERTY_EXISTS(person, name) AS name_property_exists
LIMIT 1;
Voici les résultats de la requête :
| is_blocked_property_exists | name_property_exists | labels | comptes | emplacement | Personne |
|---|---|---|---|---|---|
false |
true |
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. Vous trouverez ci-dessous les règles relatives aux sous-requêtes Spanner Graph :
- Une sous-requête est placée entre accolades
{}. - Une sous-requête peut commencer par la clause
GRAPHen tête pour spécifier le graphique dans le champ d'application. Le graphique spécifié ne doit pas nécessairement être identique à celui utilisé dans la requête externe. - Lorsque la clause
GRAPHest omise dans la sous-requête, les éléments suivants se produisent :- Le graphique concerné est déduit du contexte de la requête externe la plus proche.
- La sous-requête doit commencer par une instruction de correspondance de modèle de graphique avec
MATCH.
- 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 à l'intérieur de la sous-requête, mais elle peut être référencée dans des expressions ou des fonctions à l'intérieur de la sous-requête.
Utiliser une sous-requête pour trouver le nombre total de transferts de chaque compte
La requête suivante illustre l'utilisation de la sous-requête VALUE. La sous-requête est placée entre accolades {} et précédée du mot clé VALUE. La requête renvoie le nombre total de transferts initiés à partir d'un compte.
GRAPH FinGraph
MATCH (p:Person)-[:Owns]->(account:Account)
RETURN p.name, account.id AS account_id, VALUE {
MATCH (a:Account)-[transfer:Transfers]->(:Account)
WHERE a = account
RETURN COUNT(transfer) AS num_transfers
} AS num_transfers;
Voici les résultats de la requête :
| nom | account_id | num_transfers |
|---|---|---|
Alex |
7 |
2 |
Dana |
20 |
2 |
Lee |
16 |
1 |
Pour obtenir la liste des expressions de sous-requête acceptées, consultez Sous-requêtes Spanner Graph.
Utiliser une sous-requête pour trouver les comptes appartenant à chaque personne
La requête suivante utilise l'instruction CALL avec une sous-requête intégrée. L'instruction MATCH
(p:Person) crée une table avec une seule colonne nommée p.
Chaque ligne de ce tableau contient un nœud Person. L'instruction CALL (p) exécute la sous-requête incluse pour chaque ligne de cette table de travail. La sous-requête recherche les comptes appartenant à chaque personne correspondante p. Les comptes multiples d'une même personne sont classés par ID de compte.
L'exemple déclare la variable de nœud de portée externe p à partir de la clause MATCH
(p:Person). L'instruction CALL (p) fait référence à cette variable. Cette déclaration vous permet de redéclarer ou de déclarer plusieurs fois la variable de nœud dans un modèle de chemin d'accès de la sous-requête. Cela garantit que les variables de nœud p interne et externe sont liées au même nœud Person dans le graphique. Si l'instruction CALL ne déclare pas la variable de nœud p, la sous-requête traite la variable redéclarée p comme une nouvelle variable. Cette nouvelle variable est indépendante de la variable de portée externe, et la sous-requête ne la déclare pas plusieurs fois, car elle renvoie des résultats différents. Pour en savoir plus, consultez la section sur l'instruction CALL.
GRAPH FinGraph
MATCH (p:Person)
CALL (p) {
MATCH (p)-[:Owns]->(a:Account)
RETURN a.Id AS account_Id
ORDER BY account_Id
}
RETURN p.name AS person_name, account_Id
ORDER BY person_name, account_Id;
Résultat
| person_name | account_Id |
|---|---|
| Alex | 7 |
| Dana | 20 |
| Lee | 16 |
Paramètres de requête
Vous pouvez interroger Spanner Graph avec des paramètres. Pour en savoir plus, consultez la syntaxe et découvrez comment interroger des données avec des paramètres dans les bibliothèques clientes Spanner.
La requête suivante illustre l'utilisation des paramètres de requête.
GRAPH FinGraph
MATCH (person:Person {id: @id})
RETURN person.name;
Interroger des graphiques et des tableaux ensemble
Vous pouvez utiliser des requêtes de graphe en association avec SQL pour accéder aux informations de vos graphes et tables dans une seule instruction.
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 graphiques avec du contenu non graphique et inversement.
Par exemple, vous pouvez créer une table CreditReports et insérer quelques rapports de crédit, comme indiqué dans l'exemple suivant :
CREATE TABLE CreditReports (
person_id INT64 NOT NULL,
create_time TIMESTAMP NOT NULL,
score INT64 NOT NULL,
) PRIMARY KEY (person_id, create_time);
INSERT INTO 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);
Vous pouvez ensuite identifier des personnes spécifiques grâce à la mise en correspondance des modèles de graphiques dans GRAPH_TABLE et joindre les résultats de la requête de graphique à la table CreditReports pour récupérer les scores de crédit.
SELECT
gt.person.id,
credit.score AS latest_credit_score
FROM GRAPH_TABLE(
FinGraph
MATCH (person:Person)-[:Owns]->(:Account)-[:Transfers]->(account:Account {is_blocked:true})
RETURN DISTINCT person
) AS gt
JOIN CreditReports AS credit
ON gt.person.id = credit.person_id
ORDER BY credit.create_time;
Voici les résultats de la requête :
| person_id | latest_credit_score |
|---|---|
1 |
700 |
2 |
800 |
Étapes suivantes
Découvrez les bonnes pratiques pour ajuster les requêtes.