Conformité aux spécifications OpenCypher dans Amazon Neptune - Amazon Neptune
ClausesOpérateursExpressionsFonctionsDifférences Neptune openCypher

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Conformité aux spécifications OpenCypher dans Amazon Neptune

La version Amazon Neptune d'openCypher prend généralement en charge les clauses, les opérateurs, les expressions, les fonctions et la syntaxe définis dans la spécification openCypher actuelle, à savoir la version 9 de Cypher Query Language Reference. Les limites et les différences relatives à la prise en charge d'openCypher par Neptune sont décrites ci-dessous.

Note

L'implémentation Neo4j actuelle de Cypher contient des fonctionnalités qui ne se trouvent pas dans la spécification openCypher mentionnée ci-dessus. Si vous migrez le code Cypher actuel vers Neptune, consultez Compatibilité de Neptune avec Neo4j et Réécriture des requêtes Cypher pour les exécuter dans openCypher sur Neptune pour plus d'informations.

Prise en charge des clauses openCypher dans Neptune

Neptune prend en charge les clauses suivantes, sauf indication contraire :

  • MATCH : prise en charge, mais pas shortestPath() et allShortestPaths()

  • OPTIONAL MATCH

  • MANDATORY MATCH : n'est actuellement pas pris en charge dans Neptune. Neptune prend toutefois en charge les valeurs d'ID personnalisées dans les requêtes MATCH.

  • RETURN : pris en charge, sauf lorsqu'il est utilisé avec des valeurs non statiques pour SKIP ou LIMIT. Par exemple, voici ce qui ne fonctionne pas pour l'instant :

    MATCH (n)
RETURN n LIMIT toInteger(rand())    // Does NOT work!

  • WITH : pris en charge, sauf lorsqu'il est utilisé avec des valeurs non statiques pour SKIP ou LIMIT. Par exemple, voici ce qui ne fonctionne pas pour l'instant :

    MATCH (n)
WITH n SKIP toInteger(rand())
WITH count() AS count
RETURN count > 0 AS nonEmpty    // Does NOT work!

  • UNWIND

  • WHERE

  • ORDER BY

  • SKIP

  • LIMIT

  • CREATE : Neptune vous permet de créer des valeurs d'ID personnalisées dans les requêtes CREATE.

  • DELETE

  • SET

  • REMOVE

  • MERGE : Neptune prend en charge les valeurs d'ID personnalisées dans les requêtes MERGE.

  • CALL[YIELD...] : n'est actuellement pas pris en charge dans Neptune.

  • UNION, UNION ALL : les requêtes en lecture seule sont prises en charge, mais les requêtes de mutation ne le sont pas actuellement.

Prise en charge des opérateurs openCypher dans Neptune

Neptune prend en charge les opérateurs suivants, sauf indication contraire :

Opérateurs généraux

  • DISTINCT

  • L'opérateur . permettant d'accéder aux propriétés d'un mappage de littéraux imbriqué.

Operateurs mathématiques

  • Opérateur d'addition +.

  • L'opérateur de soustraction -.

  • Opérateur de multiplication *.

  • L'opérateur de division /.

  • L'opérateur de division modulo %.

  • L’opérateur d’exponentiation ^ n’est PAS pris en charge.

Opérateurs de comparaison

  • Opérateur d'addition =.

  • L'opérateur d'égalité <>.

  • L'opérateur < (inférieur à) est pris en charge sauf lorsque l'un des arguments est un chemin, une liste ou un mappage.

  • L'opérateur > (supérieur à) est pris en charge sauf lorsque l'un des arguments est un chemin, une liste ou un mappage.

  • L'opérateur <= less-than-or-equal -to est pris en charge sauf lorsque l'un des arguments est un chemin, une liste ou une carte.

  • L'opérateur >= greater-than-or-equal -to est pris en charge sauf lorsque l'un des arguments est un chemin, une liste ou une carte.

  • IS NULL

  • IS NOT NULL

  • STARTS WITH est pris en charge si les données recherchées correspondant à une chaîne.

  • ENDS WITH est pris en charge si les données recherchées correspondant à une chaîne.

  • CONTAINS est pris en charge si les données recherchées correspondant à une chaîne.

Opérateurs booléens

  • AND

  • OR

  • XOR

  • NOT

Opérateurs de chaîne

  • Opérateur de concaténation +.

Opérateurs de liste

  • Opérateur de concaténation +.

  • IN (vérifie la présence d'un élément dans la liste)

Prise en charge des expressions openCypher dans Neptune

Neptune prend en charge les expressions suivantes, sauf indication contraire :

  • CASE

  • L'expression [] n'est actuellement pas prise en charge dans Neptune pour accéder aux clés de propriété calculées dynamiquement au sein d'un nœud, d'une relation ou d'un mappage. Par exemple, les éléments suivants ne fonctionnent pas :

    MATCH (n)
WITH [5, n, {key: 'value'}] AS list
RETURN list[1].name

Prise en charge des fonctions openCypher dans Neptune

Neptune prend en charge les fonctions suivantes, sauf indication contraire :

Fonctions de prédicat

  • exists()

Fonctions scalaires

  • coalesce()

  • endNode()

  • epochmillis()

  • head()

  • id()

  • last()

  • length()

  • randomUUID()

  • properties()

  • removeKeyFromMap

  • size() : cette méthode surchargée ne fonctionne actuellement que pour les expressions de modèles, les listes et les chaînes.

  • startNode()

  • timestamp()

  • toBoolean()

  • toFloat()

  • toInteger()

  • type()

Fonctions d'agrégation

  • avg()

  • collect()

  • count()

  • max()

  • min()

  • percentileDisc()

  • stDev()

  • percentileCont()

  • stDevP()

  • sum()

Répertorier des fonctions

  • join() (concatène les chaînes d'une liste en une seule chaîne)

  • keys()

  • labels()

  • nodes()

  • range()

  • relationships()

  • reverse()

  • tail()

Fonctions mathématiques (numériques)

  • abs()

  • ceil()

  • floor()

  • rand()

  • round()

  • sign()

Fonctions mathématiques (logarithmiques)

  • e()

  • exp()

  • log()

  • log10()

  • sqrt()

Fonctions mathématiques (trigonométriques)

  • acos()

  • asin()

  • atan()

  • atan2()

  • cos()

  • cot()

  • degrees()

  • pi()

  • radians()

  • sin()

  • tan()

Fonctions de chaîne

  • join() (concatène les chaînes d'une liste en une seule chaîne)

  • left()

  • lTrim()

  • replace()

  • reverse()

  • right()

  • rTrim()

  • split()

  • substring()

  • toLower()

  • toString()

  • toUpper()

  • trim()

Fonctions définies par l'utilisateur

Les fonctions définies par l'utilisateur ne sont actuellement pas prises en charge dans Neptune.

Détails d'implémentation d'openCypher spécifiques à Neptune

Les sections suivantes décrivent en quoi l'implémentation Neptune d'openCypher peut différer ou aller au-delà de la spécification openCypher.

Évaluations des chemins de longueur variable (VLP) dans Neptune

Les évaluations de chemins de longueur variable (VLP) découvrent les chemins entre les nœuds du graphe. La longueur du chemin peut être illimitée dans une requête. Pour éviter les cycles, la spécification openCypher indique que chaque arête doit être traversée au maximum une fois par solution.

Pour les VLP, l'implémentation Neptune s'écarte de la spécification openCypher en ce sens qu'elle ne prend en charge que les valeurs de constantes pour les filtres d'égalité des propriétés. Prenons la requête suivante :

MATCH (x)-[:route*1..2 {dist:33, code:x.name}]->(y) return x,y

La valeur du filtre d'égalité des propriétés x.name n'étant pas une constante, cette requête génère une exception UnsupportedOperationException avec le message suivant : Property predicate over variable-length relationships with non-constant expression is not supported in this release.

Prise en charge temporelle dans l'implémentation de Neptune openCypher

Neptune fournit actuellement une prise en charge limitée de la fonction temporelle dans openCypher. Il prend en charge le type de données DateTime pour les types temporels.

La fonction datetime() peut être utilisée pour obtenir la date et l'heure UTC actuelles comme suit :

RETURN  datetime() as res

Les valeurs de date et d'heure peuvent être converties à partir des données stockées dans Neptune comme suit :

MATCH (n) RETURN datetime(n.createdDate)

Les valeurs de date et d'heure peuvent être analysées à partir de chaînes dans un format "dateTheure" où date et heure sont toutes deux exprimées sous l'une des formes prises en charge ci-dessous :

Formats de date pris en charge

  • yyyy-MM-dd

  • yyyyMMdd

  • yyyy-MM

  • yyyy-DDD

  • yyyyDDD

  • yyyy

Formats pris en charge

  • HH:mm:ssZ

  • HHmmssZ

  • HH:mm:ssZ

  • HH:mmZ

  • HHmmZ

  • HHZ

  • HHmmss

  • HH:mm:ss

  • HH:mm

  • HHmm

  • HH

Par exemple :

RETURN datetime('2022-01-01T00:01')      // or another example:
RETURN datetime('2022T0001')

Notez que toutes les valeurs de date/heure dans Neptune openCypher sont stockées et récupérées sous forme de valeurs UTC.

Neptune openCypher utilise une horloge statement, ce qui signifie que le même instant dans le temps est utilisé pendant toute la durée d'une requête. Une requête différente au sein de la même transaction peut utiliser un instant différent.

Neptune ne prend pas en charge l'utilisation d'une fonction dans un appel à datetime(). Voici, par exemple, ce qui ne fonctionne pas :

CREATE (:n {date:datetime(tostring(2021))})  // ---> NOT ALLOWED!

Neptune prend en charge la fonction epochmillis() qui convertit une valeur datetime en epochmillis. Par exemple :

MATCH (n) RETURN epochMillis(n.someDateTime)
1698972364782

Neptune ne prend actuellement pas en charge les autres fonctions et opérations au niveau des objets DateTime, telles que l'addition et la soustraction.

Différences de sémantique du langage Neptune openCypher

Neptune représente les ID de nœuds et de relations sous forme de chaînes plutôt que d'entiers. L'ID équivaut à celui fourni par le biais du chargeur de données. S'il existe un espace de noms pour la colonne, il s'agit de l'espace de noms plus l'ID. Par conséquent, la fonction id renvoie une chaîne au lieu d'un entier.

Le type de données INTEGER est limité à 64 bits. Lors de la conversion de valeurs à virgule flottante ou de valeurs de chaîne plus grandes en entier à l'aide de la fonction TOINTEGER, les valeurs négatives sont tronquées en LLONG_MIN, et les valeurs positives sont tronquées en LLONG_MAX.

Par exemple :

RETURN TOINTEGER(2^100)
>  9223372036854775807

RETURN TOINTEGER(-1 * 2^100)
>  -9223372036854775808

Fonction join() spécifique à Neptune

Neptune implémente une fonction join() qui ne se trouve pas dans la spécification openCypher. Cela crée un littéral de chaîne à partir d'une liste de littéraux de chaîne et d'un délimiteur de chaîne. Deux arguments sont donc utilisés :

  • Le premier argument est une liste de littéraux de chaîne.

  • Le deuxième argument est le délimiteur de chaîne, qui peut avoir un, aucune ou plusieurs caractères.

Exemple : 

join(["abc", "def", "ghi"], ", ")    // Returns "abc, def, ghi"

Fonction removeKeyFromMap() spécifique à Neptune

Neptune implémente une fonction removeKeyFromMap() qui ne se trouve pas dans la spécification openCypher. Il supprime une clé spécifiée dans un mappage et renvoie le nouveau mappage généré.

La fonction accepte deux arguments :

  • Le premier argument est le mappage à partir duquel la clé doit être supprimée.

  • Le premier argument est la clé à supprimer du mappage.

Cette fonction removeKeyFromMap() est particulièrement utile dans les situations où vous souhaitez définir les valeurs d'un nœud ou d'une relation en déroulant une liste de mappage. Par exemple :

UNWIND [{`~id`: 'id1', name: 'john'}, {`~id`: 'id2', name: 'jim'}] as val
CREATE (n {`~id`: val.`~id`})
SET n = removeKeyFromMap(val, '~id')

Valeurs d'ID personnalisées pour les propriétés des nœuds et des relations

À partir de la version 1.2.0.2 du moteur, Neptune a étendu la spécification openCypher afin que vous puissiez désormais spécifier les valeurs id des nœuds et des relations dans les clauses CREATE, MERGE et MATCH. Cela vous permet d'attribuer des chaînes conviviales au lieu d'UUID générés par le système pour identifier les nœuds et les relations.

Avertissement

Cette extension de la spécification openCypher est rétrocompatible, car ~id est désormais considéré comme un nom de propriété réservé. Si vous l'utilisez déjà ~id en tant que propriété dans vos données et requêtes, vous devez migrer la propriété existante vers une nouvelle clé de propriété et supprimer l'ancienne. veuillez consulter Que faire si vous utilisez actuellement ~id en tant que propriété.

Voici un exemple montrant comment créer des nœuds et des relations dotés d'ID personnalisés :

CREATE (n {`~id`: 'fromNode', name: 'john'})
  -[:knows {`~id`: 'john-knows->jim', since: 2020}]
  ->(m {`~id`: 'toNode', name: 'jim'})

Si vous essayez de créer un ID personnalisé déjà utilisé, Neptune génère une erreur DuplicateDataException.

Voici un exemple d'utilisation d'ID personnalisé dans une clause MATCH :

MATCH (n {`~id`: 'id1'})
RETURN n

Voici un exemple d'utilisation d'ID personnalisés dans une clause MERGE :

MATCH (n {name: 'john'}), (m {name: 'jim'})
MERGE (n)-[r {`~id`: 'john->jim'}]->(m)
RETURN r

Que faire si vous utilisez actuellement ~id en tant que propriété

Avec la version 1.2.0.2 du moteur, la clé ~id dans les clauses openCypher est désormais traitée comme id plutôt que comme propriété. Dès lors, si vous avez une propriété nommée ~id, il devient impossible d'y accéder.

Si vous utilisez une propriété ~id, avant de passer à la version de moteur 1.2.0.2 ou à une version ultérieure, vous devez migrer la propriété ~id existante vers une nouvelle clé de propriété, puis supprimer la propriété ~id. Par exemple, la requête ci-dessous :

  • Crée une propriété nommée 'newId' pour tous les nœuds,

  • copie la valeur de la propriété '~id' dans la propriété 'newId'

  • et supprime la propriété '~id' des données

MATCH (n)
WHERE exists(n.`~id`)
SET n.newId = n.`~id`
REMOVE n.`~id`

La même approche doit être adoptée pour toutes les relations dans les données qui ont une propriété ~id.

Vous devrez également modifier toutes les requêtes que vous utilisez qui font référence à une propriété ~id. Par exemple, cette requête :

MATCH (n)
WHERE n.`~id` = 'some-value'
RETURN n

... serait remplacée par ce qui suit :

MATCH (n)
WHERE n.newId = 'some-value'
RETURN n

Autres différences entre Neptune openCypher et Cypher

  • Neptune prend uniquement en charge les connexions TCP pour le protocole Bolt. WebSocketsles connexions pour Bolt ne sont pas prises en charge.

  • Neptune openCypher supprime les espaces tels que définis par Unicode dans les fonctions trim(), ltrim() et rtrim().

  • Dans Neptune openCypher, tostring(double) ne passe pas automatiquement en notation E pour les grandes valeurs du double.

  • Bien qu'openCypher CREATE ne crée pas de propriétés à valeurs multiples, celles-ci peuvent exister dans les données créées à l'aide de Gremlin. Si Neptune openCypher trouve une propriété à valeurs multiples, l'une de ces valeurs est choisie arbitrairement, ce qui crée un résultat non déterministe.