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 Neptune mendukung referensi spesifikasi OpenCypher versi 9. Silakan lihat [Kepatuhan spesifikasi OpenCypher di Amazon Neptune](feature-opencypher-compliance.md) di Amazon Neptunus untuk detailnya. Selain itu, Amazon Neptune mendukung fitur yang tercantum di sini. Kecuali versi tertentu disebutkan, fitur-fiturnya tersedia di Neptune Database dan Neptune Analytics.
## Query-time Akses data S3
Tersedia dalam Neptune Database 1.4.7.0 dan yang lebih tinggi.
Neptune mendukung `neptune.read()` fungsi untuk membaca data CSV atau Parquet 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 Neptune Database dan Neptune Analytics.
Neptunus mengimplementasikan `join()` fungsi yang tidak ada dalam spesifikasi OpenCypher. Ini membuat 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 Neptune Database dan Neptune Analytics.
Neptunus mengimplementasikan `removeKeyFromMap()` fungsi yang tidak ada dalam spesifikasi OpenCypher. Ini menghapus kunci tertentu dari peta dan mengembalikan peta baru yang dihasilkan.
Fungsi ini mengambil 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 mengatur nilai untuk node atau hubungan dengan melepaskan 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 di Neptune Database 1.2.0.2 dan yang lebih tinggi, dan Neptune Analytics.
Mulai rilis [ mesin 1.2.0.2](engine-releases-1.2.0.2.md), Neptune telah memperluas spesifikasi OpenCypher sehingga Anda sekarang dapat menentukan `id` nilai untuk node dan hubungan di`CREATE`,, `MERGE` dan klausa. `MATCH` Ini memungkinkan Anda menetapkan string yang ramah pengguna alih-alih UUID yang dihasilkan sistem untuk mengidentifikasi node dan hubungan.
Di Neptune Analytics, nilai id khusus tidak tersedia untuk tepi.
**Awas**
Ekstensi untuk 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, Anda perlu memigrasikan properti yang ada ke kunci properti baru dan menghapus yang lama. Lihat [Apa yang harus dilakukan jika Anda saat ini menggunakan `~id` sebagai properti](#opencypher-compliance-custom-ids-migrating).
Berikut adalah contoh yang menunjukkan cara membuat node dan hubungan yang memiliki IDS khusus:
```
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 menampilkan `DuplicateDataException` kesalahan.
Berikut adalah contoh penggunaan ID khusus dalam `MATCH` klausa:
```
MATCH (n {`~id`: 'id1'})
RETURN n
```
Berikut adalah contoh penggunaan ID khusus dalam `MERGE` klausa:
```
MATCH (n {name: 'john'}), (m {name: 'jim'})
MERGE (n)-[r {`~id`: 'john->jim'}]->(m)
RETURN r
```
### Apa yang harus dilakukan jika Anda saat ini 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 alih- `id` alih sebagai properti. Ini berarti bahwa jika Anda memiliki properti bernama`~id`, mengaksesnya menjadi tidak mungkin.
Jika Anda menggunakan `~id` properti, apa yang harus Anda lakukan sebelum memutakhirkan ke rilis mesin `1.2.0.2` atau yang lebih tinggi adalah pertama-tama memigrasikan `~id` properti yang ada ke kunci properti baru, dan kemudian menghapus `~id` properti tersebut. Misalnya, kueri di bawah ini:
+ Membuat 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 untuk 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 di Neptune Database 1.4.1.0 dan yang lebih tinggi, dan Neptune Analytics.
Amazon Neptunus mendukung `CALL` subquery. `CALL`Subquery adalah bagian dari query utama yang berjalan dalam lingkup terisolasi untuk setiap input ke `CALL` subquery.
Misalnya, sebuah 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 query di dalam `CALL { ... }` dieksekusi untuk masing-masing `friend` yang dicocokkan dengan klausa MATCH sebelumnya. Ketika kueri batin dijalankan, `LIMIT` klausa `ORDER` dan bersifat lokal ke kota-kota tempat teman tertentu tinggal, jadi kami mendapatkan (paling banyak) dua kota per teman.
Semua klausa kueri tersedia di dalam `CALL` subquery. 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 `WITH` klausa awal. Tidak seperti `WITH` klausa reguler, klausa ini 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 subquery CALL
Variabel yang dipancarkan dari `CALL` subquery ditentukan dengan `RETURN` klausa akhir. Perhatikan bahwa variabel yang dipancarkan tidak dapat tumpang tindih dengan variabel sebelum `CALL` subkueri.
### Batasan
Sampai sekarang, pembaruan di dalam `CALL` subquery tidak didukung.
## Fungsi OpenCypher Neptunus
Tersedia di Neptune Database 1.4.1.0 dan yang lebih tinggi, dan Neptune Analytics.
**teks IndexOf **
`textIndexOf(text :: STRING, lookup :: STRING, from = 0 :: INTEGER?, to = -1 :: INTEGER?) :: (INTEGER?)`
Mengembalikan indeks kejadian pertama `lookup` dalam rentang `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 (titik 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 diper ** tahankan ** (misalnya pengem `[1, 6, 5, 1, 5]` balian`[1, 6, 5]`).
```
RETURN collToSet([1, 6, 5, 1, 1, 5])
{
"results": [{
"collToSet([1, 6, 5, 1, 1, 5])": [1, 6, 5]
}]
}
```
**CollSubtract **
`collSubtract(first :: LIST OF ANY?, second :: LIST OF ANY?) :: (LIST? OF ANY?)`
Mengembalikan daftar baru yang berisi semua elemen unik dari mengecu `first` alikan 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 peta atau node yang nilainya akan digunakan untuk menyortir. `order`adalah "" atau `asc` "`desc`" (tidak peka huruf besar) untuk menentukan urutan naik atau turun, masing-masing. Secara default, penyortiran akan dilakukan dalam urutan menaik.
**ColleSort **
`collSort(coll :: LIST OF ANY, config :: MAP?) :: (LIST? OF ANY?)`
Mengembalikan daftar diurutkan baru yang berisi elemen dari daftar `coll` input.
```
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 yang diurutkan berdasarkan nilai `key` properti yang ditentukan.
```
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 yang diurutkan berdasarkan nilai properti yang ditentukan, `key` secara 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 daftar `coll` input yang diurutkan, mengurutkan elemen node dengan 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 [ 1.4.5.0 ](https://docs.aws.amazon.com/releases/release-1.4.5.0.xml) dan lebih tinggi.
### hari
`day(temporal :: (datetime | date)) :: (LONG)`
Meng `day` embalikan bulan dari `date` nilai `datetime` atau. Untuk`datetime`: nilai dinormalisasi ke UTC berdasarkan input sebelum mengekstraksi hari. Untuk`date`: hari diekstraksi berdasarkan zona waktu.
In `datetime` put tersedia di Neptune Database dan Neptune Analytics:
```
RETURN day(datetime('2021-06-03T01:48:14Z'))
{
"results": [{
"day(datetime('2021-06-03T01:48:14Z'))": 3
}]
}
```
Di sini, dinormalisasi ke UTC, jadi \+ 08:00 berges `datetime` er 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
}]
}
```
In `date` put hanya tersedia di Neptune Analytics:
```
RETURN day(date('2021-06-03Z'))
{
"results": [{
"day(date('2021-06-03Z'))": 3
}]
}
```
Zona waktu `date` yang dipertahankan, 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.
In `datetime` put tersedia di Neptune Database dan Neptune Analytics:
```
RETURN month(datetime('2021-06-03T01:48:14Z'))
{
"results": [{
"month(datetime('2021-06-03T01:48:14Z'))": 6
}]
}
```
Di sini, dinormalisasi ke UTC, jadi \+ 08:00 berges `datetime` er 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
}]
}
```
In `date` put hanya tersedia di Neptune Analytics:
```
RETURN month(date('2021-06-03Z'))
{
"results": [{
"month(date('2021-06-03Z'))": 6
}]
}
```
Zona waktu `date` yang dipertahankan, 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-nilai dinormalisasi ke UTC berdasarkan input sebelum mengekstraksi tahun. Untuk`date`: tahun diekstraksi berdasarkan zona waktu.
In `datetime` put tersedia di Neptune Database dan Neptune 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
}]
}
```
In `date` put hanya tersedia di Neptune Analytics:
```
RETURN year(date('2021-06-03Z'))
{
"results": [{
"year(date('2021-06-03Z'))": 2021
}]
}
```
Zona waktu `date` yang dipertahankan, mempertahankan Juni 2021.
```
RETURN year(date('2021-01-01+08:00'))
{
"results": [{
"year(date('2021-01-01+08:00'))": 2021
}]
}
```
### Fungsi OpenCypher Neptunus
Tersedia di Neptune Database 1.4.6.0 dan yang lebih tinggi, dan Neptune Analytics.
#### mengurangi ()
Kurangi proses secara berurutan setiap elemen daftar dengan menggabungkannya dengan total berjalan atau 'akumulator'. Dimulai dengan nilai awal, ini 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 telah diproses, ia mengembalikan hasil akumulasi akhir.
Struktur reduce () yang khas adalah - `reduce(accumulator = initial , variable IN list | expression)`
**Spesifikasi tipe:**
`- 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:
+ Multiplikasi Numerik
+ Penambahan Numerik
+ Penggabungan string
+ Daftar Gabungan
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 `reduce()` evaluasi dan merespons 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
}]
}
```