Clausole Operatori Espressioni Funzioni Differenze di Neptune openCypher

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. 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 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 e Riscrittura delle query Cypher da eseguire in openCypher su Neptune 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 nelle query MATCH.
RETURN: supportata, tranne quando viene utilizzata con valori non statici per SKIPo 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 SKIPo 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 nelle query CREATE.
DELETE
SET
REMOVE
MERGE: Neptune supporta valori ID personalizzati 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. Per ulteriori informazioni, vedere Query hints.

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() (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() (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 functionsnon 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.

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 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 "dateTtime" 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

Per esempio:


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

Nota che tutti i valori di data/ora 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. Per 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

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 ISO86 01 formati 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:

+/-HH: mm
+/-HHmm
+/-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 + 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.

Per 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.

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Conformità agli standard SPARQL

Il modello di dati Graph