Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

openCypher ekstensi di Amazon Neptunus

Amazon Neptunus mendukung referensi spesifikasi versi openCypher 9. Silakan lihat openCypher kepatuhan spesifikasi di Amazon Neptunus 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.

Fungsi khusus Neptunus 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:

Contoh:

join(["abc", "def", "ghi"], ", ")    // Returns "abc, def, ghi"

Fungsi khusus Neptunus removeKeyFromMap()

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:

removeKeyFromMap()Fungsi ini sangat berguna dalam situasi di mana Anda ingin menetapkan nilai untuk node atau hubungan dengan membuka daftar peta. Sebagai 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, Neptunus telah memperluas openCypher spesifikasi 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 yang dihasilkan sistem untuk mengidentifikasi node dan hubunganUUIDs.

Di Neptunus Analytics, nilai id kustom tidak tersedia untuk tepi.

Berikut adalah contoh yang menunjukkan cara membuat node dan hubungan yang memiliki kustomIDS:

CREATE (n {`~id`: 'fromNode', name: 'john'})
  -[:knows {`~id`: 'john-knows->jim', since: 2020}]
  ->(m {`~id`: 'toNode', name: 'jim'})

Jika Anda mencoba membuat ID kustom 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 kustom IDs 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 openCypher klausa sekarang diperlakukan sebagai id pengganti sebagai properti. 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:

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

CALLdukungan subquery di Neptunus

Tersedia dalam Database Neptunus 1.4.1.0 dan lebih tinggi, dan Neptunus Analytics.

Amazon Neptunus mendukung subkueriCALL. CALLSubquery 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 sebelumnyaMATCH. 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 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 CALL subquery

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 denganDISTINCT,,, ORDER BYWHERE, 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.

textIndexOf

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 akhirtext. Pengindeksan berbasis nol, dan dinyatakan dalam nilai skalar Unicode (poin kode non-pengganti).

RETURN textIndexOf('Amazon Neptune', 'e')
{
  "results": [{
      "textIndexOf('Amazon Neptune', 'e')": 8
    }]
}

collToSet

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]
    }]
}

collSubtract

collSubtract(first :: LIST OF ANY?, second :: LIST OF ANY?) :: (LIST? OF ANY?)

Mengembalikan daftar baru yang berisi semua elemen unik dari first mengecualikan 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 tersebut, yang menentukan kunci pengurutan dan/atau arah pengurutan:

{ key: STRING, order: STRING }

Berikut key adalah properti map atau node yang nilainya akan digunakan untuk menyortir. orderadalah "asc" atau "desc" (case insensitive) 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]
    }]
}

collSortMaps

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"
        }]
    }]
}

collSortMulti

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"
        }]
    }]
}

collSortNodes

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"
          }
        }]
    }]
}