Référence 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 libellés de bord
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.		 TRAIL chemin

Lorsque vous souhaitez obtenir un résultat unique dans Spanner Graph, utilisez le mode TRAIL pour renvoyer des arêtes uniques dans une seule correspondance.

Conformité aux normes

Spanner Graph adopte les normes ISO Graph Query Language (GQL) et SQL/Property Graph Queries (SQL/PGQ).

Modèle de données

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

openCypher Spanner Graph
Chaque relation est associée à un seul type de relation.
 Les nœuds et les arêtes comportent un ou plusieurs libellés.

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 libellés sont définis de manière statique dans le schéma. Pour mettre à jour les libellés, vous devez 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 fonctionnalités de requête de Spanner Graph sont similaires à 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 ce 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, consultez 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.

Uniqueté des relations 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 le mode TRAIL pour vous assurer qu'aucun lien répété 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 Spanner Graph renvoie un chemin d'accès valide.

Exemple de graphique

openCypher Spanner Graph (mode TRAIL) Spanner Graph (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

Afficher les éléments du graphique en tant que 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

La mise en correspondance de modèles à longueur variable dans openCypher est appelée quantification de chemin dans Spanner Graph. La quantification de chemin utilise une syntaxe différente, comme illustré 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;

Itinéraire 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 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;

Instructions 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 en savoir plus, consultez les sections Instruction RETURN et Instruction WITH.
Spanner Graph 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 motif de graphique.
ORDER BY Compatible Pour en savoir plus, consultez la section Instruction ORDER BY.
SKIP / LIMIT Compatible Pour en savoir plus, consultez les sections Instruction SKIP et 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 section 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 en savoir plus, consultez la section Types de données dans GoogleSQL.

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

Type structurel

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

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 combiner 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 ni les cartes d'une liste de clés dynamiques et les types de valeurs d'éléments hétérogènes. Utilisez 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 la section 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.

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

Fonctions et expressions de type structurel

Type Fonction ou expression openCypher
 Spanner Graph
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 de type de propriété, mais pas 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 Edge .
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
 Spanner Graph
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

Spanner Graph n'accepte pas de chaîne de comparaison. Cela équivaut à des comparaisons conjuguées avec AND.
Exemple: 

      a < b AND b < C

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

Par 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 la demande Compatible
Sous-requête Exists Compatible
Projection cartographique Non compatibleLes types
et STRUCT offrent des fonctionnalités similaires.
Comprehension de liste 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 d'entrée des nœuds et des arêtes. Pour en savoir plus, consultez la section Insérer, mettre à jour ou supprimer 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 à l'aide des résultats de 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 un nœud et une arête

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 du graphique 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 é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 l'arête

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 des nœuds tels que 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 la mutation

openCypher Spanner Graph
Afficher les résultats après une insertion ou une 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