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

Menulis ulang kueri Cypher untuk dijalankan di Neptunus openCypher

openCypher Bahasa ini adalah bahasa kueri deklaratif untuk grafik properti yang awalnya dikembangkan oleh Neo4j, kemudian bersumber terbuka pada tahun 2015, dan berkontribusi pada openCypher proyek di bawah lisensi open-source Apache 2. Di AWS, kami percaya bahwa open source baik untuk semua orang dan kami berkomitmen untuk membawa nilai open source kepada pelanggan kami, dan keunggulan operasional AWS untuk komunitas open source.

OpenCypher sintaks didokumentasikan dalam Referensi Bahasa Kueri Cypher, Versi 9.

Karena openCypher berisi subset sintaks dan fitur bahasa kueri Cypher, beberapa skenario migrasi memerlukan penulisan ulang kueri dalam bentuk yang openCypher sesuai atau memeriksa metode alternatif untuk mencapai fungsionalitas yang diinginkan.

Bagian ini berisi rekomendasi untuk menangani perbedaan umum, tetapi sama sekali tidak lengkap. Anda harus menguji aplikasi apa pun menggunakan penulisan ulang ini secara menyeluruh untuk memastikan bahwa hasilnya sesuai dengan yang Anda harapkan.

Menulis ulangNone,All, dan fungsi Any predikat

Fungsi-fungsi ini bukan bagian dari openCypher spesifikasi. Hasil yang sebanding dapat dicapai dengan openCypher menggunakan Pemahaman Daftar.

Misalnya, temukan semua jalur yang berpindah dari node Start ke nodeEnd, tetapi tidak ada perjalanan yang diizinkan melewati node dengan properti kelasD:

# Neo4J Cypher code
match p=(a:Start)-[:HOP*1..]->(z:End)
where none(node IN nodes(p) where node.class ='D')
return p

# Neptune openCypher code
match p=(a:Start)-[:HOP*1..]->(z:End)
where size([node IN nodes(p) where node.class = 'D']) = 0
return p

Pemahaman daftar dapat mencapai hasil ini sebagai berikut:

all  => size(list_comprehension(list)) = size(list)
any  => size(list_comprehension(list)) >= 1
none => size(list_comprehension(list)) = 0

Menulis ulang fungsi Cypher reduce() di openCypher

reduce()Fungsi ini bukan bagian dari openCypher spesifikasi. Hal ini sering digunakan untuk membuat agregasi data dari elemen dalam daftar. Dalam banyak kasus, Anda dapat menggunakan kombinasi Pemahaman Daftar dan UNWIND klausa untuk mencapai hasil yang serupa.

Misalnya, kueri Cypher berikut menemukan semua bandara di jalur yang memiliki satu hingga tiga pemberhentian antara Anchorage (ANC) dan Austin (AUS), dan mengembalikan jarak total setiap jalur:

MATCH p=(a:airport {code: 'ANC'})-[r:route*1..3]->(z:airport {code: 'AUS'})
RETURN p, reduce(totalDist=0, r in relationships(p) | totalDist + r.dist) AS totalDist
ORDER BY totalDist LIMIT 5

Anda dapat menulis kueri yang sama openCypher untuk Neptunus sebagai berikut:

MATCH p=(a:airport {code: 'ANC'})-[r:route*1..3]->(z:airport {code: 'AUS'})
UNWIND [i in relationships(p) | i.dist] AS di
RETURN p, sum(di) AS totalDist
ORDER BY totalDist
LIMIT 5

Menulis ulang klausa Cypher FOREACH di openCypher

FOREACHKlausul ini bukan bagian dari openCypher spesifikasi. Hal ini sering digunakan untuk memperbarui data di tengah-tengah query, sering dari agregasi atau elemen dalam jalur.

Sebagai contoh jalur, temukan semua bandara di jalur dengan tidak lebih dari dua pemberhentian antara Anchorage (ANC) dan Austin (AUS) dan tetapkan properti yang dikunjungi di masing-masing bandara:

# Neo4J Example
MATCH p=(:airport {code: 'ANC'})-[*1..2]->({code: 'AUS'})
FOREACH (n IN nodes(p) | SET n.visited = true)

# Neptune openCypher
MATCH p=(:airport {code: 'ANC'})-[*1..2]->({code: 'AUS'})
WITH nodes(p) as airports
UNWIND airports as a
SET a.visited=true

Contoh lain adalah:

# Neo4J Example
MATCH p=(start)-[*]->(finish)
WHERE start.name = 'A' AND finish.name = 'D'
FOREACH (n IN nodes(p) | SET n.marked = true)

# Neptune openCypher
MATCH p=(start)-[*]->(finish)
WHERE start.name = 'A' AND finish.name = 'D'
UNWIND nodes(p) AS n
SET n.marked = true

Menulis ulang prosedur Neo4j APOC di Neptunus

Contoh di bawah ini digunakan openCypher untuk mengganti beberapa APOCprosedur yang paling umum digunakan. Contoh-contoh ini hanya untuk referensi, dan dimaksudkan untuk memberikan beberapa saran tentang cara menangani skenario umum. Dalam praktiknya, setiap aplikasi berbeda, dan Anda harus membuat strategi Anda sendiri untuk menyediakan semua fungsionalitas yang Anda butuhkan.

Prosedur penulisan ulang apoc.export

Neptunus menyediakan berbagai opsi untuk grafik penuh dan ekspor berbasis kueri dalam berbagai format output CSV seperti JSON dan, menggunakan utilitas ekspor neptunus (lihat). Mengekspor data dari cluster DB Neptunus

Prosedur penulisan ulang apoc.schema

Neptunus tidak memiliki skema, indeks, atau kendala yang didefinisikan secara eksplisit, sehingga banyak prosedur tidak lagi diperlukan. apoc.schema Contohnya adalah:

openCypher Neptunus memang mendukung pengambilan nilai yang serupa dengan yang dilakukan prosedur, seperti yang ditunjukkan di bawah ini, tetapi dapat mengalami masalah kinerja pada grafik yang lebih besar karena hal itu memerlukan pemindaian sebagian besar grafik untuk mengembalikan jawabannya.

# openCypher replacement for apoc.schema.properties.distinct
MATCH (n:airport)
RETURN DISTINCT n.runways

# openCypher replacement for apoc.schema.properties.distinctCount
MATCH (n:airport)
RETURN DISTINCT n.runways, count(n.runways)

Alternatif untuk apoc.do prosedur

Prosedur ini digunakan untuk menyediakan eksekusi kueri bersyarat yang mudah diimplementasikan menggunakan openCypher klausa lain. Di Neptunus setidaknya ada dua cara untuk mencapai perilaku serupa:

Contoh pendekatan ini ditunjukkan di bawah ini.

Alternatif untuk apoc.do.when

# Neo4J Example
MATCH (n:airport {region: 'US-AK'})
CALL apoc.do.when(
 n.runways>=3,
 'SET n.is_large_airport=true RETURN n',
 'SET n.is_large_airport=false RETURN n',
 {n:n}
) YIELD value
WITH collect(value.n) as airports
RETURN size([a in airports where a.is_large_airport]) as large_airport_count,
size([a in airports where NOT a.is_large_airport]) as small_airport_count


# Neptune openCypher
MATCH (n:airport {region: 'US-AK'})
WITH n.region as region, collect(n) as airports
WITH [a IN airports where a.runways >= 3] as large_airports,
[a IN airports where a.runways < 3] as small_airports, airports
UNWIND large_airports as la
SET la.is_large_airport=true
WITH DISTINCT small_airports, airports
UNWIND small_airports as la
    SET la.small_airports=true
WITH DISTINCT airports
RETURN size([a in airports where a.is_large_airport]) as large_airport_count,
size([a in airports where NOT a.is_large_airport]) as small_airport_count

#Neptune Gremlin using choose()
g.V().
  has('airport', 'region', 'US-AK').
  choose(
    values('runways').is(lt(3)),
    property(single, 'is_large_airport', false),
    property(single, 'is_large_airport', true)).
  fold().
  project('large_airport_count', 'small_airport_count').
    by(unfold().has('is_large_airport', true).count()).
    by(unfold().has('is_large_airport', false).count())

 #Neptune Gremlin using coalesce() 
g.V().
  has('airport', 'region', 'US-AK').
  coalesce(
    where(values('runways').is(lt(3))).
    property(single, 'is_large_airport', false),
    property(single, 'is_large_airport', true)).
  fold().
  project('large_airport_count', 'small_airport_count').
    by(unfold().has('is_large_airport', true).count()).
    by(unfold().has('is_large_airport', false).count())

Alternatif untuk apoc.do.case

# Neo4J Example
MATCH (n:airport {region: 'US-AK'})
CALL apoc.case([
 n.runways=1, 'RETURN "Has one runway" as b',
 n.runways=2, 'RETURN "Has two runways" as b'
 ],
 'RETURN "Has more than 2 runways" as b'
) YIELD value 
RETURN {type: value.b,airport: n}

# Neptune openCypher
MATCH (n:airport {region: 'US-AK'})
WITH n.region as region, collect(n) as airports
WITH [a IN airports where a.runways =1] as single_runway,
[a IN airports where a.runways =2] as double_runway,
[a IN airports where a.runways >2] as many_runway
UNWIND single_runway as sr
    WITH {type: "Has one runway",airport: sr} as res, double_runway, many_runway
WITH DISTINCT double_runway as double_runway, collect(res) as res, many_runway
UNWIND double_runway as dr
    WITH {type: "Has two runways",airport: dr} as two_runways, res, many_runway
WITH collect(two_runways)+res as res, many_runway
UNWIND many_runway as mr
    WITH {type: "Has more than 2 runways",airport: mr} as res2, res, many_runway
WITH collect(res2)+res as res
UNWIND res as r
RETURN r

#Neptune Gremlin using choose()
g.V().
  has('airport', 'region', 'US-AK').
  project('type', 'airport').
    by(
      choose(values('runways')).
        option(1, constant("Has one runway")).
        option(2, constant("Has two runways")).
        option(none, constant("Has more than 2 runways"))).
    by(elementMap())

 #Neptune Gremlin using coalesce()
 g.V().
  has('airport', 'region', 'US-AK').
  project('type', 'airport').
    by(
      coalesce(
        has('runways', 1).constant("Has one runway"),
        has('runways', 2).constant("Has two runways"),
        constant("Has more than 2 runways"))).
    by(elementMap())

Alternatif untuk properti berbasis daftar

Neptunus saat ini tidak mendukung penyimpanan properti berbasis Daftar. Namun, hasil serupa dapat diperoleh dengan menyimpan nilai daftar sebagai string yang dipisahkan koma dan kemudian menggunakan split() fungsi join() and untuk membangun dan mendekonstruksi properti list.

Misalnya, jika kita ingin menyimpan daftar tag sebagai properti, kita dapat menggunakan contoh penulisan ulang yang menunjukkan cara mengambil properti yang dipisahkan koma dan kemudian menggunakan join() fungsi split() dan dengan Pemahaman Daftar untuk mencapai hasil yang sebanding:

# Neo4j Example (In this example, tags is a durable list of string.
MATCH (person:person {name: "TeeMan"})
WITH person, [tag in person.tags WHERE NOT (tag IN ['test1', 'test2', 'test3'])] AS newTags
SET person.tags = newTags
RETURN person

# Neptune openCypher 
MATCH (person:person {name: "TeeMan"})
WITH person, [tag in split(person.tags, ',') WHERE NOT (tag IN ['test1', 'test2', 'test3'])] AS newTags
SET person.tags = join(newTags,',')
RETURN person

Menulis ulang CALL subkueri

Subquery CALL Neptunus tidak mendukung CALL (friend) { ... } sintaks untuk mengimpor variabel ke dalam lingkup subquery (, dalam contoh ini). friend Silakan gunakan WITH klausa di dalam subquery untuk hal yang sama, misalnya,. CALL { WITH friend ... }

CALLSubquery opsional tidak didukung saat ini.

Perbedaan lain antara openCypher Neptunus dan Cypher