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](https://s3.amazonaws.com/artifacts.opencypher.org/openCypher9.pdf). Les limites et les différences relatives à la prise en charge d'openCypher par Neptune sont décrites ci-dessous. Amazon Neptune prend également en charge plusieurs fonctionnalités qui ne sont pas couvertes par la spécification OpenCypher. Pour plus d'informations, consultez [Extensions OpenCypher dans Amazon Neptune](access-graph-opencypher-extensions.md). **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](migration-compatibility.md) et [Réécriture des requêtes Cypher pour les exécuter dans openCypher sur Neptune](migration-opencypher-rewrites.md) 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](access-graph-opencypher-extensions.md#opencypher-compliance-custom-ids) 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](access-graph-opencypher-extensions.md#opencypher-compliance-custom-ids) dans les requêtes `CREATE`. + `DELETE` + `SET` + `REMOVE` + `MERGE` : Neptune prend en charge les [valeurs d'ID personnalisées](access-graph-opencypher-extensions.md#opencypher-compliance-custom-ids) 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. + `USING`— `USING` est pris en charge depuis la version [1.3.2.0](https://docs.aws.amazon.com//neptune/latest/userguide/engine-releases-1.3.2.0.html) du moteur. Voir [Conseils relatifs aux requêtes](https://docs.aws.amazon.com//neptune/latest/userguide/opencypher-query-hints.html) pour plus d'informations. ## 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. *is NOT supported* **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()`](access-graph-opencypher-extensions.md#opencypher-compliance-join-function) (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()`](access-graph-opencypher-extensions.md#opencypher-compliance-join-function) (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** *User-defined functions***ne sont actuellement pas** pris 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](https://s3.amazonaws.com/artifacts.opencypher.org/openCypher9.pdf). ### É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](https://s3.amazonaws.com/artifacts.opencypher.org/openCypher9.pdf) indique que chaque arête doit être traversée au maximum une fois par solution. En effet VLPs, l'implémentation de Neptune s'écarte de la spécification OpenCypher en ce sens qu'elle ne prend en charge que les valeurs 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.` ### Support temporel dans l'implémentation de Neptune OpenCypher (base de données Neptune 1.3.1.0 et versions antérieures) 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 analysées à partir de chaînes dans un format `"`*date*`T`*heure*`"` 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 date/time valeurs de 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. ### Support temporel dans l'implémentation de Neptune OpenCypher (Neptune Analytics et Neptune Database 1.3.2.0 et versions ultérieures) La fonctionnalité date/heure suivante OpenCypher s'applique à Neptune Analytics. Vous pouvez également utiliser le paramètre labmode `DatetimeMillisecond=enabled` pour activer la fonctionnalité datetime suivante sur les versions 1.3.2.0 et supérieures du moteur Neptune. Pour plus de détails sur l'utilisation de cette fonctionnalité en mode laboratoire, consultez[Support date/heure étendu](features-lab-mode.md#labmode-extended-datetime-support). + Support en millisecondes. Le littéral Datetime sera toujours renvoyé en millisecondes, même si le nombre de millisecondes est égal à 0. (Le comportement précédent consistait à tronquer des millisecondes.) ``` CREATE (:event {time: datetime('2024-04-01T23:59:59Z')}) # Returning the date returns with 000 suffixed representing milliseconds MATCH(n:event) RETURN n.time as datetime { "results" : [ { "n" : { "~id" : "0fe88f7f-a9d9-470a-bbf2-fd6dd5bf1a7d", "~entityType" : "node", "~labels" : [ "event" ], "~properties" : { "time" : "2024-04-01T23:59:59.000Z" } } } ] } ``` + Support pour appeler la fonction datetime () sur des propriétés stockées ou des résultats intermédiaires. Par exemple, les requêtes suivantes n'étaient pas possibles avant cette fonctionnalité. Datetime () sur les propriétés : ``` // Create node with property 'time' stored as string CREATE (:event {time: '2024-04-01T23:59:59Z'}) // Match and return this property as datetime MATCH(n:event) RETURN datetime(n.time) as datetime ``` Datetime () sur les résultats intermédiaires : ``` // Parse datetime from parameter UNWIND $list as myDate RETURN datetime(myDate) as d ``` + Il est désormais également possible de sauvegarder les propriétés date/heure créées dans les cas mentionnés ci-dessus. Sauvegarde de la date et de l'heure de la propriété string d'une propriété vers une autre : ``` // Create node with property 'time' stored as string CREATE (:event {time: '2024-04-01T23:59:59Z', name: 'crash'}) // Match and update the same property to datetime type MATCH(n:event {name: 'crash'}) SET n.time = datetime(n.time) // Match and update another node's property MATCH(e:event {name: 'crash'}) MATCH(n:server {name: e.servername}) SET n.time = datetime(e.time) ``` Créez des nœuds par lots à partir d'un paramètre doté d'une propriété datetime : ``` // Batch create from parameter UNWIND $list as events CREATE (n:crash) {time: datetime(events.time)} // Parameter value { "x":[ {"time":"2024-01-01T23:59:29", "name":"crash1"}, {"time":"2023-01-01T00:00:00Z", "name":"crash2"} ] } ``` + Support d'un plus grand sous-ensemble de formats de ISO8601 date/heure. Reportez-vous à ci-dessous. Formats pris en charge Le format d'une valeur date/heure est [Date] T [Heure] [Fuseau horaire], où T est le séparateur. Si aucun fuseau horaire explicite n'est fourni, UTC (Z) est supposé être le fuseau horaire par défaut. Fuseau horaire Les formats de fuseau horaire pris en charge sont les suivants : + \$1/-HH : mm + \$1/-HHmm + \$1/-HH La présence d'un fuseau horaire dans une chaîne de date/heure est facultative. Si le décalage horaire est de 0, Z peut être utilisé à la place du suffixe de fuseau horaire ci-dessus pour indiquer l'heure UTC. La plage prise en charge d'un fuseau horaire est comprise entre -14h00 et \$114h00. Date Si aucun fuseau horaire n'est présent ou si le fuseau horaire est UTC (Z), les formats de date pris en charge sont les suivants : **Note** DDD fait référence à une date ordinale, qui représente un jour de l'année compris entre 001 et 365 (366 les années bissextiles). Par exemple, 2024-002 représente le 2 janvier 2024. + `yyyy-MM-dd` + `yyyyMMdd` + `yyyy-MM` + `yyyyMM` + `yyyy-DDD` + `yyyyDDD` + `yyyy` Si un fuseau horaire autre que Z est choisi, les formats de date pris en charge sont limités aux suivants : + `yyyy-MM-dd` + `yyyy-DDD` + `yyyyDDD` La plage de dates prise en charge est comprise entre 1400-01-01 et 9999-12-31. Heure Si aucun fuseau horaire n'est présent ou si le fuseau horaire est UTC (Z), les formats horaires pris en charge sont les suivants : + `HH:mm:ss.SSS` + `HH:mm:ss` + `HHmmss.SSS` + `HHmmss` + `HH:mm` + `HHmm` + `HH` Si un fuseau horaire autre que Z est choisi, les formats horaires pris en charge sont limités aux suivants : + `HH:mm:ss` + `HH:mm:ss.SSS` ### Différences de sémantique du langage Neptune openCypher Neptune représente le nœud et la relation IDs 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 ``` ### Propriétés à valeurs multiples 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 (base de données Neptune) ou lors du chargement de données (base de données Neptune et Neptune Analytics). 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. ### Gestion des valeurs NaN La façon dont Neptune gère la comparaison des valeurs des `NaN` propriétés n'est pas définie. Le fait de s'appuyer sur de telles comparaisons peut donner des résultats inattendus ou non déterministes.