Clausole Operatori Espressioni Funzioni Differenze con Nettuno openCypher

openCypher conformità alle specifiche in Amazon Neptune

La versione openCypher di Amazon Neptune supporta generalmente le clausole, gli operatori, le espressioni, le funzioni e la sintassi definite nella specifica openCypher corrente, ovvero la versione 9 di riferimento del linguaggio di riferimento Cypher Query. Le limitazioni e le differenze nel supporto openCypher per Neptune sono indicate di seguito.

Nota

L'attuale implementazione Neo4j di Cypher contiene funzionalità che non sono contenute nelle specifiche sopra menzionate. openCypher 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.

Support per le openCypher clausole in Neptune

Neptune supporta le seguenti clausole, ad eccezione di quanto indicato:

MATCH— Supportato, tranne che shortestPath() e allShortestPaths() non sono attualmente supportati.
OPTIONAL MATCH
MANDATORY MATCH — non è attualmente supportato 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 supportato 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.

Support per openCypher gli operatori di 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)

Support per openCypher le espressioni 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
```

Support per openCypher le funzioni di 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 functions non sono attualmente supportati in Neptune.

Dettagli di implementazione specifici per Neptune openCypher

Le sezioni seguenti descrivono i modi in cui l'implementazione openCypher di Neptune può differire o andare oltre le specifiche. openCypher

Valutazioni del percorso 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 specifica openCypher specifica che ogni spigolo deve essere attraversato al massimo una volta per soluzione.

InfattiVLPs, l'implementazione di Neptune si discosta dalle openCypher specifiche 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 (database openCypher 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 datetime() funzione può essere utilizzata per ottenere la UTC data e l'ora 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

openCypher Neptune utilizza statement un orologio, 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, puoi 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

DDDsi 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 è (Z), i formati di ora supportati sono: UTC

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 di openCypher Nettuno

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

Funzione `join()` specifica di Neptune

Neptune implementa join() una funzione che non è presente nelle specifiche. 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

Neptune implementa removeKeyFromMap() una funzione che non è presente nelle specifiche. 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. Per 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

A partire dalla versione 1.2.0.2 del motore, Neptune ha esteso le openCypher specifiche in modo che ora sia possibile specificare id i valori per i nodi e le relazioni nelle clausole e,. CREATE MERGE MATCH Ciò consente di assegnare stringhe intuitive anziché quelle generate dal sistema per identificare nodi e relazioni. UUIDs

avvertimento

Questa estensione della openCypher specifica è incompatibile con le versioni precedenti, perché ~id ora è considerata 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à.

Ecco un esempio che mostra come creare nodi e relazioni personalizzati: IDS


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 la versione 1.2.0.2 del motore, la ~id chiave nelle openCypher clausole viene ora trattata come id anziché come una 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à '~id' nella proprietà 'newId',
e rimuove la proprietà '~id' 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

Altre differenze tra openCypher Neptune e Cypher

Neptune TCP supporta solo connessioni per il protocollo Bolt. WebSocketsle connessioni per Bolt non sono supportate.
openCypher Neptune rimuove gli spazi bianchi come definito da Unicode nelle funzioni e. trim() ltrim() rtrim()
In openCypher Neptunetostring(, il ) doppio non passa automaticamente alla notazione E per valori elevati del doppio.
Sebbene openCypher CREATE non crei proprietà multivalore, esse possono esistere nei dati creati utilizzando Gremlin. Se openCypher Neptune 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

SPARQLconformità agli standard

Il modello di dati Graph

openCypher conformità alle specifiche in Amazon Neptune

Nota

Support per le openCypher clausole in Neptune

Support per openCypher gli operatori di Neptune

Operatori generali

Operatori matematici

Operatori di confronto

Operatori booleani

Operatori di stringa

Operatori di elenco

Support per openCypher le espressioni in Neptune

Support per openCypher le funzioni di Neptune

Funzioni di predicato

Funzioni scalari

Funzioni di aggregazione

Elencare le funzioni

Funzioni matematiche – numeriche

Funzioni matematiche – logaritmiche

Funzioni matematiche – trigonometriche

Funzioni stringa

Dettagli di implementazione specifici per Neptune openCypher

Valutazioni del percorso a lunghezza variabile (VLP) in Neptune

Supporto temporale nell'implementazione di Neptune (database openCypher Neptune 1.3.1.0 e versioni successive)

Formati di data supportati

Formati di ora supportati

Supporto temporale nell'implementazione di Neptune ( openCypher Neptune Analytics e Neptune Database 1.3.2.0 e versioni successive)

Nota

Differenze nella semantica del linguaggio di openCypher Nettuno

Funzione join() specifica di Neptune

Funzione removeKeyFromMap() specifica di Neptune

Valori ID personalizzati per le proprietà dei nodi e delle relazioni

avvertimento

Cosa fare se attualmente si utilizza ~id come proprietà

Altre differenze tra openCypher Neptune e Cypher

Funzione `join()` specifica di Neptune

Funzione `removeKeyFromMap()` specifica di Neptune

Cosa fare se attualmente si utilizza `~id` come proprietà