Query-time Akses data S3 Fungsi join()Fungsi removeKeyFromMap()Nilai ID kustom Dukungan subquery CALL di Neptunus Fungsi OpenCypher Neptunus Fungsi penyortiran Fungsi temporal

Ekstensi OpenCypher di Amazon Neptunus

Amazon Neptune mendukung referensi spesifikasi OpenCypher versi 9. Silakan lihat Kepatuhan spesifikasi OpenCypher di Amazon Neptune 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, lihatneptune.read ().

`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, Neptune telah memperluas spesifikasi OpenCypher sehingga Anda sekarang dapat menentukan id nilai untuk node dan hubungan diCREATE,, 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.

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, ~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. CALLSubquery 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 denganDISTINCT,ORDER BY,, WHERESKIP, atauLIMIT.

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 akhirtext. 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 darisecond.


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


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. orderadalah "" 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 dan lebih tinggi.

hari

day(temporal :: (datetime | date)) :: (LONG)

Meng day embalikan bulan dari date nilai datetime atau. Untukdatetime: nilai dinormalisasi ke UTC berdasarkan input sebelum mengekstraksi hari. Untukdate: 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). Untukdatetime: nilai dinormalisasi ke UTC berdasarkan input sebelum mengekstraksi bulan. Untukdate: 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. Untukdatetime: nilai-nilai dinormalisasi ke UTC berdasarkan input sebelum mengekstraksi tahun. Untukdate: 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
    }]
}

Awas Javascript dinonaktifkan atau tidak tersedia di browser Anda.

Untuk menggunakan Dokumentasi AWS, Javascript harus diaktifkan. Lihat halaman Bantuan browser Anda untuk petunjuk.

Konvensi Dokumen

Pengecualian

neptune.read ()

Ekstensi OpenCypher di Amazon Neptunus

Query-time Akses data S3

Fungsi Neptune-specific join ()

Fungsi Neptune-specific remove KeyFromMap ()

Nilai ID kustom untuk properti node dan hubungan

Awas

Apa yang harus dilakukan jika Anda saat ini menggunakan ~id sebagai properti

Dukungan subquery CALL di Neptunus

Lingkup variabel di dalam subquery CALL

Variabel dikembalikan dari subquery CALL

Batasan

Fungsi OpenCypher Neptunus

Fungsi penyortiran

Fungsi temporal

hari

bulan

tahun

Fungsi OpenCypher Neptunus

mengurangi ()

Spesifikasi tipe:

Pembatasan:

Penanganan luapan:

Contoh:

`Fungsi Neptune-specific` join ()

`Fungsi Neptune-specific` remove KeyFromMap ()

Apa yang harus dilakukan jika Anda saat ini menggunakan `~id` sebagai properti