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à. # Conformità alle specifiche OpenCypher in Amazon Neptune Il rilascio di Amazon Neptune di openCypher supporta generalmente le clausole, gli operatori, le espressioni, le funzioni e la sintassi definiti nella specifica openCypher corrente, ovvero [Cypher Query Language Reference versione 9](https://s3.amazonaws.com/artifacts.opencypher.org/openCypher9.pdf). Le limitazioni e le differenze nel supporto di Neptune per openCypher sono indicate di seguito. Amazon Neptune supporta anche diverse funzionalità oltre all'ambito delle specifiche OpenCypher. Fare riferimento a [Estensioni OpenCypher in Amazon Neptune](access-graph-opencypher-extensions.md) per ulteriori dettagli. **Nota** L'attuale implementazione Neo4j di Cypher contiene funzionalità che non sono contenute nella specifica openCypher menzionata sopra. Se stai migrando il codice Cypher corrente a Neptune, consulta [Compatibilità di Neptune con Neo4j](migration-compatibility.md) e [Riscrittura delle query Cypher da eseguire in openCypher su Neptune](migration-opencypher-rewrites.md) per ulteriori informazioni. ## Supporto delle clausole openCypher in Neptune Neptune supporta le seguenti clausole, ad eccezione di quanto indicato: + `MATCH`: supportata, ad eccezione di *`shortestPath()`* e *`allShortestPaths()`* che non sono attualmente supportate. + `OPTIONAL MATCH` + *`MANDATORY MATCH`*: **non** è attualmente supportata in Neptune. Neptune, tuttavia, supporta [valori ID personalizzati](access-graph-opencypher-extensions.md#opencypher-compliance-custom-ids) nelle query `MATCH`. + `RETURN`: supportata, tranne quando viene utilizzata con valori non statici per `SKIP`o `LIMIT`. Ad esempio, quanto segue attualmente non funziona: ``` MATCH (n) RETURN n LIMIT toInteger(rand()) // Does NOT work! ``` + `WITH`: supportata, tranne quando viene utilizzata con valori non statici per `SKIP`o `LIMIT`. Ad esempio, quanto segue attualmente non funziona: ``` 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 consente di creare [valori ID personalizzati](access-graph-opencypher-extensions.md#opencypher-compliance-custom-ids) nelle query `CREATE`. + `DELETE` + `SET` + `REMOVE` + `MERGE`: Neptune supporta [valori ID personalizzati](access-graph-opencypher-extensions.md#opencypher-compliance-custom-ids) nelle query `MERGE`. + *`CALL[YIELD...]`*: **non** è attualmente supportata in Neptune. + `UNION, UNION ALL`: le query di sola lettura sono supportate, ma le query di mutazione **non** sono attualmente supportate. + `USING`[— `USING` è supportato dalla versione 1.3.2.0 del motore.](https://docs.aws.amazon.com//neptune/latest/userguide/engine-releases-1.3.2.0.html) Per ulteriori informazioni, vedere [Query hints](https://docs.aws.amazon.com//neptune/latest/userguide/opencypher-query-hints.html). ## Supporto degli operatori openCypher in Neptune Neptune supporta i seguenti operatori, ad eccezione di quanto indicato: **Operatori generali** + `DISTINCT` + Operatore `.` per accedere alle proprietà di una mappa letterale annidata. **Operatori matematici** + Operatore di addizione `+`. + Operatore di sottrazione `-`. + Operatore di moltiplicazione `*`. + Operatore di divisione `/`. + Operatore di divisione modulo `%`. + L'operatore `^` di esponenziazione. *is NOT supported* **Operatori di confronto** + Operatore di addizione `=`. + Operatore di disuguaglianza `<>`. + L'operatore minore di `<` è supportato tranne quando uno degli argomenti è un percorso, un elenco o una mappa. + L'operatore maggiore di `>` è supportato tranne quando uno degli argomenti è un percorso, un elenco o una mappa. + L'operatore `<=` less-than-or-equal -to è supportato tranne quando uno degli argomenti è Path, List o Map. + L'operatore `>=` greater-than-or-equal -to è supportato tranne quando uno degli argomenti è Path, List o Map. + `IS NULL` + `IS NOT NULL` + `STARTS WITH` è supportato se i dati da cercare sono una stringa. + `ENDS WITH` è supportato se i dati da cercare sono una stringa. + `CONTAINS` è supportato se i dati da cercare sono una stringa. **Operatori booleani** + `AND` + `OR` + `XOR` + `NOT` **Operatori di stringa** + Operatore di concatenazione `+`. **Operatori di elenco** + Operatore di concatenazione `+`. + `IN` (verifica la presenza di un elemento nell'elenco) ## Supporto delle espressioni openCypher in Neptune Neptune supporta le seguenti espressioni, ad eccezione di quanto indicato: + `CASE` + L'espressione `[]` **non** è attualmente supportata in Neptune per l'accesso alle chiavi di proprietà calcolate dinamicamente all'interno di un nodo, una relazione o una mappa. Ad esempio, quanto segue non funziona: ``` MATCH (n) WITH [5, n, {key: 'value'}] AS list RETURN list[1].name ``` ## Supporto delle funzioni openCypher in Neptune Neptune supporta le seguenti funzioni, ad eccezione di quanto indicato: **Funzioni di predicato** + `exists()` **Funzioni scalari** + `coalesce()` + `endNode()` + `epochmillis()` + `head()` + `id()` + `last()` + `length()` + `randomUUID()` + `properties()` + `removeKeyFromMap` + `size()`: questo metodo di overload attualmente funziona solo per espressioni di modelli, elenchi e stringhe + `startNode()` + `timestamp()` + `toBoolean()` + `toFloat()` + `toInteger()` + `type()` **Funzioni di aggregazione** + `avg()` + `collect()` + `count()` + `max()` + `min()` + `percentileDisc()` + `stDev()` + `percentileCont()` + `stDevP()` + `sum()` **Elencare le funzioni** + [`join()`](access-graph-opencypher-extensions.md#opencypher-compliance-join-function) (concatena le stringhe di un elenco in un'unica stringa) + `keys()` + `labels()` + `nodes()` + `range()` + `relationships()` + `reverse()` + `tail()` **Funzioni matematiche – numeriche** + `abs()` + `ceil()` + `floor()` + `rand()` + `round()` + `sign()` **Funzioni matematiche – logaritmiche** + `e()` + `exp()` + `log()` + `log10()` + `sqrt()` **Funzioni matematiche – trigonometriche** + `acos()` + `asin()` + `atan()` + `atan2()` + `cos()` + `cot()` + `degrees()` + `pi()` + `radians()` + `sin()` + `tan()` **Funzioni stringa** + [`join()`](access-graph-opencypher-extensions.md#opencypher-compliance-join-function) (concatena le stringhe di un elenco in un'unica stringa) + `left()` + `lTrim()` + `replace()` + `reverse()` + `right()` + `rTrim()` + `split()` + `substring()` + `toLower()` + `toString()` + `toUpper()` + `trim()` **Funzioni definite dall'utente** *User-defined functions***non** sono attualmente supportati in Neptune. ## Dettagli sull'implementazione di openCypher specifici per Neptune Le sezioni seguenti descrivono i modi in cui l'implementazione di openCypher in Neptune può differire o andare oltre la [specifica openCypher](https://s3.amazonaws.com/artifacts.opencypher.org/openCypher9.pdf). ### Valutazioni di percorsi a lunghezza variabile (VLP) in Neptune Le valutazioni dei percorsi a lunghezza variabile (`VLP`) rilevano i percorsi tra i nodi del grafo. La lunghezza del percorso può essere illimitata in una query. Per evitare cicli, la [specifica openCypher](https://s3.amazonaws.com/artifacts.opencypher.org/openCypher9.pdf) specifica che ogni arco deve essere attraversato al massimo una volta per soluzione. Infatti VLPs, l'implementazione di Neptune si discosta dalla specifica OpenCypher in quanto supporta solo valori costanti per i filtri di uguaglianza delle proprietà. Eseguire la seguente query: ``` MATCH (x)-[:route*1..2 {dist:33, code:x.name}]->(y) return x,y ``` Poiché il valore del filtro di uguaglianza della proprietà `x.name` non è una costante, questa query restituisce l'eccezione `UnsupportedOperationException` con il messaggio: `Property predicate over variable-length relationships with non-constant expression is not supported in this release.` ### Supporto temporale nell'implementazione di Neptune OpenCypher (database Neptune 1.3.1.0 e versioni successive) Neptune attualmente fornisce un supporto limitato per la funzione temporale in openCypher. Supporta il tipo di dati `DateTime` per i tipi temporali. La funzione `datetime()` può essere utilizzata per ottenere la data e l'ora UTC correnti in questo modo: ``` RETURN datetime() as res ``` I valori di data e ora possono essere analizzati da stringhe in formato `"`*date*`T`*time*`"` in cui *data* e *ora* sono entrambe espresse in uno dei formati supportati di seguito: **Formati di data supportati** + `yyyy-MM-dd` + `yyyyMMdd` + `yyyy-MM` + `yyyy-DDD` + `yyyyDDD` + `yyyy` **Formati di ora supportati** + `HH:mm:ssZ` + `HHmmssZ` + `HH:mm:ssZ` + `HH:mmZ` + `HHmmZ` + `HHZ` + `HHmmss` + `HH:mm:ss` + `HH:mm` + `HHmm` + `HH` Esempio: ``` RETURN datetime('2022-01-01T00:01') // or another example: RETURN datetime('2022T0001') ``` Nota che tutti i date/time valori in Neptune OpenCypher vengono archiviati e recuperati come valori UTC. Neptune openCypher utilizza un orologio `statement`, il che significa che lo stesso istante di tempo viene utilizzato per tutta la durata di una query. Una query diversa all'interno della stessa transazione può utilizzare un istante di tempo diverso. Neptune non supporta l'uso di una funzione all'interno di una chiamata a `datetime()`. Ad esempio, quanto segue non funziona: ``` CREATE (:n {date:datetime(tostring(2021))}) // ---> NOT ALLOWED! ``` Neptune supporta la funzione `epochmillis()` che converte `datetime` in `epochmillis`. Esempio: ``` MATCH (n) RETURN epochMillis(n.someDateTime) 1698972364782 ``` Neptune attualmente non supporta altre funzioni e operazioni sugli oggetti `DateTime`, come l'addizione e la sottrazione. ### Supporto temporale nell'implementazione di Neptune OpenCypher (Neptune Analytics e Neptune Database 1.3.2.0 e versioni successive) La seguente funzionalità datetime OpenCypher si applica a Neptune Analytics. In alternativa, è possibile utilizzare il parametro labmode `DatetimeMillisecond=enabled` per abilitare la seguente funzionalità datetime nella versione 1.3.2.0 e successive del motore Neptune. Per maggiori dettagli sull'utilizzo di questa funzionalità in labmode, consulta. [Supporto datetime esteso](features-lab-mode.md#labmode-extended-datetime-support) + Support per millisecondi. Il valore letterale Datetime verrà sempre restituito in millisecondi, anche se i millisecondi sono 0. (Il comportamento precedente consisteva nel troncare i millisecondi.) ``` 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 per chiamare la funzione datetime () su proprietà memorizzate o risultati intermedi. Ad esempio, le seguenti interrogazioni non erano possibili prima di questa funzionalità. Datetime () sulle proprietà: ``` // 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 () su risultati intermedi: ``` // Parse datetime from parameter UNWIND $list as myDate RETURN datetime(myDate) as d ``` + Ora è anche possibile salvare le proprietà datetime che vengono create nei casi sopra menzionati. Salvare datetime dalla proprietà string di una proprietà a un'altra: ``` // 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) ``` Batch crea nodi da un parametro con una proprietà 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 per un sottoinsieme più ampio di formati ISO8601 datetime. Consulta qui di seguito. Formati supportati Il formato di un valore datetime è [Date] T [Time] [Timezone], dove T è il separatore. Se non viene fornito un fuso orario esplicito, si presume che UTC (Z) sia l'impostazione predefinita. Fuso orario I formati di fuso orario supportati sono: + \$1/-HH: mm + \$1/-HHmm + \$1/-H La presenza di un fuso orario in una stringa datetime è facoltativa. Se l'offset del fuso orario è 0, è possibile utilizzare Z al posto del suffisso del fuso orario riportato sopra per indicare l'ora UTC. L'intervallo supportato di un fuso orario va da - 14:00 a \$1 14:00. Data Se non è presente alcun fuso orario o se il fuso orario è UTC (Z), i formati di data supportati sono i seguenti: **Nota** DDD si riferisce a una data ordinale, che rappresenta un giorno dell'anno compreso tra 001 e 365 (366 negli anni bisestili). Ad esempio, 2024-002 rappresenta il 2 gennaio 2024. + `yyyy-MM-dd` + `yyyyMMdd` + `yyyy-MM` + `yyyyMM` + `yyyy-DDD` + `yyyyDDD` + `yyyy` Se viene scelto un fuso orario diverso da Z, i formati di data supportati sono limitati ai seguenti: + `yyyy-MM-dd` + `yyyy-DDD` + `yyyyDDD` L'intervallo di date supportato va dal 1400-01-01 al 9999-12-31. Orario Se non è presente alcun fuso orario o se il fuso orario è UTC (Z), i formati di ora supportati sono: + `HH:mm:ss.SSS` + `HH:mm:ss` + `HHmmss.SSS` + `HHmmss` + `HH:mm` + `HHmm` + `HH` Se viene scelto un fuso orario diverso da Z, i formati di ora supportati sono limitati ai seguenti: + `HH:mm:ss` + `HH:mm:ss.SSS` ### Differenze nella semantica del linguaggio openCypher di Neptune Neptune rappresenta il nodo e la IDs relazione come stringhe anziché numeri interi. L'ID è uguale all'ID fornito tramite lo strumento di caricamento in blocco di dati. Se esiste uno spazio dei nomi per la colonna, lo spazio dei nomi più l'ID. Di conseguenza, la funzione `id` restituisce una stringa anziché un numero intero. Il tipo di dati `INTEGER` è limitato a 64 bit. Quando si convertono valori a virgola mobile o stringa più grandi in un numero intero utilizzando la funzione `TOINTEGER`, i valori negativi vengono troncati a `LLONG_MIN` e i valori positivi vengono troncati a `LLONG_MAX`. Esempio: ``` RETURN TOINTEGER(2^100) > 9223372036854775807 RETURN TOINTEGER(-1 * 2^100) > -9223372036854775808 ``` ### Proprietà multivalore Sebbene OpenCypher CREATE non crei proprietà multivalore, possono esistere nei dati creati utilizzando Gremlin (Neptune Database) o durante il caricamento dei dati (Neptune Database e Neptune Analytics). Se Neptune openCypher incontra una proprietà multivalore, uno dei valori viene scelto arbitrariamente, creando un risultato non deterministico. ### Gestione dei valori NaN La gestione da parte di Neptune del confronto dei valori delle `NaN` proprietà non è definita. Basarsi su tali confronti può portare a risultati inaspettati o non deterministici.