Documentation de référence sur Spanner Graph pour les utilisateurs d'openCypher

Ce document compare openCypher et Spanner Graph de la manière suivante :

  • Terminologie
  • Modèle de données
  • Schéma
  • Requête
  • Mutation

Dans ce document, nous partons du principe que vous connaissez openCypher v9.

Avant de commencer

Configurez et interrogez Spanner Graph à l'aide de la console Google Cloud.

Terminologie

openCypher Spanner Graph
nœuds nœuds
relations arêtes
libellés de nœuds libellés de nœuds
types de relations étiquettes de périphérie
clauses Spanner Graph utilise le terme statement pour une unité d'exécution complète et clause pour un modificateur d'instructions.

Par exemple, MATCH est une instruction, tandis que WHERE est une clause.
unicité des relations

openCypher ne renvoie pas de résultats avec des arêtes répétées dans une seule correspondance.		 chemin TRAIL

Lorsque l'unicité est souhaitée dans le graphe Spanner, utiliser TRAIL pour renvoyer des arêtes uniques en une seule correspondance.

Conformité aux normes

Spanner Graph adopte la norme ISO Graph Query Language (Langage de requête graphique) (GQL) et Requêtes de graphiques de propriétés/SQL (SQL/PGQ).

Modèle de données

Spanner Graph et openCypher adoptent le modèle de données de graphique de propriétés avec quelques différences.

openCypher Spanner Graph
Chaque relation a un seul type de relation.
 Les nœuds et les arêtes ont une ou plusieurs étiquettes.

Schéma

openCypher Spanner Graph
Un graphique n'a pas de schéma prédéfini. Un schéma de graphique doit être défini explicitement à l'aide de l'instruction CREATE PROPERTY GRAPH.
Les étiquettes sont définies de manière statique dans le schéma. Pour mettre à jour les étiquettes, vous n'avez pas besoin de mettre à jour le schéma.
Pour en savoir plus, consultez Créer, mettre à jour ou supprimer un schéma de graphique Spanner.

Requête

Les capacités de requête du graphe de Spanner sont semblables à celles d'openCypher. Les différences entre Spanner Graph et openCypher sont décrites dans cette section.

Spécifier le graphique

Dans openCypher, il existe un graphique par défaut, et les requêtes s'exécutent sur le graphique graphique. Dans Spanner Graph, vous pouvez définir plusieurs graphiques et une requête doit commencer par la clause GRAPH pour spécifier le graphique à interroger. Exemple :

   GRAPH FinGraph
   MATCH (p:Person)
   RETURN p.name
   ORDER BY p.name
   LIMIT 1;

Pour en savoir plus, reportez-vous à la syntaxe des requêtes de graphique.

Correspondance de modèles de graphiques

Spanner Graph est compatible avec des fonctionnalités de mise en correspondance de modèles de graphes similaires à celles d'openCypher. Les différences sont expliquées dans les sections suivantes.

Unicité de la relation et mode TRAIL

openCypher ne renvoie pas de résultats avec des arêtes répétées dans une seule correspondance. C'est ce que l'on appelle l'unicité des relations dans openCypher. Dans Spanner Graph, les arêtes répétées sont renvoyées par défaut. Lorsque l'unicité est souhaitée, utilisez TRAIL pour vous assurer qu'aucune arête répétitive n'existe dans la correspondance unique. Pour en savoir plus sur la sémantique détaillée de TRAIL et des autres modes de chemin d'accès, consultez la section Mode de chemin d'accès.

L'exemple suivant montre comment les résultats d'une requête changent avec le mode TRAIL:

  • Les requêtes en mode TRAIL openCypher et Spanner Graph renvoient des résultats vides, car le seul chemin possible consiste à répéter t1 deux fois.
  • Par défaut, la requête de graphique Spanner renvoie un chemin valide.

Exemple de graphique

openCypher Graphique Spanner (mode TRAIL) Graphique Spanner (mode par défaut) 
MATCH
  (src:Account)-[t1:Transfers]->
  (dst:Account)-[t2:Transfers]->
  (src)-[t1]->(dst)
WHERE src.id = 16
RETURN src.id AS src_id, dst.id AS dst_id;
      
GRAPH FinGraph
MATCH TRAIL
  (src:Account)-[t1:Transfers]->
  (dst:Account)-[t2:Transfers]->
  (src)-[t1]->(dst)
WHERE src.id = 16
RETURN src.id AS src_id, dst.id AS dst_id;
      
GRAPH FinGraph
MATCH
  (src:Account)-[t1:Transfers]->
  (dst:Account)-[t2:Transfers]->
  (src)-[t1]-> (dst)
WHERE src.id = 16
RETURN src.id AS src_id, dst.id AS dst_id;
Résultat vide. Résultat vide. Résultat:
src_id dst_id
16 20

Renvoyer des éléments de graphique sous forme de résultats de requête

openCypher Spanner Graph 
MATCH (account:Account)
WHERE account.id = 16;
RETURN account;
 
GRAPH FinGraph
MATCH (account:Account)
WHERE account.id = 16;
RETURN TO_JSON(account) AS account;

Dans Spanner Graph, les résultats de requête ne renvoient pas d'éléments de graphique. Utilisez la fonction TO_JSON pour renvoyer des éléments de graphique au format JSON.

Correspondance de modèle de longueur variable et quantification de modèle

Dans openCypher, la correspondance de modèle de longueur variable s'appelle la quantification du chemin. dans Spanner Graph. La quantification du chemin d'accès utilise une syntaxe différente, comme indiqué ci-dessous. dans l'exemple suivant. Pour en savoir plus, consultez la page Format de chemin d'accès quantifié.

openCypher Spanner Graph 
MATCH (src:Account)-[:Transfers*1..2]->(dst:Account)
WHERE src.id = 16
RETURN dst.id
ORDER BY dst.id;
     
GRAPH FinGraph
MATCH (src:Account)-[:Transfers]->{1,2}(dst:Account)
WHERE src.id = 16
RETURN dst.id
ORDER BY dst.id;

Modèle de longueur variable : liste d'éléments

Spanner Graph vous permet d'accéder directement aux variables utilisées dans les quantifications de chemin. Dans l'exemple suivant, e dans Spanner Graph est identique à edges(p) dans openCypher.

openCypher Spanner Graph 
MATCH p=(src:Account)-[:Transfers*1..3]->(dst:Account)
WHERE src.id = 16
RETURN edges(p);
      
GRAPH FinGraph
MATCH (src:Account) -[e:Transfers]->{1,3} (dst:Account)
WHERE src.id = 16
RETURN TO_JSON(e) AS e;

Chemin le plus court

openCypher dispose de deux fonctions intégrées pour trouver le chemin le plus court entre les nœuds: shortestPath et allShortestPath.

  • shortestPath trouve un seul chemin le plus court entre les nœuds.
  • allShortestPath trouve tous les chemins les plus courts entre les nœuds. Il peut y avoir comporter plusieurs chemins de même longueur.

Spanner Graph utilise une syntaxe différente pour trouver un seul chemin le plus court entre les nœuds : ANY SHORTEST pour shortestPath.. La fonction allShortestPath n'est pas prise en charge dans Spanner Graph.

openCypher Spanner Graph 
MATCH
  (src:Account {id: 7}),
  (dst:Account {id: 20}),
  p = shortestPath((src)-[*1..10]->(dst))
RETURN length(p) AS path_length;
      
GRAPH FinGraph
MATCH ANY SHORTEST
  (src:Account {id: 7})-[e:Transfers]->{1, 3}
  (dst:Account {id: 20})
RETURN ARRAY_LENGTH(e) AS path_length;

Déclarations et clauses

Le tableau suivant liste les clauses openCypher et indique si elles sont compatibles ou non avec Spanner Graph.

openCypher Spanner Graph
MATCH Compatible Pour en savoir plus, consultez la section Correspondance de modèles de graphiques.
OPTIONAL MATCH Compatible Pour en savoir plus, consultez la section Correspondance de modèles de graphiques.
RETURN / WITH Compatible Pour plus d'informations, consultez les l'instruction RETURN et l'instruction WITH. Le graphe Spanner
nécessite un aliasage explicite pour les expressions complexes.

Compatible.		 
GRAPH FinGraph
MATCH (p:Person)
RETURN EXTRACT(YEAR FROM p.birthday) AS birthYear;

Non compatible.		 
GRAPH FinGraph
MATCH (p:Person)
RETURN EXTRACT(YEAR FROM p.birthday); -- No aliasing
WHERE Compatible Pour en savoir plus, consultez la définition de graphique.
ORDER BY Compatible Pour en savoir plus, consultez la section Instruction ORDER BY.
SKIP / LIMIT Compatible Pour plus d'informations, consultez les l'instruction SKIP et l'instruction LIMIT.

Spanner Graph nécessite une expression constante pour le décalage et la limite.

Compatible.		 
GRAPH FinGraph
MATCH (n:Account)
RETURN n.id
SKIP @offsetParameter
LIMIT 3;

Non compatible.		 
GRAPH FinGraph
MATCH (n:Account)
RETURN n.id
LIMIT VALUE {
  MATCH (m:Person)
  RETURN COUNT(*) AS count
} AS count; -- Not a constant expression
UNION Compatible Pour en savoir plus, consultez la page Requête de graphique composite.
UNION ALL Compatible Pour en savoir plus, consultez la section Requête de graphique composite.
UNWIND Compatible avec l'instruction FOR. 
GRAPH FinGraph
LET arr = [1, 2, 3]
FOR num IN arr
RETURN num;
MANDATORY MATCH Non compatible
CALL[YIELD...] Non compatible
CREATE, DELETE, SET, REMOVE, MERGE Pour en savoir plus, consultez la section Mutation et Insérer, mettre à jour ou supprimer des données dans Spanner Graph.

Types de données

Spanner Graph est compatible avec tous les types de données GoogleSQL. Pour plus pour en savoir plus, consultez Types de données dans GoogleSQL

Les sections suivantes comparent les types de données openCypher avec les données Spanner Graph de données.

Type structurel

openCypher Spanner Graph
Nœud Nœud
Edge Edge
Chemin d'accès Non compatible

Type de propriété

openCypher Spanner Graph
INT INT64
FLOAT FLOAT64
STRING STRING
BOOLEAN BOOL
LIST
Liste homogène de types simples.
Par exemple, "Liste de INT", "Liste de STRING".
Vous ne pouvez pas mélanger les valeurs INT et STRING dans une même liste.		 ARRAY

Type composite

openCypher Spanner Graph
LIST ARRAY ou JSON
MAP STRUCT ou JSON

Spanner Graph n'est pas compatible avec les listes hétérogènes de différents types ou des mappages d'une liste de clés dynamiques et de types de valeurs d'éléments hétérogènes. Utilisez le format JSON pour ces cas d'utilisation.

Coercition de type

openCypher Spanner Graph
INT -> FLOAT Compatible

Pour en savoir plus sur les règles de conversion de type, consultez Règles de conversion dans GoogleSQL

Fonctions et expressions

En plus des fonctions et expressions de graphique, Spanner Graph est également compatible avec toutes les fonctions et expressions intégrées de GoogleSQL.

Pour obtenir la liste complète des fonctions et des expressions, consultez Fonctions, opérateurs et conditions GoogleSQL.

Cette section répertorie les fonctions et expressions openCypher, ainsi que leurs dans Spanner Graph.

Fonctions et expressions de type structurel

Type Fonction ou expression openCypher
 Graphique Spanner
fonction ou expression

Nœud et Edge		 exists(n.prop) PROPERTY_EXISTS(n, prop)
id (renvoie un entier) Non compatible
properties TO_JSON
keys
(noms des types de propriété, mais pas des valeurs de propriété)		 PROPERTY_NAMES
labels LABELS
Edge endNode Non compatible
startNode Non compatible
type LABELS
Chemin d'accès length Non compatible
nodes Non compatible.
relationships Non compatible
Nœud et périphérie .
property reference		 .
[]
dynamic property reference
MATCH (n)
RETURN n[n.name]

Non compatible
Modèle en tant qu'expression size(pattern) Non compatible Utilisez une sous-requête comme suit :
VALUE {
  MATCH pattern
  RETURN COUNT(*) AS count;
}

Fonctions et expressions de type de propriété

Type Fonction ou expression openCypher
 Graphique Spanner
fonction ou expression
Scalaire coalesce COALESCE
head ARRAY_FIRST
last ARRAY_LAST
size(list) ARRAY_LENGTH
size(string) LENGTH
timestamp UNIX_MILLIS(CURRENT_TIMESTAMP())
toBoolean/toFloat/toInteger CAST(expr AS type)
Agréger avg AVG
collect ARRAY_AGG
count COUNT
max MAX
min MIN
percentileCont PERCENTILE_CONT
percentileDisc PERCENTILE_DISC
stDev STDDEV
stDevP Non compatible
sum SUM
Liste range GENERATE_ARRAY
reverse ARRAY_REVERSE
tail Spanner Graph n'est pas compatible avec tail.
Utilisez plutôt ARRAY_SLICE et ARRAY_LENGTH.
Mathématiques abs ABS
ceil CEIL
floor FLOOR
rand RAND
round ROUND
sign SIGN
e EXP(1)
exp EXP
log LOG
log10 LOG10
sqrt SQRT
acos ACOS
asin ASIN
atan ATAN
atan2 ATAN2
cos COS
cot COT
degrees r * 90 / ASIN(1)
pi ACOS(-1)
radians d * ASIN(1) / 90
sin SIN
tan TAN
Chaîne left LEFT
ltrim LTRIM
replace REPLACE
reverse REVERSE
right RIGHT
rtrim RTRIM
split SPLIT
substring SUBSTR
tolower LOWER
tostring CAST(expr AS STRING)
toupper UPPER
trim TRIM
DISTINCT DISTINCT DISTINCT
Mathématiques + +
- -
* *
/ /
% MOD
^ POW
Comparaison = =
<> <>
< <
> >
<= <=
>= >=
IS [NOT] NULL IS [NOT] NULL
Chaîne de comparaison
a < b < c

Graphique Spanner n'est pas compatible avec une chaîne de comparaison. Cela équivaut à comparaisons avec AND.
Exemple : 

      a < b AND b < C

Booléen AND AND
OR OR
XOR
 Graphique Spanner n'est pas compatible avec XOR. Écrivez la requête avec <>.

Exemple:
      boolean_1 <> boolean_2

NOT NOT
Chaîne STARTS WITH STARTS_WITH
ENDS WITH ENDS_WITH
CONTAINS REGEXP_CONTAINS
+ CONCAT
Liste + ARRAY_CONCAT
IN ARRAY_INCLUDES
[] []

Autres expressions

openCypher Spanner Graph
Expression de casse Compatible
Existe sous-requête Compatible
Projection cartographique Non compatible
Les types STRUCT offrent des fonctionnalités similaires.
Compréhension des listes Non compatible
GENERATE_ARRAY et ARRAY_TRANSFORM couvrent la majorité des cas d'utilisation.

Paramètre de requête

Les requêtes suivantes montrent la différence entre l'utilisation de paramètres dans openCypher et dans Spanner Graph.

openCypher Spanner Graph
Paramètre 
MATCH (n:Person)
WHERE n.id = $id
RETURN n.name;
 
GRAPH FinGraph
MATCH (n:Person)
WHERE n.id = @id
RETURN n.name;

Mutation

Spanner Graph utilise le LMD GoogleSQL pour modifier les tables de nœud et d'entrée périphérique. Pour en savoir plus, consultez Insérez, mettez à jour ou supprimez des données de graphique Spanner.

Créer un nœud et une arête

openCypher Spanner Graph
Créer des nœuds et des arêtes 
CREATE (:Person {id: 100, name: 'John'});
CREATE (:Account {id: 1000, is_blocked: FALSE});


MATCH (p:Person {id: 100}),
      (a:Account {id: 1000})
CREATE (p)-[:Owns {create_time: timestamp()}]->(a);
 
INSERT INTO
Person (id, name)
VALUES (100, "John");


INSERT INTO
Account (id, is_blocked)
VALUES (1000, FALSE);


INSERT INTO PersonOwnAccount (id, account_id, create_time)
VALUES (100, 1000, CURRENT_TIMESTAMP());
Créer des nœuds et des arêtes avec les résultats de la requête
 
MATCH (a:Account {id: 1}), (oa:Account)
WHERE oa <> a
CREATE (a)-[:Transfers {amount: 100, create_time: timestamp()}]->(oa);
 
INSERT INTO AccountTransferAccount(id, to_id, create_time, amount)
SELECT a.id, oa.id, CURRENT_TIMESTAMP(), 100
FROM GRAPH_TABLE(
  FinGraph
  MATCH
    (a:Account {id:1000}),
    (oa:Account)
  WHERE oa <> a
);

Dans Spanner Graph, les libellés sont attribués de manière statique conformément à l'instruction LDD CREATE PROPERTY GRAPH.

Mettre à jour le nœud et le périphérique

openCypher Spanner Graph
Modifier les propriétés 
MATCH (p:Person {id: 100})
SET p.country = 'United States';
 
UPDATE Person AS p
SET p.country = 'United States'
WHERE p.id = 100;

Pour mettre à jour les libellés des graphiques Spanner, consultez la section Créer, mettre à jour ou supprimer un schéma de graphique Spanner.

Fusionner un nœud et une arête

openCypher Spanner Graph
Insérer un nouvel élément ou mettre à jour des propriétés 
MERGE (p:Person {id: 100, country: 'United States'});
 
INSERT OR UPDATE INTO Person
(id, country)
VALUES (100, 'United States');

Supprimer le nœud et le périphérique

Supprimer des arêtes revient à supprimer la table d'entrée.

openCypher Spanner Graph
Supprimer des nœuds et des arêtes 
MATCH (p:Person {id:100}), (a:Account {id:1000})
DELETE (p)-[:Owns]->(a);
 
DELETE PersonOwnAccount
WHERE id = 100 AND account_id = 1000;

La suppression de nœuds nécessite de gérer les arêtes pendantes potentielles. Lorsque DELETE CASCADE est spécifié, DELETE supprime les arêtes associées de comme DETACH DELETE dans openCypher. Pour en savoir plus, consultez la présentation du schéma Spanner.

openCypher Spanner Graph
Supprimer les nœuds et les arêtes associées 
DETACH DELETE (:Account {id: 1000});
 
DELETE Account
WHERE id = 1000;

Renvoyer les résultats de mutation

openCypher Spanner Graph
Renvoyer les résultats après l'insertion ou la mise à jour 
MATCH (p:Person {id: 100})
SET p.country = 'United States'
RETURN p.id, p.name;
 
UPDATE Person AS p
SET p.country = 'United States'
WHERE p.id = 100
THEN RETURN id, name;
Renvoyer les résultats après la suppression 
DELETE (p:Person {id: 100})
RETURN p.country;
 
DELETE FROM Person
WHERE id = 100
THEN RETURN country;

Étape suivante