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 delle specifiche OpenCypher 9. Fai riferimento a Conformità alle specifiche OpenCypher in Amazon Neptune in Amazon Neptune per maggiori dettagli. 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.
Query-time Accesso ai dati S3
Disponibile in Neptune Database 1.4.7.0 e versioni successive.
Neptune supporta neptune.read() 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'interrogazione, neptune.read() accede ai dati di Amazon S3 al momento dell'esecuzione della query.
Per una documentazione completa, consulta neptune.read ().
Il Neptune-specific unisciti () funzione
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"
Il Neptune-specific rimuovereKeyFromMap() funzione
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. Ad 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, 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é UUID generati dal sistema per identificare nodi e relazioni.
In Neptune Analytics, i valori ID personalizzati non sono disponibili per i bordi.
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. Consulta Cosa fare se al momento stai utilizzando ~id come proprietà.
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 ID personalizzati in una clausola MERGE:
MATCH (n {name: 'john'}), (m {name: 'jim'}) MERGE (n)-[r {`~id`: 'john->jim'}]->(m) RETURN r
Cosa fare se al momento stai utilizzando ~id come proprietà
Con il rilascio 1.2.0.2 del motore, 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à '~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
Supporto per le sottoquery CALL in Neptune
Disponibile in Neptune Database 1.4.1.0 e versioni successive e Neptune Analytics.
Amazon Neptune supporta CALL sottoquery. A CALL la sottoquery è una parte della query principale che viene eseguita in un ambito isolato per ogni input di CALL sottoquery.
Ad esempio, supponiamo che un grafico contenga dati sulle persone, sui loro amici e sulle città in cui vivevano. Possiamo recuperare le due città più grandi in cui viveva ogni amico di qualcuno utilizzando un 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 della query all'interno CALL { ... } viene eseguito per ogni friend a cui corrisponde la precedente clausola MATCH. Quando viene eseguita la query interna, ORDER e LIMIT le clausole si riferiscono alle città in cui viveva un determinato amico, quindi otteniamo (al massimo) due città per amico.
Tutte le clausole di interrogazione sono disponibili all'interno CALL sottointerrogazioni. Questo include nested CALL anche sottointerrogazioni. Alcune restrizioni per la prima WITH la clausola e le variabili emesse esistono e sono spiegate di seguito.
Ambito delle variabili all'interno della sottoquery CALL
Le variabili delle clausole precedenti a CALL la sottoquery utilizzata al suo interno deve essere importata con l'iniziale WITH clausola. A differenza del normale WITH clausole che può contenere solo un elenco di variabili ma non consente l'aliasing e non può essere utilizzato insieme a DISTINCT, ORDER BY, WHERE, SKIP, o LIMIT.
Variabili restituite dalla sottoquery CALL
Le variabili che vengono emesse da CALL la sottoquery viene specificata con la finale RETURN clausola. Nota che le variabili emesse non possono sovrapporsi alle variabili precedenti CALL sottoquery.
Limitazioni
A partire da ora, si aggiorna all'interno di un CALL le sottoquery non sono supportate.
funzioni Neptune OpenCypher
Disponibile in Neptune Database 1.4.1.0 e versioni successive e Neptune Analytics.
testoIndexOf
textIndexOf(text :: STRING, lookup :: STRING, from = 0 :: INTEGER?, to = -1 :: INTEGER?) :: (INTEGER?)
Restituisce l'indice della prima occorrenza di lookup nell'intervallo di text a partire dall'offset from (incluso), tramite offset to (esclusivo). 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 univoci dell'elenco originale. L'ordine dell'elenco originale è mantenuti (ad es. [1, 6, 5, 1, 5] restituisce [1, 6, 5]).
RETURN collToSet([1, 6, 5, 1, 1, 5]) { "results": [{ "collToSet([1, 6, 5, 1, 1, 5])": [1, 6, 5] }] }
Colla/sottrai
collSubtract(first :: LIST OF ANY?, second :: LIST OF ANY?) :: (LIST? OF ANY?)
Restituisce un nuovo elenco contenente tutti gli elementi univoci di first escludendo elementi da second.
RETURN collSubtract([2, 5, 1, 0], [1, 5]) { "results": [{ "collSubtract([2, 5, 1, 0], [1, 5])": [0, 2] }] }
Sezione Collinter
collIntersection(first :: LIST? OF ANY?, second :: LIST? OF ANY?) :: (LIST? OF ANY?)
Restituisce un nuovo elenco contenente tutti gli elementi univoci dell'intersezione di first e second.
RETURN collIntersection([2, 5, 1, 0], [1, 5]) { "results": [{ "collIntersection([2, 5, 1, 0], [1, 5])": [1, 5] }] }
Funzioni di ordinamento
Le sezioni seguenti definiscono le funzioni per ordinare le raccolte. Queste funzioni richiedono (in alcuni casi facoltative) config argomenti della 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 }
Qui key è una proprietà della mappa o del nodo il cui valore deve essere utilizzato per l'ordinamento. order è o»asc«o»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 di coll lista 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 specificato key proprietà.
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 specificato key proprietà, applicando opzionalmente 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 di coll elenco di input, ordinando gli elementi del nodo in base ai rispettivi valori key proprietà.
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 nella versione Neptune 1.4.5.0 e fino.
giorno
day(temporal :: (datetime | date)) :: (LONG)
Restituisce il day del mese a partire da un datetime o date valore. Per datetime: i valori sono normalizzati in UTC in base all'input prima dell'estrazione del giorno. Per date: il giorno viene estratto in base al fuso orario.
Il datetime l'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, il datetime è normalizzato all'UTC, quindi + 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 }] }
Il date l'input è disponibile solo in Neptune Analytics:
RETURN day(date('2021-06-03Z')) { "results": [{ "day(date('2021-06-03Z'))": 3 }] }
Il date conserva il fuso orario, mantenendo 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 datetime o date valore (1-12). Per datetime: i valori sono normalizzati in UTC in base all'input prima dell'estrazione del mese. Per date: il mese viene estratto in base al fuso orario.
Il datetime l'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, il datetime è normalizzato all'UTC, quindi + 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 }] }
Il date l'input è disponibile solo in Neptune Analytics:
RETURN month(date('2021-06-03Z')) { "results": [{ "month(date('2021-06-03Z'))": 6 }] }
Il date conserva il fuso orario, mantenendo 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 a datetime o date valore. Per datetime: i valori sono normalizzati all'UTC in base all'input prima dell'estrazione dell'anno. Per date: l'anno viene estratto in base al fuso orario.
Il datetime l'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, il datetime è normalizzato all'UTC, quindi + 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 }] }
Il date l'input è disponibile solo in Neptune Analytics:
RETURN year(date('2021-06-03Z')) { "results": [{ "year(date('2021-06-03Z'))": 2021 }] }
Il date conserva il fuso orario, mantenendo giugno 2021.
RETURN year(date('2021-01-01+08:00')) { "results": [{ "year(date('2021-01-01+08:00'))": 2021 }] }
Funzioni Neptune OpenCypher
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 progressivo o «accumulatore». Partendo 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, il reduce() l'espressione supporta solo:
-
Moltiplicazione numerica
-
Addizione numerica
-
Concatenamento di stringhe
-
Concatenazione di elenchi
Sono rappresentati da + o * operatore. 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 un overflow numerico durante reduce() valutazione e risponde in modo diverso in 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:
Vedete 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 }] }