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.
## Akses data S3 waktu kueri
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 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:
+ 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 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:
+ 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 yang dihasilkan sistem untuk mengidentifikasi node dan hubungan UUIDs .
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 Anda saat ini 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 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](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 '\$1id' ke properti 'NewId',
+ dan menghapus properti '\$1id' 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.
**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 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
}]
}
```
**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]
}]
}
```
**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 "`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"
}
}]
}]
}
```
## 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 \$1 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 \$1 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 \$1 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
+ Penggabungan 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
}]
}
```
# neptune.read ()
Neptunus mendukung `neptune.read` prosedur untuk membaca `CALL` data dari Amazon S3 dan kemudian menjalankan kueri OpenCypher (baca, sisipkan, perbarui) menggunakan data. Prosedur menghasilkan setiap baris dalam file sebagai baris variabel hasil yang dideklarasikan. Ini menggunakan kredensyal IAM dari penelepon untuk mengakses data di Amazon S3. Lihat [Mengelola izin untuk neptune.read ()](access-graph-opencypher-21-extensions-s3-read-permissions.md) untuk mengatur izin. AWS Wilayah bucket Amazon S3 harus berada di wilayah yang sama di mana instance berada. Saat ini, pembacaan lintas wilayah tidak didukung.
**Sintaksis**
```
CALL neptune.read(
{
source: "string",
format: "parquet/csv",
concurrency: 10
}
)
YIELD row
...
```
**Masukan**
+ **source** (wajib) - Amazon S3 URI ke **satu** objek. Awalan Amazon S3 ke beberapa objek tidak didukung.
+ **format** (wajib) - `parquet` dan `csv` didukung.
+ Rincian lebih lanjut tentang format Parket yang didukung dapat ditemukan di[Jenis kolom Parket yang didukung](access-graph-opencypher-21-extensions-s3-read-parquet.md#access-graph-opencypher-21-extensions-s3-read-parquet-column-types).
+ Untuk informasi selengkapnya tentang format csv yang didukung, lihat[Muat format untuk data OpenCypher](bulk-load-tutorial-format-opencypher.md).
+ **konkurensi** (opsional) - Jenis: 0 atau bilangan bulat yang lebih besar. Default: 0. Menentukan jumlah thread yang akan digunakan untuk membaca file. Jika nilainya 0, jumlah maksimum utas yang diizinkan oleh sumber daya akan digunakan. Untuk Parket, disarankan untuk diatur ke sejumlah grup baris.
**Output**
Neptune.read mengembalikan:
+ **baris** - Jenis: Peta
+ Setiap baris dalam file, di mana kuncinya adalah kolom dan nilainya adalah data yang ditemukan di setiap kolom.
+ Anda dapat mengakses data setiap kolom seperti properti access (`row.col`).
## Praktik terbaik untuk neptune.read ()
Operasi pembacaan Neptunus S3 bisa intensif memori. Harap gunakan jenis instans yang cocok untuk beban kerja produksi seperti yang diuraikan dalam [Memilih jenis instans untuk Amazon Neptunus](instance-types.md).
Penggunaan memori dan kinerja `neptune.read()` permintaan dipengaruhi oleh berbagai faktor seperti ukuran file, jumlah kolom, jumlah baris, dan format file. Bergantung pada struktur, file kecil (misalnya, file CSV 100MB atau di bawahnya, file Parket 20MB atau di bawahnya) dapat bekerja dengan andal pada sebagian besar jenis instance yang sesuai dengan produksi, sedangkan file yang lebih besar mungkin memerlukan memori substanal yang tidak dapat disediakan oleh tipe instance yang lebih kecil.
Saat menguji fitur ini, disarankan untuk memulai dengan file kecil dan menskalakan secara bertahap untuk memastikan beban kerja baca Anda dapat diakomodasi oleh ukuran instans Anda. Jika Anda melihat `neptune.read()` permintaan yang mengarah ke out-of-memory pengecualian atau instans dimulai ulang, pertimbangkan untuk membagi file Anda menjadi potongan yang lebih kecil, mengurangi kompleksitas file, atau meningkatkan ke jenis instans yang lebih besar.
# Contoh kueri menggunakan parket
Contoh query berikut mengembalikan jumlah baris dalam file Parket tertentu:
```
CALL neptune.read(
{
source: "",
format: "parquet"
}
)
YIELD row
RETURN count(row)
```
Anda dapat menjalankan contoh query menggunakan `execute-open-cypher-query` operasi di AWS CLI dengan mengeksekusi kode berikut:
```
aws neptunedata execute-open-cypher-query \
--open-cypher-query "CALL neptune.read({source: '', format: 'parquet'}) YIELD row RETURN count(row)" \
--endpoint-url https://my-cluster-name.cluster-abcdefgh1234.us-east-1.neptune.amazonaws.com:8182
```
Kueri bisa fleksibel dalam apa yang dilakukannya dengan baris yang dibaca dari file Parket. Misalnya, kueri berikut membuat simpul dengan bidang yang disetel ke data yang ditemukan di file Parket:
```
CALL neptune.read(
{
source: "",
format: "parquet"
}
)
YIELD row
CREATE (n {someField: row.someCol})
RETURN n
```
**Awas**
Tidak dianggap praktik yang baik untuk menggunakan klausa penghasil hasil besar seperti `MATCH(n)` sebelum klausa. `CALL` Ini akan mengarah pada kueri yang berjalan lama, karena produk silang antara solusi yang masuk dari klausa sebelumnya dan baris yang dibaca oleh neptune.read. Disarankan untuk memulai kueri dengan `CALL` neptune.read.
## Jenis kolom Parket yang didukung
**Jenis Data Parket:**
+ NULL
+ BOOLEAN
+ FLOAT
+ DOUBLE
+ STRING
+ INTEGER YANG DITANDATANGANI: UINT8,, UINT16, UINT32 UINT64
+ MAP: Hanya mendukung satu tingkat. Tidak mendukung bersarang.
+ DAFTAR: Hanya mendukung satu tingkat. Tidak mendukung bersarang.
**Tipe data khusus Neptunus:**
Berbeda dengan header kolom properti dari format CSV, header kolom properti dari format Parket hanya perlu memiliki nama properti, jadi tidak perlu memiliki nama tipe atau kardinalitas.
Namun, ada beberapa jenis kolom khusus dalam format Parket yang memerlukan anotasi dalam metadata, termasuk tipe Any, tipe Date, tipe DateTime, dan jenis Geometri. Objek berikut adalah contoh anotasi metadata yang diperlukan untuk file yang berisi kolom jenis khusus ini:
```
"metadata": {
"anyTypeColumns": ["UserCol1"],
"dateTypeColumns": ["UserCol2"],
"dateTimeTypeColumns": ["UserCol3"],
"geometryTypeColumns": ["UserCol4"]
}
```
Di bawah ini adalah detail tentang muatan yang diharapkan terkait dengan jenis ini:
+ Tipe kolom Any didukung di kolom pengguna. Tipe Any adalah jenis “gula sintaksis” untuk semua jenis lain yang kami dukung. Ini sangat berguna jika kolom pengguna memiliki beberapa jenis di dalamnya. Payload dari nilai tipe Any adalah daftar string json sebagai berikut:`{"value": "10", "type": "Int"};{"value": "1.0", "type": "Float"}`, yang memiliki bidang nilai dan bidang tipe di setiap string json individu. Nilai kardinalitas kolom Any diatur, artinya kolom dapat menerima beberapa nilai.
+ Neptunus mendukung jenis berikut dalam tipe Any: Bool (atau Boolean), Byte, Short, Int, Long,,,,, Float, Double UnsignedByte UnsignedShort, Date UnsignedInt UnsignedLong, DateTime, String, dan Geometry.
+ Jenis vektor tidak didukung dalam Tipe apa pun.
+ Bersarang Tipe apa pun tidak didukung. Misalnya, `{"value": {"value": "10", "type": "Int"}, "type": "Any"}`.
+ Kolom tipe Tanggal dan Datetime didukung di kolom pengguna. Muatan kolom ini harus disediakan sebagai string mengikuti format XSD atau salah satu format di bawah ini:
+ YYYY-MM-DD
+ YYYY-MM-DDTHH: mm
+ YYYY-MM-DDTHH: MM: SS
+ YYYY-MM-DDTHH: mm: SSZ
+ YYYY-MM-DDTHH: MM: SS.SSSZ
+ YYYY-MM-DDTHH: mm: SS [\$1\$1-] hhmm
+ YYYY-MM-DDTHH: mm: SS.sss [\$1\$1-] hhmm
+ Jenis kolom Geometri didukung di kolom pengguna. Muatan kolom ini hanya boleh berisi geometri primitif tipe Point, disediakan sebagai string dalam format teks terkenal (WKT). Misalnya, POINT (30 10) akan menjadi nilai Geometri yang valid.
## Contoh keluaran parket
Diberikan file Parket seperti ini:
```
Parquet Type:
int8 int16 int32 int64 float double string
+--------+---------+-------------+----------------------+------------+------------+----------+
| Byte | Short | Int | Long | Float | Double | String |
|--------+---------+-------------+----------------------+------------+------------+----------|
| -128 | -32768 | -2147483648 | -9223372036854775808 | 1.23456 | 1.23457 | first |
| 127 | 32767 | 2147483647 | 9223372036854775807 | nan | nan | second |
| 0 | 0 | 0 | 0 | -inf | -inf | third |
| 0 | 0 | 0 | 0 | inf | inf | fourth |
+--------+---------+-------------+----------------------+------------+------------+----------+
```
Berikut adalah contoh output yang dikembalikan oleh neptune.read menggunakan query berikut:
```
aws neptunedata execute-open-cypher-query \
--open-cypher-query "CALL neptune.read({source: '', format: 'parquet'}) YIELD row RETURN row" \
--endpoint-url https://my-cluster-name.cluster-abcdefgh1234.us-east-1.neptune.amazonaws.com:8182
```
```
{
"results": [{
"row": {
"Float": 1.23456,
"Byte": -128,
"Int": -2147483648,
"Long": -9223372036854775808,
"String": "first",
"Short": -32768,
"Double": 1.2345678899999999
}
}, {
"row": {
"Float": "NaN",
"Byte": 127,
"Int": 2147483647,
"Long": 9223372036854775807,
"String": "second",
"Short": 32767,
"Double": "NaN"
}
}, {
"row": {
"Float": "-INF",
"Byte": 0,
"Int": 0,
"Long": 0,
"String": "third",
"Short": 0,
"Double": "-INF"
}
}, {
"row": {
"Float": "INF",
"Byte": 0,
"Int": 0,
"Long": 0,
"String": "fourth",
"Short": 0,
"Double": "INF"
}
}]
}
```
Saat ini, tidak ada cara untuk mengatur node atau label tepi ke bidang data yang berasal dari file Parket. Disarankan agar Anda mempartisi kueri menjadi beberapa kueri, satu untuk setiap label/jenis.
```
CALL neptune.read({source: '', format: 'parquet'})
YIELD row
WHERE row.`~label` = 'airport'
CREATE (n:airport)
CALL neptune.read({source: '', format: 'parquet'})
YIELD row
WHERE row.`~label` = 'country'
CREATE (n:country)
```
# Contoh kueri menggunakan CSV
Dalam contoh ini, kueri mengembalikan jumlah baris dalam file CSV yang diberikan:
```
CALL neptune.read(
{
source: "",
format: "csv"
}
)
YIELD row
RETURN count(row)
```
Anda dapat menjalankan contoh query menggunakan execute-open-cypher-query operasi di AWS CLI dengan mengeksekusi kode berikut:
```
aws neptunedata execute-open-cypher-query \
--open-cypher-query "CALL neptune.read({source: '', format: 'csv'}) YIELD row RETURN count(row)" \
--endpoint-url https://my-cluster-name.cluster-abcdefgh1234.us-east-1.neptune.amazonaws.com:8182
```
Kueri bisa fleksibel dalam apa yang dilakukannya dengan baris yang dibaca dari file CSV. Misalnya, kueri berikut membuat simpul dengan bidang yang disetel ke data dari file CSV:
```
CALL neptune.read(
{
source: "",
format: "csv"
}
)
YIELD row
CREATE (n {someField: row.someCol})
RETURN n
```
**Awas**
Ini tidak dianggap praktik yang baik menggunakan klausa penghasil hasil besar seperti MATCH (n) sebelum klausa CALL. Ini akan mengarah pada kueri yang berjalan lama karena produk silang antara solusi yang masuk dari klausa sebelumnya dan baris yang dibaca oleh neptune.read. Disarankan untuk memulai kueri dengan CALL neptune.read.
## Header kolom properti
Anda dapat menentukan kolom (`:`) untuk properti dengan menggunakan sintaks berikut. Nama jenis tidak peka dengan huruf besar/kecil. Jika titik dua muncul dalam nama properti, itu harus diloloskan dengan mendahuluinya dengan garis miring terbalik:. `\:`
```
propertyname:type
```
**catatan**
Spasi, koma, carriage return, dan karakter baris baru tidak diperbolehkan di header kolom, sehingga nama properti tidak dapat menyertakan karakter ini.
Anda dapat menentukan kolom untuk jenis array dengan menambahkan `[]` ke jenisnya:
```
propertyname:type[]
```
Properti edge hanya dapat memiliki satu nilai dan akan menyebabkan kesalahan jika jenis array yang ditentukan atau nilai kedua ditentukan. Contoh berikut menunjukkan header kolom untuk properti bernama umur tipe Int:
```
age:Int
```
Setiap baris dalam file akan perlu memiliki integer dalam posisi itu atau dibiarkan kosong. Array string diperbolehkan, tetapi string dalam array tidak dapat menyertakan karakter titik koma () kecuali jika diloloskan menggunakan garis miring terbalik (`;`). `\;`
## Jenis kolom CSV yang didukung
+ **BOOL (atau BOOLEAN)** - Nilai yang diizinkan: benar, salah. Menunjukkan bidang Boolean. Nilai apa pun selain true akan diperlakukan sebagai false.
+ **FLOAT** - Rentang: 32-bit IEEE 754 floating point termasuk Infinity, INF, -Infinity, -INF dan NaN (). not-a-number
+ **DOUBLE** - Rentang: 64-bit IEEE 754 floating point termasuk Infinity, INF, -Infinity, -INF dan NaN (). not-a-number
+ **TALI** -
+ Tanda kutip adalah opsional. Karakter koma, baris baru, dan carriage return secara otomatis lolos jika disertakan dalam string yang dikelilingi oleh tanda kutip ganda (“). Contoh: “Halo, Dunia”.
+ Untuk menyertakan tanda kutip dalam string yang dikutip, Anda dapat menghindari tanda kutip dengan menggunakan dua berturut-turut: Contoh: “Halo “" Dunia ""”.
+ Array string diperbolehkan, tetapi string dalam array tidak dapat menyertakan karakter titik koma (;) kecuali jika diloloskan menggunakan garis miring terbalik (\$1;).
+ Jika Anda ingin mengapit string dalam array dengan tanda kutip, Anda harus mengapit keseluruhan array dengan satu set tanda kutip. Contoh: “String satu; String 2; String 3".
+ **DATE, DATETIME** - Nilai datetime dapat diberikan dalam format XSD, atau salah satu format berikut:
+ YYYY-MM-DD
+ YYYY-MM-DDTHH: mm
+ YYYY-MM-DDTHH: MM: SS
+ YYYY-MM-DDTHH: mm: SSZ
+ YYYY-MM-DDTHH: MM: SS.SSSZ
+ YYYY-MM-DDTHH: mm: SS [\$1\$1-] hhmm
+ YYYY-MM-DDTHH: mm: SS.sss [\$1\$1-] hhmm
+ **INTEGER YANG DITANDATANGANI** -
+ Byte: -128 hingga 127
+ Pendek: -32768 sampai 32767
+ Int: -2^31 hingga 2 ^ 31-1
+ Panjang: -2 ^ 63 hingga 2 ^ 63-1
**Jenis kolom khusus Neptunus:**
+ Tipe kolom Any didukung di kolom pengguna. Tipe Any adalah jenis “gula sintaksis” untuk semua jenis lain yang kami dukung. Ini sangat berguna jika kolom pengguna memiliki beberapa jenis di dalamnya. Payload dari nilai tipe Any adalah daftar string json sebagai berikut:`{"value": "10", "type": "Int"};{"value": "1.0", "type": "Float"}`, yang memiliki bidang nilai dan bidang tipe di setiap string json individu. Header kolom dari tipe Any adalah PropertyName:Any. Nilai kardinalitas kolom Any diatur, artinya kolom dapat menerima beberapa nilai.
+ Neptunus mendukung jenis berikut dalam tipe Any: Bool (atau Boolean), Byte, Short, Int, Long,,,,, Float, Double UnsignedByte UnsignedShort, Date UnsignedInt UnsignedLong, DateTime, String, dan Geometry.
+ Jenis vektor tidak didukung dalam Tipe apa pun.
+ Bersarang Tipe apa pun tidak didukung. Misalnya, `{"value": {"value": "10", "type": "Int"}, "type": "Any"}`.
+ Jenis kolom Geometri didukung di kolom pengguna. Muatan kolom ini hanya boleh berisi geometri primitif tipe Point, disediakan sebagai string dalam format teks terkenal (WKT). Misalnya, POINT (30 10) akan menjadi nilai Geometri yang valid.
## Contoh keluaran CSV
Diberikan file CSV berikut:
```
colA:byte,colB:short,colC:int,colD:long,colE:float,colF:double,colG:string
-128,-32768,-2147483648,-9223372036854775808,1.23456,1.23457,first
127,32767,2147483647,9223372036854775807,nan,nan,second
0,0,0,0,-inf,-inf,third
0,0,0,0,inf,inf,fourth
```
Contoh ini menunjukkan output yang dikembalikan oleh neptune.read menggunakan query berikut:
```
aws neptunedata execute-open-cypher-query \
--open-cypher-query "CALL neptune.read({source: '', format: 'csv'}) YIELD row RETURN row" \
--endpoint-url https://my-cluster-name.cluster-abcdefgh1234.us-east-1.neptune.amazonaws.com:8182
```
```
{
"results": [{
"row": {
"colD": -9223372036854775808,
"colC": -2147483648,
"colE": 1.23456,
"colB": -32768,
"colF": 1.2345699999999999,
"colG": "first",
"colA": -128
}
}, {
"row": {
"colD": 9223372036854775807,
"colC": 2147483647,
"colE": "NaN",
"colB": 32767,
"colF": "NaN",
"colG": "second",
"colA": 127
}
}, {
"row": {
"colD": 0,
"colC": 0,
"colE": "-INF",
"colB": 0,
"colF": "-INF",
"colG": "third",
"colA": 0
}
}, {
"row": {
"colD": 0,
"colC": 0,
"colE": "INF",
"colB": 0,
"colF": "INF",
"colG": "fourth",
"colA": 0
}
}]
}
```
Saat ini, tidak ada cara untuk mengatur label node atau edge ke bidang data yang berasal dari file CSV. Disarankan agar Anda mempartisi kueri menjadi beberapa kueri, satu untuk setiap label/jenis.
```
CALL neptune.read({source: '', format: 'csv'})
YIELD row
WHERE row.`~label` = 'airport'
CREATE (n:airport)
CALL neptune.read({source: '', format: 'csv'})
YIELD row
WHERE row.`~label` = 'country'
CREATE (n:country)
```
# Mengelola izin untuk neptune.read ()
## Kebijakan IAM yang Diperlukan
Untuk menjalankan kueri OpenCypher yang digunakan`neptune.read()`, Anda harus memiliki izin yang sesuai untuk mengakses data dalam database Neptunus Anda. Kueri hanya-baca memerlukan tindakan. `ReadDataViaQuery` Kueri yang memodifikasi data memerlukan `WriteDataViaQuery` penyisipan atau penghapusan`DeleteDataViaQuery`. Contoh di bawah ini memberikan ketiga tindakan pada cluster yang ditentukan.
Selain itu, Anda memerlukan izin untuk mengakses bucket S3 yang berisi file data Anda. Pernyataan kebijakan NepTunes3Access memberikan izin S3 yang diperlukan:
+ **`s3:ListBucket`**: Diperlukan untuk memverifikasi keberadaan bucket dan daftar konten.
+ **`s3:GetObject`**: Diperlukan untuk mengakses objek yang ditentukan sehingga kontennya dapat dibaca untuk integrasi ke dalam kueri OpenCypher.
Jika bucket S3 Anda menggunakan enkripsi sisi server AWS KMS, Anda juga harus memberikan izin KMS. KMSAccess Pernyataan kebijakan Neptunes3 memungkinkan Neptunus untuk mendekripsi data dan menghasilkan kunci data saat mengakses objek S3 terenkripsi. Kondisi ini membatasi operasi KMS untuk permintaan yang berasal dari layanan S3 dan RDS di wilayah Anda.
+ **`kms:Decrypt`**: Diperlukan untuk melakukan dekripsi objek terenkripsi sehingga datanya dapat dibaca oleh Neptunus.
+ **`kms:GenerateDataKey`**: Juga diperlukan oleh S3 API yang digunakan untuk mengambil objek yang akan dibaca.
```
{
"Sid": "NeptuneQueryAccess",
"Effect": "Allow",
"Action": [
"neptune-db:ReadDataViaQuery",
"neptune-db:WriteDataViaQuery",
"neptune-db:DeleteDataViaQuery"
],
"Resource": "arn:aws:neptune-db:::/*"
},
{
"Sid": "NeptuneS3Access",
"Effect": "Allow",
"Action": [
"s3:ListBucket",
"s3:GetObject"
],
"Resource": [
"arn:aws:s3:::neptune-read-bucket",
"arn:aws:s3:::neptune-read-bucket/*"
]
},
{
"Sid": "NeptuneS3KMSAccess",
"Effect": "Allow",
"Action": [
"kms:Decrypt",
"kms:GenerateDataKey"
],
"Resource": "arn:aws:kms:::key/",
"Condition": {
"StringEquals": {
"kms:ViaService": [
"s3..amazonaws.com",
"rds..amazonaws.com"
]
}
}
}
```
## Prasyarat penting
Izin dan prasyarat ini memastikan integrasi data S3 yang aman dan andal ke dalam kueri OpenCypher, sambil mempertahankan kontrol akses yang tepat dan langkah-langkah perlindungan data.
+ **Autentikasi IAM**: Fitur ini hanya didukung untuk cluster Neptunus dengan otentikasi IAM diaktifkan. Lihat [Mengamankan database Amazon Neptunus](security.md) untuk petunjuk terperinci tentang cara membuat dan menyambung ke kluster berkemampuan autentikasi IAM.
+ **Titik akhir VPC**:
+ Titik akhir VPC tipe Gateway untuk Amazon S3 diperlukan untuk memungkinkan Neptunus berkomunikasi dengan Amazon S3.
+ Untuk menggunakan AWS KMS enkripsi kustom dalam kueri, titik akhir VPC tipe antarmuka untuk diperlukan agar AWS KMS Neptunus dapat berkomunikasi dengannya. AWS KMS
+ Untuk petunjuk mendetail tentang cara mengonfigurasi titik akhir ini, lihat [Membuat Titik Akhir VPC Amazon S3](bulk-load-tutorial-IAM.md).