Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Ekstensi OpenCypher di Amazon Neptunus
Amazon Neptunus mendukung referensi spesifikasi OpenCypher versi 9. Silakan lihat [Kepatuhan spesifikasi OpenCypher di Amazon Neptunus](feature-opencypher-compliance.md) di Amazon Neptunus untuk detailnya. Selain itu, Amazon Neptunus mendukung fitur yang tercantum di sini. Kecuali versi tertentu disebutkan, fitur-fiturnya tersedia di Database Neptunus dan Neptunus Analytics.
## Query-time Akses data S3
Tersedia dalam Database Neptunus 1.4.7.0 dan yang lebih tinggi.
Neptunus mendukung `neptune.read()` fungsi untuk membaca data CSV atau Parket dari Amazon S3 langsung dalam kueri OpenCypher. Tidak seperti pemuat massal yang mengimpor data sebelum melakukan kueri, `neptune.read()` mengakses data Amazon S3 pada waktu eksekusi kueri.
Untuk dokumentasi lengkap, lihat[neptune.read ()](access-graph-opencypher-21-extensions-s3-read.md).
## Fungsi Neptune-specific `join ()`
Tersedia dalam Database Neptunus dan Neptunus Analytics.
Neptunus mengimplementasikan fungsi `join()` yang tidak ada dalam spesifikasi OpenCypher. Ini menciptakan string literal dari daftar literal string dan pembatas string. Dibutuhkan dua argumen:
+ Argumen pertama adalah daftar literal string.
+ Argumen kedua adalah string pembatas, yang dapat terdiri dari nol, satu, atau lebih dari satu karakter.
Contoh:
```
join(["abc", "def", "ghi"], ", ") // Returns "abc, def, ghi"
```
## Fungsi Neptune-specific `remove KeyFromMap ()`
Tersedia dalam Database Neptunus dan Neptunus Analytics.
Neptunus mengimplementasikan fungsi `removeKeyFromMap()` yang tidak ada dalam spesifikasi OpenCypher. Ini menghapus kunci tertentu dari peta dan mengembalikan peta baru yang dihasilkan.
Fungsi ini membutuhkan dua argumen:
+ Argumen pertama adalah peta untuk menghapus kunci.
+ Argumen kedua adalah kunci untuk menghapus dari peta.
`removeKeyFromMap()`Fungsi ini sangat berguna dalam situasi di mana Anda ingin menetapkan nilai untuk node atau hubungan dengan membuka daftar peta. Contoh:
```
UNWIND [{`~id`: 'id1', name: 'john'}, {`~id`: 'id2', name: 'jim'}] as val
CREATE (n {`~id`: val.`~id`})
SET n = removeKeyFromMap(val, '~id')
```
## Nilai ID kustom untuk properti node dan hubungan
Tersedia dalam Database Neptunus 1.2.0.2 dan lebih tinggi, dan Neptunus Analytics.
Mulai [rilis mesin 1.2.0.2](engine-releases-1.2.0.2.md), Neptunus telah memperluas spesifikasi OpenCypher sehingga Anda sekarang dapat menentukan `id` nilai untuk node dan hubungan di,, dan klausa. `CREATE` `MERGE` `MATCH` Ini memungkinkan Anda menetapkan string yang ramah pengguna alih-alih UUID yang dihasilkan sistem untuk mengidentifikasi node dan hubungan.
Di Neptunus Analytics, nilai id kustom tidak tersedia untuk tepi.
**Awas**
Ekstensi ke spesifikasi OpenCypher ini tidak kompatibel ke belakang, karena sekarang `~id` dianggap sebagai nama properti yang dicadangkan. Jika Anda sudah menggunakan `~id` sebagai properti dalam data dan kueri, Anda harus memigrasikan properti yang ada ke kunci properti baru dan menghapus yang lama. Lihat [Apa yang harus dilakukan jika saat ini Anda menggunakan `~id` sebagai properti](#opencypher-compliance-custom-ids-migrating).
Berikut adalah contoh yang menunjukkan cara membuat node dan relasi yang memiliki ID kustom:
```
CREATE (n {`~id`: 'fromNode', name: 'john'})
-[:knows {`~id`: 'john-knows->jim', since: 2020}]
->(m {`~id`: 'toNode', name: 'jim'})
```
Jika Anda mencoba membuat ID khusus yang sudah digunakan, Neptunus akan membuat kesalahan. `DuplicateDataException`
Berikut adalah contoh penggunaan ID kustom dalam `MATCH` klausa:
```
MATCH (n {`~id`: 'id1'})
RETURN n
```
Berikut adalah contoh penggunaan ID kustom dalam `MERGE` klausa:
```
MATCH (n {name: 'john'}), (m {name: 'jim'})
MERGE (n)-[r {`~id`: 'john->jim'}]->(m)
RETURN r
```
### Apa yang harus dilakukan jika saat ini Anda menggunakan `~id` sebagai properti
Dengan [rilis mesin 1.2.0.2](engine-releases-1.2.0.2.md), `~id` kunci dalam klausa OpenCypher sekarang diperlakukan sebagai pengganti sebagai properti. `id` Ini berarti bahwa jika Anda memiliki properti bernama`~id`, mengaksesnya menjadi tidak mungkin.
Jika Anda menggunakan `~id` properti, yang harus Anda lakukan sebelum memutakhirkan ke rilis mesin `1.2.0.2` atau di atasnya adalah terlebih dahulu memigrasikan `~id` properti yang ada ke kunci properti baru, lalu menghapus properti tersebut`~id`. Misalnya, kueri di bawah ini:
+ Menciptakan properti baru bernama 'NewId' untuk semua node,
+ menyalin nilai properti '\~id' ke properti 'NewId',
+ dan menghapus properti '\~id' dari data
```
MATCH (n)
WHERE exists(n.`~id`)
SET n.newId = n.`~id`
REMOVE n.`~id`
```
Hal yang sama perlu dilakukan untuk setiap hubungan dalam data yang memiliki `~id` properti.
Anda juga harus mengubah kueri apa pun yang Anda gunakan sebagai referensi `~id` properti. Misalnya, kueri ini:
```
MATCH (n)
WHERE n.`~id` = 'some-value'
RETURN n
```
... akan berubah menjadi ini:
```
MATCH (n)
WHERE n.newId = 'some-value'
RETURN n
```
## Dukungan subquery CALL di Neptunus
Tersedia dalam Database Neptunus 1.4.1.0 dan lebih tinggi, dan Neptunus Analytics.
Amazon Neptunus mendukung subkueri`CALL`. `CALL`Subquery adalah bagian dari query utama yang berjalan dalam lingkup terisolasi untuk setiap input ke `CALL` subquery.
Misalnya, grafik berisi data tentang orang, teman mereka, dan kota tempat mereka tinggal. Kita dapat mengambil dua kota terbesar tempat setiap teman seseorang tinggal dengan menggunakan `CALL` subquery:
```
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
```
Dalam contoh ini, bagian kueri di dalam `CALL { ... }` dijalankan untuk masing-masing `friend` yang dicocokkan dengan klausa MATCH sebelumnya. Ketika kueri batin dijalankan, `LIMIT` klausa `ORDER` dan bersifat lokal di kota-kota tempat seorang teman tertentu tinggal, jadi kami memperoleh (paling banyak) dua kota per teman.
Semua klausa kueri tersedia di dalam `CALL` subkueri. Ini termasuk `CALL` subquery bersarang juga. Beberapa batasan untuk `WITH` klausa pertama dan variabel yang dipancarkan ada dan dijelaskan di bawah ini.
### Lingkup variabel di dalam subquery CALL
Variabel dari klausa sebelum `CALL` subquery yang digunakan di dalamnya harus diimpor oleh klausa awal. `WITH` Tidak seperti `WITH` klausa reguler hanya dapat berisi daftar variabel tetapi tidak mengizinkan aliasing dan tidak dapat digunakan bersama dengan`DISTINCT`,,, `ORDER BY``WHERE`, `SKIP` atau. `LIMIT`
### Variabel dikembalikan dari CALL subquery
Variabel yang dipancarkan dari `CALL` subquery ditentukan dengan klausa akhir. `RETURN` Perhatikan bahwa variabel yang dipancarkan tidak dapat tumpang tindih dengan variabel sebelum subquery. `CALL`
### Batasan
Sampai sekarang, pembaruan di dalam `CALL` subquery tidak didukung.
## Fungsi Neptunus OpenCypher
Tersedia dalam Database Neptunus 1.4.1.0 dan lebih tinggi, dan Neptunus Analytics.
**teks IndexOf**
`textIndexOf(text :: STRING, lookup :: STRING, from = 0 :: INTEGER?, to = -1 :: INTEGER?) :: (INTEGER?)`
Mengembalikan indeks kejadian pertama `lookup` dalam kisaran `text` mulai dari offset `from` (inklusif), melalui offset `to` (eksklusif). Jika `to` -1, rentang berlanjut hingga akhir`text`. Pengindeksan berbasis nol, dan dinyatakan dalam nilai skalar Unicode (poin kode non-pengganti).
```
RETURN textIndexOf('Amazon Neptune', 'e')
{
"results": [{
"textIndexOf('Amazon Neptune', 'e')": 8
}]
}
```
**coll ToSet**
`collToSet(values :: LIST OF ANY?) :: (LIST? OF ANY?)`
Mengembalikan daftar baru yang hanya berisi elemen unik dari daftar asli. Urutan daftar asli **dipertahankan** (misalnya `[1, 6, 5, 1, 5]` pengembalian`[1, 6, 5]`).
```
RETURN collToSet([1, 6, 5, 1, 1, 5])
{
"results": [{
"collToSet([1, 6, 5, 1, 1, 5])": [1, 6, 5]
}]
}
```
**CollKurangi**
`collSubtract(first :: LIST OF ANY?, second :: LIST OF ANY?) :: (LIST? OF ANY?)`
Mengembalikan daftar baru yang berisi semua elemen unik dari `first` mengecualikan elemen dari`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?)`
Mengembalikan daftar baru yang berisi semua elemen unik dari persimpangan `first` dan`second`.
```
RETURN collIntersection([2, 5, 1, 0], [1, 5])
{
"results": [{
"collIntersection([2, 5, 1, 0], [1, 5])": [1, 5]
}]
}
```
## Fungsi penyortiran
Bagian berikut mendefinisikan fungsi untuk mengurutkan koleksi. Fungsi-fungsi ini mengambil (dalam beberapa kasus opsional) argumen `config` peta, atau daftar beberapa peta semacam itu, yang menentukan kunci pengurutan arah and/or pengurutan:
```
{ key: STRING, order: STRING }
```
Berikut `key` adalah properti map atau node yang nilainya akan digunakan untuk menyortir. `order`adalah "" atau `asc` "`desc`" (tidak peka huruf besar/kecil) untuk menentukan jenis naik atau turun, masing-masing. Secara default, penyortiran akan dilakukan dalam urutan menaik.
**CollSort**
`collSort(coll :: LIST OF ANY, config :: MAP?) :: (LIST? OF ANY?)`
Mengembalikan daftar diurutkan baru yang berisi unsur-unsur dari daftar `coll` masukan.
```
RETURN collSort([5, 3, 1], {order: 'asc'})
{
"results": [{
"collSort([5, 3, 1])": [1, 3, 5]
}]
}
```
**coll SortMaps**
`collSortMaps(coll :: LIST OF MAP, config :: MAP) :: (LIST? OF ANY?)`
Mengembalikan daftar peta diurutkan berdasarkan nilai `key` properti tertentu.
```
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"
}]
}]
}
```
**coll SortMulti**
```
collSortMulti(coll :: LIST OF MAP?,
configs = [] :: LIST OF MAP,
limit = -1 :: INTEGER?,
skip = 0 :: INTEGER?) :: (LIST? OF ANY?)
```
Mengembalikan daftar peta diurutkan berdasarkan nilai `key` properti tertentu, opsional menerapkan batas dan lewati.
```
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"
}]
}]
}
```
**coll SortNodes**
`collSortNodes(coll :: LIST OF NODE, config :: MAP) :: (LIST? OF NODE?)`
Mengembalikan versi diurutkan dari daftar `coll` masukan, mengurutkan elemen node dengan nilai-nilai `key` properti masing-masing.
```
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"
}
}]
}]
}
```
## Fungsi temporal
Fungsi temporal tersedia dari Neptunus [versi](https://docs.aws.amazon.com/releases/release-1.4.5.0.xml) 1.4.5.0 dan yang lebih tinggi.
### hari
`day(temporal :: (datetime | date)) :: (LONG)`
`day`Mengembalikan bulan dari `date` nilai `datetime` atau. Untuk`datetime`: nilai dinormalisasi ke UTC berdasarkan input sebelum mengekstraksi hari. Untuk`date`: hari diekstraksi berdasarkan zona waktu.
`datetime`Masukan tersedia di Database Neptunus dan Neptunus Analytics:
```
RETURN day(datetime('2021-06-03T01:48:14Z'))
{
"results": [{
"day(datetime('2021-06-03T01:48:14Z'))": 3
}]
}
```
Di sini, `datetime` dinormalisasi ke UTC, jadi \+ 08:00 bergeser kembali ke 2 Juni.
```
RETURN day(datetime('2021-06-03T00:00:00+08:00'))
{
"results": [{
"day(datetime('2021-06-03T00:00:00+08:00'))": 2
}]
}
```
`date`Masukan hanya tersedia di Neptunus Analytics:
```
RETURN day(date('2021-06-03Z'))
{
"results": [{
"day(date('2021-06-03Z'))": 3
}]
}
```
Zona waktu `date` mempertahankan, menjaga 3 Juni.
```
RETURN day(date('2021-06-03+08:00'))
{
"results": [{
"day(date('2021-06-03+08:00'))": 3
}]
}
```
### bulan
`month(temporal :: (datetime | date)) :: (LONG)`
Mengembalikan bulan dari `date` nilai `datetime` atau (1-12). Untuk`datetime`: nilai dinormalisasi ke UTC berdasarkan input sebelum mengekstraksi bulan. Untuk`date`: bulan diekstraksi berdasarkan zona waktu.
`datetime`Masukan tersedia di Database Neptunus dan Neptunus Analytics:
```
RETURN month(datetime('2021-06-03T01:48:14Z'))
{
"results": [{
"month(datetime('2021-06-03T01:48:14Z'))": 6
}]
}
```
Di sini, `datetime` dinormalisasi ke UTC, jadi \+ 08:00 bergeser kembali ke 31 Mei.
```
RETURN month(datetime('2021-06-01T00:00:00+08:00'))
{
"results": [{
"month(datetime('2021-06-01T00:00:00+08:00'))": 5
}]
}
```
`date`Masukan hanya tersedia di Neptunus Analytics:
```
RETURN month(date('2021-06-03Z'))
{
"results": [{
"month(date('2021-06-03Z'))": 6
}]
}
```
Zona waktu `date` mempertahankan, menjaga 1 Juni.
```
RETURN month(date('2021-06-01+08:00'))
{
"results": [{
"month(date('2021-06-01+08:00'))": 6
}]
}
```
### tahun
`year(temporal :: (datetime | date)) :: (LONG)`
Mengembalikan tahun dari `date` nilai `datetime` atau. Untuk`datetime`: nilai dinormalisasi ke UTC berdasarkan input sebelum mengekstraksi tahun. Untuk`date`: tahun diekstraksi berdasarkan zona waktu.
`datetime`Masukan tersedia di Database Neptunus dan Neptunus Analytics:
```
RETURN year(datetime('2021-06-03T01:48:14Z'))
{
"results": [{
"year(datetime('2021-06-03T01:48:14Z'))": 2021
}]
}
```
Di sini, `datetime` dinormalisasi ke UTC, jadi \+ 08:00 bergeser kembali ke 31 Desember 2020.
```
RETURN year(datetime('2021-01-01T00:00:00+08:00'))
{
"results": [{
"year(datetime('2021-01-01T00:00:00+08:00'))": 2020
}]
}
```
`date`Masukan hanya tersedia di Neptunus Analytics:
```
RETURN year(date('2021-06-03Z'))
{
"results": [{
"year(date('2021-06-03Z'))": 2021
}]
}
```
Zona waktu `date` mempertahankan, menjaga Juni 2021.
```
RETURN year(date('2021-01-01+08:00'))
{
"results": [{
"year(date('2021-01-01+08:00'))": 2021
}]
}
```
### Fungsi Neptunus OpenCypher
Tersedia dalam Database Neptunus 1.4.6.0 dan lebih tinggi, dan Neptunus Analytics.
#### mengurangi ()
Mengurangi proses secara berurutan setiap elemen daftar dengan menggabungkannya dengan total berjalan atau 'akumulator.' Dimulai dengan nilai awal, ia memperbarui akumulator setelah setiap operasi dan menggunakan nilai yang diperbarui dalam iterasi berikutnya.
`for i in (0, ..., n) acc = acc X list[I], where X denotes any binary operator`
Setelah semua elemen diproses, ia mengembalikan hasil akumulasi akhir.
Struktur reduce () yang khas adalah - `reduce(accumulator = initial , variable IN list | expression)`
**Spesifikasi jenis:**
`- 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 `
**Pembatasan:**
Saat ini, `reduce()` ekspresi hanya mendukung:
+ Perkalian Numerik
+ Penambahan Numerik
+ Rangkaian String
+ Daftar Penggabungan
Mereka diwakili oleh `*` operator `+` atau. Ekspresi harus berupa ekspresi biner seperti yang ditentukan di bawah ini - `expression pattern: accumulator + any variable or accumulator * any variable`
**Penanganan luapan:**
Neptunus mendeteksi luapan numerik selama evaluasi dan merespons `reduce()` secara berbeda berdasarkan tipe data:
```
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.
```
**Contoh:**
Lihat contoh berikut untuk fungsi 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
}]
}
```