Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Estensioni OpenCypher in Amazon Neptune
Amazon Neptune supporta la versione di riferimento della specifica OpenCypher 9. Per ulteriori informazioni, [Conformità alle specifiche OpenCypher in Amazon Neptune](feature-opencypher-compliance.md) consulta Amazon Neptune. Inoltre, Amazon Neptune supporta le funzionalità elencate qui. A meno che non vengano menzionate versioni specifiche, le funzionalità sono disponibili in Neptune Database e Neptune Analytics.
## Accesso ai dati Query-time S3
Disponibile in Neptune Database 1.4.7.0 e versioni successive.
Neptune supporta `neptune.read()` la funzione per leggere i dati CSV o Parquet da Amazon S3 direttamente all'interno delle query OpenCypher. A differenza del bulk loader che importa i dati prima dell'esecuzione delle query, accede ai dati di `neptune.read()` Amazon S3 al momento dell'esecuzione delle query.
Per la documentazione completa, consulta. [neptune.read ()](access-graph-opencypher-21-extensions-s3-read.md)
## Funzione `join()` specifica di Neptune
Disponibile in Neptune Database e Neptune Analytics.
Neptune implementa una funzione `join()` che non è presente nella specifica openCypher. Crea un valore letterale di stringa da un elenco di valori letterali di stringa e da un delimitatore di stringa. Accetta due argomenti:
+ Il primo argomento è un elenco di valori letterali di stringa.
+ Il secondo argomento è la stringa del delimitatore, che può essere composta da zero, uno o più caratteri.
Esempio:
```
join(["abc", "def", "ghi"], ", ") // Returns "abc, def, ghi"
```
## Funzione `removeKeyFromMap()` specifica di Neptune
Disponibile in Neptune Database e Neptune Analytics.
Neptune implementa una funzione `removeKeyFromMap()` che non è presente nella specifica openCypher. Rimuove una chiave specificata da una mappa e restituisce la nuova mappa risultante.
La funzione accetta due argomenti:
+ Il primo argomento è la mappa da cui rimuovere la chiave.
+ Il primo argomento è la chiave da rimuovere dalla mappa.
La funzione `removeKeyFromMap()` è particolarmente utile in situazioni in cui si desidera impostare valori per un nodo o una relazione utilizzando un elenco di mappe. Esempio:
```
UNWIND [{`~id`: 'id1', name: 'john'}, {`~id`: 'id2', name: 'jim'}] as val
CREATE (n {`~id`: val.`~id`})
SET n = removeKeyFromMap(val, '~id')
```
## Valori ID personalizzati per le proprietà dei nodi e delle relazioni
Disponibile in Neptune Database 1.2.0.2 e versioni successive e Neptune Analytics.
A partire dal [rilascio 1.2.0.2 del motore](engine-releases-1.2.0.2.md), Neptune ha esteso la specifica openCypher in modo che ora sia possibile specificare i valori `id` per i nodi e le relazioni nelle clausole `CREATE`, `MERGE` e `MATCH`. Ciò consente di assegnare stringhe intuitive anziché quelle generate dal sistema per identificare nodi e relazioni. UUIDs
In Neptune Analytics, i valori ID personalizzati non sono disponibili per i bordi.
**avvertimento**
Questa estensione della specifica openCypher è incompatibile con le versioni precedenti, perché `~id` ora è considerato un nome di proprietà riservato. Se si utilizza già `~id` come proprietà nei dati e nelle query, è necessario migrare la proprietà esistente a una nuova chiave di proprietà e rimuovere quella precedente. Per informazioni, consulta [Cosa fare se attualmente si utilizza `~id` come proprietà](#opencypher-compliance-custom-ids-migrating).
Ecco un esempio che mostra come creare nodi e relazioni con ID personalizzati:
```
CREATE (n {`~id`: 'fromNode', name: 'john'})
-[:knows {`~id`: 'john-knows->jim', since: 2020}]
->(m {`~id`: 'toNode', name: 'jim'})
```
Se si tenta di creare un ID personalizzato già in uso, Neptune genera un errore `DuplicateDataException`.
Ecco un esempio di utilizzo di un ID personalizzato in una clausola `MATCH`:
```
MATCH (n {`~id`: 'id1'})
RETURN n
```
Ecco un esempio di utilizzo di custom IDs in una `MERGE` clausola:
```
MATCH (n {name: 'john'}), (m {name: 'jim'})
MERGE (n)-[r {`~id`: 'john->jim'}]->(m)
RETURN r
```
### Cosa fare se attualmente si utilizza `~id` come proprietà
Con il [rilascio 1.2.0.2 del motore](engine-releases-1.2.0.2.md), la chiave `~id` nelle clausole openCypher viene ora trattata come `id` anziché come proprietà. Ciò significa che se si dispone di una proprietà denominata `~id`, accedervi diventa impossibile.
Se si utilizza una proprietà `~id`, prima di aggiornare il motore al rilascio `1.2.0.2` o superiore è necessario migrare la proprietà `~id` esistente a una nuova chiave di proprietà e quindi rimuovere la proprietà `~id`. Ad esempio, la query seguente:
+ Crea una nuova proprietà denominata 'newId' per tutti i nodi,
+ copia il valore della proprietà '\$1id' nella proprietà 'newId'
+ e rimuove la proprietà '\$1id' dai dati
```
MATCH (n)
WHERE exists(n.`~id`)
SET n.newId = n.`~id`
REMOVE n.`~id`
```
La stessa cosa deve essere fatta per tutte le relazioni nei dati che hanno una proprietà `~id`.
È inoltre necessario modificare tutte le query utilizzate che fanno riferimento a una proprietà `~id`. Ad esempio, questa query:
```
MATCH (n)
WHERE n.`~id` = 'some-value'
RETURN n
```
...verrà modificata in questa:
```
MATCH (n)
WHERE n.newId = 'some-value'
RETURN n
```
## Supporto per subquery CALL in Neptune
Disponibile in Neptune Database 1.4.1.0 e versioni successive e Neptune Analytics.
Amazon `CALL` Neptune supporta le subquery. Una `CALL` sottoquery è una parte della query principale che viene eseguita in un ambito isolato per ogni input della sottoquery. `CALL`
Ad esempio, supponiamo che un grafico contenga dati sulle persone, i loro amici e le città in cui hanno vissuto. Possiamo recuperare le due città più grandi in cui viveva ogni amico di qualcuno utilizzando una `CALL` sottoquery:
```
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
```
In questo esempio, la parte di interrogazione interna `CALL { ... }` viene eseguita per ognuna di esse `friend` che corrisponde alla clausola MATCH precedente. Quando viene eseguita la query interna, le `LIMIT` clausole `ORDER` and sono locali delle città in cui viveva un determinato amico, quindi otteniamo (al massimo) due città per amico.
Tutte le clausole di interrogazione sono disponibili all'interno delle sottoquery. `CALL` Ciò include anche le sottoquery `CALL` annidate. Esistono alcune restrizioni per la prima `WITH` clausola e le variabili emesse e sono spiegate di seguito.
### Ambito delle variabili all'interno della sottoquery CALL
Le variabili delle clausole precedenti alla `CALL` sottoquery utilizzate al suo interno devono essere importate dalla clausola iniziale. `WITH` A differenza delle `WITH` clausole normali, può contenere solo un elenco di variabili ma non consente l'aliasing e non può essere utilizzata insieme a,,, o. `DISTINCT` `ORDER BY` `WHERE` `SKIP` `LIMIT`
### Variabili restituite dalla sottoquery CALL
Le variabili emesse dalla `CALL` sottoquery vengono specificate con la clausola finale. `RETURN` Nota che le variabili emesse non possono sovrapporsi alle variabili precedenti alla sottoquery. `CALL`
### Limitazioni
Al momento, gli aggiornamenti all'interno di una `CALL` sottoquery non sono supportati.
## Funzioni OpenCypher di Neptune
Disponibile in Neptune Database 1.4.1.0 e versioni successive e Neptune Analytics.
**textIndexOf**
`textIndexOf(text :: STRING, lookup :: STRING, from = 0 :: INTEGER?, to = -1 :: INTEGER?) :: (INTEGER?)`
Restituisce l'indice della prima occorrenza `lookup` nell'intervallo compreso tra offset `from` (incluso) e offset (esclusivo). `text` `to` Se `to` è -1, l'intervallo continua fino alla fine di. `text` L'indicizzazione è a base zero ed è espressa in valori scalari Unicode (punti di codice non surrogati).
```
RETURN textIndexOf('Amazon Neptune', 'e')
{
"results": [{
"textIndexOf('Amazon Neptune', 'e')": 8
}]
}
```
**collToSet**
`collToSet(values :: LIST OF ANY?) :: (LIST? OF ANY?)`
Restituisce un nuovo elenco contenente solo gli elementi unici dell'elenco originale. L'ordine dell'elenco originale viene **mantenuto** (ad esempio `[1, 6, 5, 1, 5]` ritorni`[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?)`
Restituisce un nuovo elenco contenente tutti gli elementi unici da cui sono `first` esclusi gli elementi. `second`
```
RETURN collSubtract([2, 5, 1, 0], [1, 5])
{
"results": [{
"collSubtract([2, 5, 1, 0], [1, 5])": [0, 2]
}]
}
```
**CollInterSection**
`collIntersection(first :: LIST? OF ANY?, second :: LIST? OF ANY?) :: (LIST? OF ANY?)`
Restituisce un nuovo elenco contenente tutti gli elementi unici dell'intersezione di e. `first` `second`
```
RETURN collIntersection([2, 5, 1, 0], [1, 5])
{
"results": [{
"collIntersection([2, 5, 1, 0], [1, 5])": [1, 5]
}]
}
```
## Funzioni di ordinamento
Le seguenti sezioni definiscono le funzioni per ordinare le raccolte. Queste funzioni accettano (in alcuni casi opzionali) argomenti di `config` mappa, o un elenco di più mappe di questo tipo, che definiscono la chiave di ordinamento, and/or la direzione di ordinamento:
```
{ key: STRING, order: STRING }
```
`key`Ecco una proprietà della mappa o del nodo il cui valore deve essere usato per l'ordinamento. `order`è "" o "`asc``desc`" (senza distinzione tra maiuscole e minuscole) per specificare rispettivamente un ordinamento crescente o decrescente. Per impostazione predefinita, l'ordinamento verrà eseguito in ordine crescente.
**CollSort**
`collSort(coll :: LIST OF ANY, config :: MAP?) :: (LIST? OF ANY?)`
Restituisce un nuovo elenco ordinato contenente gli elementi dell'elenco `coll` di input.
```
RETURN collSort([5, 3, 1], {order: 'asc'})
{
"results": [{
"collSort([5, 3, 1])": [1, 3, 5]
}]
}
```
**collSortMaps**
`collSortMaps(coll :: LIST OF MAP, config :: MAP) :: (LIST? OF ANY?)`
Restituisce un elenco di mappe ordinate in base al valore della proprietà specificata`key`.
```
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"
}]
}]
}
```
**collSortMulti**
```
collSortMulti(coll :: LIST OF MAP?,
configs = [] :: LIST OF MAP,
limit = -1 :: INTEGER?,
skip = 0 :: INTEGER?) :: (LIST? OF ANY?)
```
Restituisce un elenco di mappe ordinate in base al valore delle `key` proprietà specificate, applicando facoltativamente limit e 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"
}]
}]
}
```
**collSortNodes**
`collSortNodes(coll :: LIST OF NODE, config :: MAP) :: (LIST? OF NODE?)`
Restituisce una versione ordinata dell'elenco di `coll` input, ordinando gli elementi del nodo in base ai valori delle rispettive proprietà. `key`
```
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"
}
}]
}]
}
```
## Funzioni temporali
[Le funzioni temporali sono disponibili a partire dalla versione 1.4.5.0 di Neptune.](https://docs.aws.amazon.com/releases/release-1.4.5.0.xml)
### giorno
`day(temporal :: (datetime | date)) :: (LONG)`
Restituisce il numero `day` del mese da un valore or. `datetime` `date` Per`datetime`: i valori vengono normalizzati in UTC in base all'input prima dell'estrazione del giorno. Per`date`: il giorno viene estratto in base al fuso orario.
L'`datetime`input è disponibile sia in Neptune Database che in Neptune Analytics:
```
RETURN day(datetime('2021-06-03T01:48:14Z'))
{
"results": [{
"day(datetime('2021-06-03T01:48:14Z'))": 3
}]
}
```
Qui, `datetime` è normalizzato all'UTC, quindi \$1 08:00 torna al 2 giugno.
```
RETURN day(datetime('2021-06-03T00:00:00+08:00'))
{
"results": [{
"day(datetime('2021-06-03T00:00:00+08:00'))": 2
}]
}
```
L'`date`input è disponibile solo in Neptune Analytics:
```
RETURN day(date('2021-06-03Z'))
{
"results": [{
"day(date('2021-06-03Z'))": 3
}]
}
```
Il fuso orario di `date` Preserve, mantiene il 3 giugno.
```
RETURN day(date('2021-06-03+08:00'))
{
"results": [{
"day(date('2021-06-03+08:00'))": 3
}]
}
```
### mese
`month(temporal :: (datetime | date)) :: (LONG)`
Restituisce il mese da un `date` valore `datetime` or (1-12). Per`datetime`: i valori vengono normalizzati in UTC in base all'input prima dell'estrazione del mese. Per`date`: il mese viene estratto in base al fuso orario.
L'`datetime`input è disponibile sia in Neptune Database che in Neptune Analytics:
```
RETURN month(datetime('2021-06-03T01:48:14Z'))
{
"results": [{
"month(datetime('2021-06-03T01:48:14Z'))": 6
}]
}
```
Qui, `datetime` è normalizzato all'UTC, quindi \$1 08:00 torna al 31 maggio.
```
RETURN month(datetime('2021-06-01T00:00:00+08:00'))
{
"results": [{
"month(datetime('2021-06-01T00:00:00+08:00'))": 5
}]
}
```
L'`date`input è disponibile solo in Neptune Analytics:
```
RETURN month(date('2021-06-03Z'))
{
"results": [{
"month(date('2021-06-03Z'))": 6
}]
}
```
Il fuso orario di `date` Preserve, mantiene il 1° giugno.
```
RETURN month(date('2021-06-01+08:00'))
{
"results": [{
"month(date('2021-06-01+08:00'))": 6
}]
}
```
### anno
`year(temporal :: (datetime | date)) :: (LONG)`
Restituisce l'anno da un `datetime` valore or. `date` Per`datetime`: i valori vengono normalizzati in UTC in base all'input prima dell'estrazione dell'anno. Per`date`: l'anno viene estratto in base al fuso orario.
L'`datetime`input è disponibile sia in Neptune Database che in Neptune Analytics:
```
RETURN year(datetime('2021-06-03T01:48:14Z'))
{
"results": [{
"year(datetime('2021-06-03T01:48:14Z'))": 2021
}]
}
```
Qui, `datetime` è normalizzato in UTC, quindi \$1 08:00 torna al 31 dicembre 2020.
```
RETURN year(datetime('2021-01-01T00:00:00+08:00'))
{
"results": [{
"year(datetime('2021-01-01T00:00:00+08:00'))": 2020
}]
}
```
L'`date`input è disponibile solo in Neptune Analytics:
```
RETURN year(date('2021-06-03Z'))
{
"results": [{
"year(date('2021-06-03Z'))": 2021
}]
}
```
Il fuso orario di `date` Preserve, mantiene giugno 2021.
```
RETURN year(date('2021-01-01+08:00'))
{
"results": [{
"year(date('2021-01-01+08:00'))": 2021
}]
}
```
### Funzioni OpenCypher di Neptune
Disponibile in Neptune Database 1.4.6.0 e versioni successive e Neptune Analytics.
#### ridurre ()
Reduce elabora in sequenza ogni elemento dell'elenco combinandolo con un totale corrente o «accumulatore». A partire da un valore iniziale, aggiorna l'accumulatore dopo ogni operazione e utilizza quel valore aggiornato nell'iterazione successiva.
`for i in (0, ..., n) acc = acc X list[I], where X denotes any binary operator`
Una volta che tutti gli elementi sono stati elaborati, restituisce il risultato finale accumulato.
Una tipica struttura reduce () sarebbe - `reduce(accumulator = initial , variable IN list | expression)`
**Specifiche del tipo:**
`- 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 `
**Limitazioni:**
Attualmente, l'`reduce()`espressione supporta solo:
+ Moltiplicazione numerica
+ Addizione numerica
+ Concatenamento di stringhe
+ Concatenazione di elenchi
Sono rappresentati dall'operatore or. `+` `*` L'espressione deve essere un'espressione binaria come specificato di seguito - `expression pattern: accumulator + any variable or accumulator * any variable`
**Gestione dell'overflow:**
Neptune rileva l'overflow numerico durante la valutazione e risponde in modo diverso in `reduce()` base al tipo di dati:
```
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.
```
**Esempi:**
Vedi i seguenti esempi per la funzione 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
}]
}
```