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.
# Extensions OpenCypher dans Amazon Neptune
Amazon Neptune prend en charge la version 9 de référence des spécifications OpenCypher. Consultez Amazon Neptune pour plus de détails. [Conformité aux spécifications OpenCypher dans Amazon Neptune](feature-opencypher-compliance.md) Amazon Neptune prend également en charge les fonctionnalités répertoriées ici. À moins que des versions spécifiques ne soient mentionnées, les fonctionnalités sont disponibles dans Neptune Database et Neptune Analytics.
## Query-time Accès aux données S3
Disponible dans la base de données Neptune 1.4.7.0 et versions ultérieures.
Neptune prend en charge la `neptune.read()` fonction permettant de lire les données CSV ou Parquet d'Amazon S3 directement dans les requêtes OpenCypher. Contrairement au chargeur en masse qui importe les données avant d'effectuer une requête, il `neptune.read()` accède aux données Amazon S3 au moment de l'exécution de la requête.
Pour une documentation complète, consultez[neptune.read ()](access-graph-opencypher-21-extensions-s3-read.md).
## La `fonction Neptune-specific` join ()
Disponible dans la base de données Neptune et Neptune Analytics.
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"
```
## La `fonction Neptune-specific` remove KeyFromMap ()
Disponible dans la base de données Neptune et Neptune Analytics.
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
Disponible dans Neptune Database 1.2.0.2 et versions ultérieures, et Neptune Analytics.
À partir de la [version 1.2.0.2 du moteur](engine-releases-1.2.0.2.md), 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.
Dans Neptune Analytics, les valeurs d'identifiant personnalisées ne sont pas disponibles pour les arêtes.
**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. Consultez [Que faire si vous utilisez actuellement `~id` comme propriété](#opencypher-compliance-custom-ids-migrating).
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` comme propriété
Avec la [version 1.2.0.2 du moteur](engine-releases-1.2.0.2.md), 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
```
## Prise en charge des sous-requêtes CALL dans Neptune
Disponible dans Neptune Database 1.4.1.0 et versions ultérieures, et Neptune Analytics.
Amazon Neptune prend en charge les `CALL` sous-requêtes. Une `CALL` sous-requête fait partie de la requête principale qui s'exécute dans une étendue isolée pour chaque entrée de la `CALL` sous-requête.
Supposons, par exemple, qu'un graphique contienne des données sur des personnes, leurs amis et les villes dans lesquelles elles vivaient. Nous pouvons récupérer les deux plus grandes villes où vivait chaque ami de quelqu'un en utilisant une `CALL` sous-requête :
```
MATCH (person:Person)-[:knows]->(friend)
CALL {
WITH friend
MATCH (friend)-[:lived_in]->(city)
RETURN city
ORDER BY city.population DESC
LIMIT 2
}
RETURN person, friend, city
```
Dans cet exemple, la partie de requête interne `CALL { ... }` est exécutée pour chacune `friend` des requêtes correspondant à la clause MATCH précédente. Lorsque la requête interne est exécutée, les `LIMIT` clauses `ORDER` and sont locales aux villes où vivait un ami spécifique. Nous obtenons donc (au maximum) deux villes par ami.
Toutes les clauses de requête sont disponibles dans les `CALL` sous-requêtes. Cela inclut également les `CALL` sous-requêtes imbriquées. Certaines restrictions concernant la première `WITH` clause et les variables émises existent et sont expliquées ci-dessous.
### Étendue des variables dans la sous-requête CALL
Les variables des clauses situées avant la `CALL` sous-requête qui sont utilisées dans celle-ci doivent être importées par la `WITH` clause initiale. Contrairement aux `WITH` clauses régulières, elle ne peut contenir qu'une liste de variables mais n'autorise pas l'aliasing et ne peut pas être utilisée avec `DISTINCT``ORDER BY`, `WHERE``SKIP`, ou`LIMIT`.
### Variables renvoyées par la sous-requête CALL
Les variables émises par la `CALL` sous-requête sont spécifiées dans la `RETURN` clause finale. Notez que les variables émises ne peuvent pas se chevaucher avec les variables antérieures à la `CALL` sous-requête.
### Limitations
Pour l'instant, les mises à jour à l'intérieur d'une `CALL` sous-requête ne sont pas prises en charge.
## Fonctions OpenCypher de Neptune
Disponible dans Neptune Database 1.4.1.0 et versions ultérieures, et Neptune Analytics.
**texte IndexOf **
`textIndexOf(text :: STRING, lookup :: STRING, from = 0 :: INTEGER?, to = -1 :: INTEGER?) :: (INTEGER?)`
Renvoie l'indice de la première occurrence de `lookup` dans la plage `text` allant de offset `from` (inclus) à offset `to` (exclusif). Si la `to` valeur est -1, la plage continue jusqu'à la fin de`text`. L'indexation est basée sur zéro et est exprimée en valeurs scalaires Unicode (points de code non substituts).
```
RETURN textIndexOf('Amazon Neptune', 'e')
{
"results": [{
"textIndexOf('Amazon Neptune', 'e')": 8
}]
}
```
**coll ToSet **
`collToSet(values :: LIST OF ANY?) :: (LIST? OF ANY?)`
Renvoie une nouvelle liste contenant uniquement les éléments uniques de la liste d'origine. L'ordre de la liste d'origine est ** maintenu ** (par exemple, les `[1, 6, 5, 1, 5]` retours`[1, 6, 5]`).
```
RETURN collToSet([1, 6, 5, 1, 1, 5])
{
"results": [{
"collToSet([1, 6, 5, 1, 1, 5])": [1, 6, 5]
}]
}
```
**CollSubtract **
`collSubtract(first :: LIST OF ANY?, second :: LIST OF ANY?) :: (LIST? OF ANY?)`
Renvoie une nouvelle liste contenant tous les éléments uniques de l'`first`exclusion d'éléments de`second`.
```
RETURN collSubtract([2, 5, 1, 0], [1, 5])
{
"results": [{
"collSubtract([2, 5, 1, 0], [1, 5])": [0, 2]
}]
}
```
**Intersection de Coll **
`collIntersection(first :: LIST? OF ANY?, second :: LIST? OF ANY?) :: (LIST? OF ANY?)`
Renvoie une nouvelle liste contenant tous les éléments uniques de l'intersection de `first` et`second`.
```
RETURN collIntersection([2, 5, 1, 0], [1, 5])
{
"results": [{
"collIntersection([2, 5, 1, 0], [1, 5])": [1, 5]
}]
}
```
## Fonctions de tri
Les sections suivantes définissent les fonctions permettant de trier les collections. Ces fonctions utilisent des arguments de `config` carte (dans certains cas facultatifs), ou une liste de plusieurs cartes de ce type, qui définissent la clé de tri dans and/or le sens du tri :
```
{ key: STRING, order: STRING }
```
`key`Voici une propriété de carte ou de nœud dont la valeur doit être utilisée pour le tri. `order`est soit "`asc`" soit "`desc`" (insensible aux majuscules) pour spécifier un tri croissant ou décroissant, respectivement. Par défaut, le tri sera effectué par ordre croissant.
**Coll Sort **
`collSort(coll :: LIST OF ANY, config :: MAP?) :: (LIST? OF ANY?)`
Renvoie une nouvelle liste triée contenant les éléments de la liste `coll` d'entrée.
```
RETURN collSort([5, 3, 1], {order: 'asc'})
{
"results": [{
"collSort([5, 3, 1])": [1, 3, 5]
}]
}
```
**coll SortMaps **
`collSortMaps(coll :: LIST OF MAP, config :: MAP) :: (LIST? OF ANY?)`
Renvoie une liste de cartes triées selon la valeur de la `key` propriété spécifiée.
```
RETURN collSortMaps([{name: 'Alice', age: 25}, {name: 'Bob', age: 35}, {name: 'Charlie', age: 18}], {key: 'age', order: 'desc'})
{
"results": [{
"x": [{
"age": 35,
"name": "Bob"
}, {
"age": 25,
"name": "Alice"
}, {
"age": 18,
"name": "Charlie"
}]
}]
}
```
**coll SortMulti **
```
collSortMulti(coll :: LIST OF MAP?,
configs = [] :: LIST OF MAP,
limit = -1 :: INTEGER?,
skip = 0 :: INTEGER?) :: (LIST? OF ANY?)
```
Renvoie une liste de cartes triées selon la valeur des `key` propriétés spécifiées, en appliquant éventuellement limit et skip.
```
RETURN collSortMulti([{name: 'Alice', age: 25}, {name: 'Bob', age: 35}, {name: 'Charlie', age: 18}], [{key: 'age', order: 'desc'}, {key:'name'}]) as x
{
"results": [{
"x": [{
"age": 35,
"name": "Bob"
}, {
"age": 25,
"name": "Alice"
}, {
"age": 18,
"name": "Charlie"
}]
}]
}
```
**coll SortNodes **
`collSortNodes(coll :: LIST OF NODE, config :: MAP) :: (LIST? OF NODE?)`
Renvoie une version triée de la liste `coll` d'entrée, triant les éléments du nœud en fonction des valeurs de leurs `key` propriétés respectives.
```
create (n:person {name: 'Alice', age: 23}), (m:person {name: 'Eve', age: 21}), (o:person {name:'Bob', age:25})
{"results":[]}
match (n:person) with collect(n) as people return collSortNodes(people, {key: 'name', order: 'desc'})
{
"results": [{
"collSortNodes(people, 'name')": [{
"~id": "e599240a-8c23-4337-8aa8-f603c8fb5488",
"~entityType": "node",
"~labels": ["person"],
"~properties": {
"age": 21,
"name": "Eve"
}
}, {
"~id": "8a6ef785-59e3-4a0b-a0ff-389655a9c4e6",
"~entityType": "node",
"~labels": ["person"],
"~properties": {
"age": 25,
"name": "Bob"
}
}, {
"~id": "466bc826-f47f-452c-8a27-6b7bdf7ae9b4",
"~entityType": "node",
"~labels": ["person"],
"~properties": {
"age": 23,
"name": "Alice"
}
}]
}]
}
match (n:person) with collect(n) as people return collSortNodes(people, {key: 'age'})
{
"results": [{
"collSortNodes(people, '^age')": [{
"~id": "e599240a-8c23-4337-8aa8-f603c8fb5488",
"~entityType": "node",
"~labels": ["person"],
"~properties": {
"age": 21,
"name": "Eve"
}
}, {
"~id": "466bc826-f47f-452c-8a27-6b7bdf7ae9b4",
"~entityType": "node",
"~labels": ["person"],
"~properties": {
"age": 23,
"name": "Alice"
}
}, {
"~id": "8a6ef785-59e3-4a0b-a0ff-389655a9c4e6",
"~entityType": "node",
"~labels": ["person"],
"~properties": {
"age": 25,
"name": "Bob"
}
}]
}]
}
```
## Fonctions temporelles
Les fonctions temporelles sont disponibles à partir de la version [ 1.4.5.0 ](https://docs.aws.amazon.com/releases/release-1.4.5.0.xml) de Neptune.
### day
`day(temporal :: (datetime | date)) :: (LONG)`
Renvoie le `day` du mois à partir d'une `date` valeur `datetime` ou. Pour `datetime` : les valeurs sont normalisées en UTC sur la base des données saisies avant l'extraction du jour. Pour `date` : le jour est extrait en fonction du fuseau horaire.
L'`datetime`entrée est disponible à la fois dans la base de données Neptune et dans Neptune Analytics :
```
RETURN day(datetime('2021-06-03T01:48:14Z'))
{
"results": [{
"day(datetime('2021-06-03T01:48:14Z'))": 3
}]
}
```
Ici, le `datetime` est normalisé à UTC, donc \+ 08:00 revient au 2 juin.
```
RETURN day(datetime('2021-06-03T00:00:00+08:00'))
{
"results": [{
"day(datetime('2021-06-03T00:00:00+08:00'))": 2
}]
}
```
L'`date`entrée est disponible uniquement dans Neptune Analytics :
```
RETURN day(date('2021-06-03Z'))
{
"results": [{
"day(date('2021-06-03Z'))": 3
}]
}
```
Le fuseau horaire est `date` conservé, le 3 juin.
```
RETURN day(date('2021-06-03+08:00'))
{
"results": [{
"day(date('2021-06-03+08:00'))": 3
}]
}
```
### month
`month(temporal :: (datetime | date)) :: (LONG)`
Renvoie le mois à partir d'une `date` valeur `datetime` ou (1-12). Pour `datetime` : les valeurs sont normalisées en UTC sur la base des données saisies avant l'extraction du mois. Pour `date` : le mois est extrait en fonction du fuseau horaire.
L'`datetime`entrée est disponible à la fois dans la base de données Neptune et dans Neptune Analytics :
```
RETURN month(datetime('2021-06-03T01:48:14Z'))
{
"results": [{
"month(datetime('2021-06-03T01:48:14Z'))": 6
}]
}
```
Ici, le `datetime` est normalisé à UTC, donc \+ 08:00 revient au 31 mai.
```
RETURN month(datetime('2021-06-01T00:00:00+08:00'))
{
"results": [{
"month(datetime('2021-06-01T00:00:00+08:00'))": 5
}]
}
```
L'`date`entrée est disponible uniquement dans Neptune Analytics :
```
RETURN month(date('2021-06-03Z'))
{
"results": [{
"month(date('2021-06-03Z'))": 6
}]
}
```
Le fuseau horaire est `date` conservé, le 1er juin.
```
RETURN month(date('2021-06-01+08:00'))
{
"results": [{
"month(date('2021-06-01+08:00'))": 6
}]
}
```
### year
`year(temporal :: (datetime | date)) :: (LONG)`
Renvoie l'année à partir d'une `date` valeur `datetime` ou. Pour `datetime` : les valeurs sont normalisées en UTC sur la base des données saisies avant l'extraction de l'année. Pour `date` : l'année est extraite en fonction du fuseau horaire.
L'`datetime`entrée est disponible à la fois dans la base de données Neptune et dans Neptune Analytics :
```
RETURN year(datetime('2021-06-03T01:48:14Z'))
{
"results": [{
"year(datetime('2021-06-03T01:48:14Z'))": 2021
}]
}
```
Ici, le `datetime` est normalisé à UTC, donc \+ 08:00 revient au 31 décembre 2020.
```
RETURN year(datetime('2021-01-01T00:00:00+08:00'))
{
"results": [{
"year(datetime('2021-01-01T00:00:00+08:00'))": 2020
}]
}
```
L'`date`entrée est disponible uniquement dans Neptune Analytics :
```
RETURN year(date('2021-06-03Z'))
{
"results": [{
"year(date('2021-06-03Z'))": 2021
}]
}
```
Le fuseau horaire est `date` conservé, en tenant compte de juin 2021.
```
RETURN year(date('2021-01-01+08:00'))
{
"results": [{
"year(date('2021-01-01+08:00'))": 2021
}]
}
```
### Fonctions OpenCypher de Neptune
Disponible dans Neptune Database 1.4.6.0 et versions ultérieures, et Neptune Analytics.
#### réduire ()
Reduce traite séquentiellement chaque élément de la liste en le combinant avec un total cumulé ou un « accumulateur ». En commençant par une valeur initiale, il met à jour l'accumulateur après chaque opération et utilise cette valeur mise à jour lors de l'itération suivante.
`for i in (0, ..., n) acc = acc X list[I], where X denotes any binary operator`
Une fois que tous les éléments ont été traités, il renvoie le résultat final cumulé.
Une structure de réduction () typique serait : `reduce(accumulator = initial , variable IN list | expression)`
**Spécifications du type :**
`- initial: starting value for the accumulator :: (Long | FLOAT | STRING | LIST? OF (STRING, LONG, FLOAT)) - list: the input list :: LIST OF T where T matches initial type - variable :: represents each element in the input list - expression :: Only supports '+' and '*' operator - return :: Same type as initial `
**Restrictions :**
Actuellement, l'`reduce()`expression ne prend en charge que :
+ Multiplication numérique
+ Addition numérique
+ Concaténation de chaînes
+ Concaténation de listes
Ils sont représentés par l'`*`opérateur `+` ou. L'expression doit être une expression binaire comme indiqué ci-dessous - `expression pattern: accumulator + any variable or accumulator * any variable`
**Gestion des débordements :**
Neptune détecte un dépassement numérique lors de l'`reduce()`évaluation et répond différemment en fonction du type de données :
```
LONG (signed 64‑bit)
--------------------
• Valid range: –9 223 372 036 854 775 808 … 9 223 372 036 854 775 807
• If any intermediate or final value falls outside this range,
Neptune aborts the query with long overflow error message.
FLOAT (IEEE‑754 double)
-----------------------
• Largest finite value ≈ 1.79 × 10^308
• Larger results overflow to INF
Once `INF` is produced, it propagates through the remainder
of the reduction.
```
**Exemples :**
Consultez les exemples suivants pour la fonction reduce ().
```
1. Long Addition:
RETURN reduce(sum = 0, n IN [1, 2, 3] | sum + n)
{
"results": [{
"reduce(sum = 0, n IN [1, 2, 3] | sum + n)": 6
}]
}
2. String Concatenation:
RETURN reduce(str = "", x IN ["A", "B", "C"] | str + x)
{
"results": [{
"reduce(str = "", x IN ["A", "B", "C"] | str + x)": "ABC"
}]
}
3. List Combination:
RETURN reduce(lst = [], x IN [1, 2, 3] | lst + x)
{
"results": [{
"reduce(lst = [], x IN [1, 2, 3] | lst + x)": [1, 2, 3]
}]
}
4. Float Addition:
RETURN reduce(total = 0.0, x IN [1.5, 2.5, 3.5] | total + x)
{
"results": [{
"reduce(total = 0.0, x IN [1.5, 2.5, 3.5] | total + x)": 7.5
}]
}
5. Long Multiplication:
RETURN reduce(product = 1, n IN [1, 2, 3] | product * n)
{
"results": [{
"reduce(product = 0, n IN [1, 2, 3] | product * n)": 6
}]
}
6. Float Multiplication:
RETURN reduce(product = 1.0, n IN [1.5, 2.5, 3.5] | product * n)
{
"results": [{
"reduce(product = 1.0, n IN [1.5, 2.5, 3.5] | product * n)": 13.125
}]
}
7. Long Overflow (Exception):
RETURN reduce(s = 9223372036854775807, x IN [2, 3] | s * x) AS result
{
"results": [{
"reduce(s = 9223372036854775807, x IN [2, 3] | s * x) AS result": long overflow
}]
}
8. Float Overflow:
RETURN reduce(s = 9.0e307, x IN [8.0e307, 1.0e307] | s + x) AS result
{
"results": [{
"reduce(s = 9.0e307, x IN [8.0e307, 1.0e307] | s + x) AS result": INF
}]
}
```