Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Catatan tentang Kepatuhan Standar Amazon Neptune
Amazon Neptune mematuhi standar yang berlaku dalam menerapkan bahasa kueri grafik Gremlin dan SPARQL dalam banyak kasus.
Bagian ini menggambarkan standar serta area-area di mana Neptune meluas atau menyimpang dari standar dan area tersebut.
**Topics**
+ [Kepatuhan standar Gremlin di Amazon Neptune](access-graph-gremlin-differences.md)
+ [Kepatuhan standar SPARQL di Amazon Neptunus](feature-sparql-compliance.md)
+ [Kepatuhan spesifikasi OpenCypher di Amazon Neptunus](feature-opencypher-compliance.md)
# Kepatuhan standar Gremlin di Amazon Neptune
Bagian berikut memberikan gambaran umum tentang implementasi Neptunus Gremlin dan bagaimana hal itu berbeda dari implementasi Apache. TinkerPop
Neptunus mengimplementasikan beberapa langkah Gremlin secara native di mesinnya, dan menggunakan implementasi TinkerPop Apache Gremlin untuk memproses yang lain (lihat). [Dukungan langkah Gremlin asli di Amazon Neptune](gremlin-step-support.md)
**catatan**
Untuk beberapa contoh konkret dari perbedaan implementasi ini yang ditunjukkan di Konsol Gremlin dan Amazon Neptune, lihat bagian [Menggunakan Gremlin untuk mengakses data grafik di Amazon Neptunus](get-started-graph-gremlin.md) dari Quick Start.
**Topics**
+ [Standar yang Berlaku untuk Gremlin](#feature-gremlin-applicable-standards)
+ [Variabel dan parameter dalam skrip](#feature-gremlin-differences-variables)
+ [TinkerPop enumerasi](#feature-gremlin-differences-tinkerpop)
+ [Kode Java](#feature-gremlin-differences-java)
+ [Properti pada elemen](#feature-gremlin-differences-properties-on-elements)
+ [Eksekusi skrip](#feature-gremlin-differences-script)
+ [Sesi](#feature-gremlin-differences-sessions)
+ [Transaksi](#feature-gremlin-differences-transactions)
+ [Vertex dan tepi IDs](#feature-gremlin-differences-vertex-edge-ids)
+ [Disediakan pengguna IDs](#feature-gremlin-differences-user-supplied-ids)
+ [Properti Vertex IDs](#feature-gremlin-differences-vertex-property-ids)
+ [Kardinalitas sifat simpul](#feature-gremlin-differences-vertex-property-cardinality)
+ [Memperbarui properti vertex](#feature-gremlin-differences-vertex-property-update)
+ [Label](#feature-gremlin-differences-labels)
+ [Karakter melarikan diri](#feature-gremlin-differences-escapes)
+ [Keterbatasan Groovy](#feature-gremlin-differences-groovy)
+ [Serialisasi](#feature-gremlin-differences-serialization)
+ [Langkah-langkah Lambda](#feature-gremlin-differences-lambda)
+ [Metode Gremlin yang tidak didukung](#feature-gremlin-differences-unsupported-methods)
+ [Langkah-langkah Gremlin yang tidak didukung](#feature-gremlin-differences-unsupported-steps)
+ [Fitur grafik Gremlin di Neptunus](#gremlin-api-reference-features)
## Standar yang Berlaku untuk Gremlin
+ Bahasa Gremlin didefinisikan oleh [ TinkerPop Dokumentasi Apache](http://tinkerpop.apache.org/docs/current/reference/) dan TinkerPop implementasi Apache dari Gremlin bukan oleh spesifikasi formal.
+ Untuk format numerik, Gremlin mengikuti standar IEEE 754 ([IEEE 754-2019 - Standar IEEE untuk Floating-Point Arithmetic](https://standards.ieee.org/content/ieee-standards/en/standard/754-2019.html). Untuk informasi selengkapnya, lihat juga [halaman Wikipedia IEEE 754](https://en.wikipedia.org/wiki/IEEE_754)).
## Variabel dan parameter dalam skrip
Jika variabel pra-terikat bersangkutan, objek traversal `g` adalah Pre-bound di Neptunus, dan objek tidak didukung. `graph`
Meskipun Neptunus tidak mendukung variabel Gremlin atau parameterisasi dalam skrip, Anda mungkin sering menemukan skrip sampel untuk Server Gremlin di Internet yang berisi deklarasi variabel, seperti:
```
String query = "x = 1; g.V(x)";
List results = client.submit(query).all().get();
```
Ada juga banyak contoh yang menggunakan [parameterisasi](https://tinkerpop.apache.org/docs/current/reference/#parameterized-scripts) (atau binding) saat mengirimkan kueri, seperti:
```
Map params = new HashMap<>();
params.put("x",1);
String query = "g.V(x)";
List results = client.submit(query).all().get();
```
Contoh parameter biasanya dikaitkan dengan peringatan tentang hukuman kinerja karena tidak membuat parameter bila memungkinkan. Ada banyak sekali contoh seperti itu TinkerPop yang mungkin Anda temui, dan semuanya terdengar cukup meyakinkan tentang perlunya membuat parameter.
Namun, baik fitur deklarasi variabel dan fitur parameterisasi (bersama dengan peringatan) hanya berlaku untuk Server TinkerPop Gremlin saat menggunakan. `GremlinGroovyScriptEngine` Mereka tidak berlaku ketika Gremlin Server menggunakan tata bahasa `gremlin-language` ANTLR Gremlin untuk mengurai kueri. Tata bahasa ANTLR tidak mendukung deklarasi variabel atau parameterisasi, jadi saat menggunakan ANTLR, Anda tidak perlu khawatir gagal membuat parameter. Karena tata bahasa ANTLR adalah komponen yang lebih baru TinkerPop, konten lama yang mungkin Anda temui di Internet umumnya tidak mencerminkan perbedaan ini.
Neptunus menggunakan tata bahasa ANTLR di mesin pemrosesan kueri daripada`GremlinGroovyScriptEngine`, sehingga tidak mendukung variabel atau parameterisasi atau properti. `bindings` Akibatnya, masalah yang terkait dengan kegagalan parameterisasi tidak berlaku di Neptunus. Menggunakan Neptunus, sangat aman hanya untuk mengirimkan kueri apa adanya di mana seseorang biasanya akan membuat parameter. Akibatnya, contoh sebelumnya dapat disederhanakan tanpa penalti kinerja sebagai berikut:
```
String query = "g.V(1)";
List results = client.submit(query).all().get();
```
## TinkerPop enumerasi
Neptune tidak mendukung nama kelas yang memenuhi syarat untuk nilai pencacahan. Misalnya, Anda harus menggunakan `single` dan bukan `org.apache.tinkerpop.gremlin.structure.VertexProperty.Cardinality.single` dalam permintaan Groovy Anda.
Jenis pencacahan ditentukan oleh jenis parameter.
Tabel berikut menunjukkan nilai enumerasi yang diizinkan dan nama yang TinkerPop sepenuhnya memenuhi syarat terkait.
| Nilai yang Diizinkan | Kelas |
| --- |--- |
| id, key, label, value | [org.apache.tinkerpop.gremlin.structure.t](https://tinkerpop.apache.org/javadocs/current/core/org/apache/tinkerpop/gremlin/structure/T.html) |
| T.id, T.key, T.label, T.value | [org.apache.tinkerpop.gremlin.structure.t](https://tinkerpop.apache.org/javadocs/current/core/org/apache/tinkerpop/gremlin/structure/T.html) |
| set, single | [org.apache.tinkerpop.gremlin.structure. VertexProperty.Kardinalitas](https://tinkerpop.apache.org/javadocs/current/core/org/apache/tinkerpop/gremlin/structure/VertexProperty.Cardinality.html) |
| asc, desc, shuffle | [org.apache.tinkerpop.gremlin.process.traversal.order](https://tinkerpop.apache.org/javadocs/3.7.2/full/org/apache/tinkerpop/gremlin/process/traversal/Order.html) |
| Order.asc, Order.desc, Order.shuffle | [org.apache.tinkerpop.gremlin.process.traversal.order](https://tinkerpop.apache.org/javadocs/3.7.2/full/org/apache/tinkerpop/gremlin/process/traversal/Order.html) |
| global, local | [org.apache.tinkerpop.gremlin.process.traversal.scope](https://tinkerpop.apache.org/javadocs/3.7.2/core/org/apache/tinkerpop/gremlin/process/traversal/Scope.html) |
| Scope.global, Scope.local | [org.apache.tinkerpop.gremlin.process.traversal.scope](https://tinkerpop.apache.org/javadocs/3.7.2/core/org/apache/tinkerpop/gremlin/process/traversal/Scope.html) |
| all, first, last, mixed | [org.apache.tinkerpop.gremlin.process.traversal.pop](https://tinkerpop.apache.org/javadocs/3.7.2/core/org/apache/tinkerpop/gremlin/process/traversal/Pop.html) |
| normSack | [org.apache.tinkerpop.gremlin.process.traversal. SackFunctions](https://tinkerpop.apache.org/javadocs/3.7.2/core/org/apache/tinkerpop/gremlin/process/traversal/SackFunctions.Barrier.html).Penghalang |
| addAll, and, assign, div, max, min, minus, mult, or, sum, sumLong | [org.apache.tinkerpop.gremlin.process.traversal.operator](https://tinkerpop.apache.org/javadocs/3.7.2/core/org/apache/tinkerpop/gremlin/process/traversal/Operator.html) |
| keys, values | [org.apache.tinkerpop.gremlin.structure.column](https://tinkerpop.apache.org/javadocs/3.7.2/core/org/apache/tinkerpop/gremlin/structure/Column.html) |
| BOTH, IN, OUT | [org.apache.tinkerpop.gremlin.structure.direction](https://tinkerpop.apache.org/javadocs/3.7.2/core/org/apache/tinkerpop/gremlin/structure/Direction.html) |
| any, none | [org.apache.tinkerpop.gremlin.process.traversal.step. TraversalOptionParent.Pilih](https://tinkerpop.apache.org/javadocs/current/full/org/apache/tinkerpop/gremlin/process/traversal/Pick.html) |
## Kode Java
Neptunus tidak mendukung panggilan ke metode yang ditentukan oleh panggilan perpustakaan Java atau Java arbitrer selain Gremlin yang didukung. APIs Misalnya, `java.lang.*`, `Date()`, dan `g.V().tryNext().orElseGet()` tidak diperbolehkan.
## Properti pada elemen
Neptunus tidak mendukung bendera `materializeProperties` yang diperkenalkan di 3.7.0 untuk mengembalikan TinkerPop properti pada elemen. Akibatnya, Neptunus masih hanya akan mengembalikan simpul atau tepi sebagai referensi hanya dengan dan. `id` `label`
## Eksekusi skrip
Semua kueri harus dimulai dengan `g`, objek traversal.
Dalam pengiriman kueri String, beberapa traversals dapat dikeluarkan terpisah dengan titik koma (`;`) atau karakter baris baru (`\n`). Untuk dieksekusi, setiap pernyataan selain yang terakhir harus diakhiri dengan langkah `.iterate()`. Hanya data dari traversal akhir yang dikembalikan. Perhatikan bahwa ini tidak berlaku untuk pengiriman ByteCode kueri GLV.
## Sesi
Sesi di Neptune dibatasi hanya durasi 10 menit. Lihat [Sesi berbasis skrip Gremlin](access-graph-gremlin-sessions.md) dan [Referensi TinkerPop Sesi](https://tinkerpop.apache.org/docs/current/reference/#console-sessions) untuk informasi lebih lanjut.
## Transaksi
Neptune membuka transaksi baru pada awal setiap traversal Gremlin dan menutup transaksi setelah berhasil menyelesaikan traversal. Transaksi di-rollback ketika ada kesalahan.
Beberapa pernyataan dipisahkan dengan titik koma (`;`) atau karakter baris baru (`\n`) disertakan dalam satu transaksi. Setiap pernyataan selain yang terakhir harus diakhiri dengan langkah `next()` yang akan dieksekusi. Hanya data dari traversal akhir yang dikembalikan.
Logika transaksi manual menggunakan `tx.commit()` dan `tx.rollback()` tidak didukung.
**penting**
Ini ***hanya*** berlaku untuk metode di mana Anda mengirim kueri Gremlin sebagai ***string teks*** (lihat[Transaksi Gremlin](access-graph-gremlin-transactions.md)).
## Vertex dan tepi IDs
Neptunus Gremlin Vertex dan Edge harus bertipe. IDs `String` String ID ini mendukung karakter Unicode, dan ukurannya tidak boleh melebihi 55 MB.
Disediakan pengguna IDs didukung, tetapi opsional dalam penggunaan normal. Jika Anda tidak memberikan ID saat menambahkan simpul atau tepi, Neptunus menghasilkan UUID dan mengubahnya menjadi string, dalam bentuk seperti ini:. `"48af8178-50ce-971a-fc41-8c9a954cea62"` Ini UUIDs tidak sesuai dengan standar RFC, jadi jika Anda membutuhkan standar, UUIDs Anda harus membuatnya secara eksternal dan menyediakannya saat Anda menambahkan simpul atau tepi.
**catatan**
Perintah `Load` Neptunus mengharuskan Anda IDs menyediakan, menggunakan bidang \$1id dalam format **CSV** Neptunus.
## Disediakan pengguna IDs
Disediakan pengguna IDs diizinkan di Neptunus Gremlin dengan ketentuan berikut.
+ Disediakan IDs adalah opsional.
+ Hanya vertex dan edge yang didukung.
+ Hanya tipe `String` yang didukung.
Untuk membuat vertex baru dengan ID kustom, gunakan langkah `property` dengan Kata Kunci `id`: `g.addV().property(id, 'customid')`.
**catatan**
Jangan menaruh tanda kutip di sekitar Kata Kunci `id`. Ini mengacu pada`T.id`.
Semua simpul IDs harus unik, dan semua tepi IDs harus unik. Namun, Neptune tidak mengizinkan vertex dan edge untuk memiliki ID yang sama.
Jika Anda mencoba untuk membuat sebuah vertex baru menggunakan `g.addV()` dan sebuah vertex dengan ID sudah ada, operasi gagal. Pengecualian untuk ini adalah jika Anda menentukan label baru untuk vertex tersebut, operasi berhasil tetapi menambahkan label baru dan properti tambahan yang ditentukan ke vertex yang ada. Tidak ada yang ditimpa. Sebuah vertex baru tidak dibuat. ID vertex tidak berubah dan tetap unik.
Misalnya, perintah konsol Gremlin berikut berhasil:
```
gremlin> g.addV('label1').property(id, 'customid')
gremlin> g.addV('label2').property(id, 'customid')
gremlin> g.V('customid').label()
==>label1::label2
```
## Properti Vertex IDs
Properti Vertex IDs dihasilkan secara otomatis dan dapat muncul sebagai angka positif atau negatif ketika ditanyakan.
## Kardinalitas sifat simpul
Neptune mendukung kardinalitas rangkaian dan kardinalitas tunggal. Jika tidak ditentukan, kardinalitas rangkaian dipilih. Ini berarti bahwa jika Anda menetapkan nilai properti, ia menambahkan nilai baru ke properti, tetapi hanya jika itu belum muncul di set nilai. Ini adalah nilai pencacahan Gremlin [Set](https://tinkerpop.apache.org/javadocs/3.7.2/core/org/apache/tinkerpop/gremlin/structure/VertexProperty.Cardinality.html).
`List` tidak didukung. Untuk informasi lebih lanjut tentang kardinalitas properti, lihat topik [Vertex](https://tinkerpop.apache.org/javadocs/3.7.2/core/org/apache/tinkerpop/gremlin/structure/Vertex.html#property-org.apache.tinkerpop.gremlin.structure.VertexProperty.Cardinality-java.lang.String-V-java.lang.Object...-) di Gremlin. JavaDoc
## Memperbarui properti vertex
Untuk memperbarui nilai properti tanpa menambahkan nilai tambahan untuk set nilai, tentukan kardinalitas `single` dalam langkah `property`.
```
g.V('exampleid01').property(single, 'age', 25)
```
Ini akan menghapus semua nilai yang ada untuk properti tersebut.
## Label
Neptune mendukung beberapa label untuk sebuah vertex. Ketika Anda membuat label, Anda dapat menentukan beberapa label dengan memisahkannya dengan `::`. Sebagai contoh, `g.addV("Label1::Label2::Label3")` menambahkan sebuah vertex dengan tiga label yang berbeda. Langkah `hasLabel` cocok dengan vertex ini dengan salah satu dari tiga label tersebut: `hasLabel("Label1")`, `hasLabel("Label2")`, dan `hasLabel("Label3")`.
**penting**
Pembatas `::` dicadangkan untuk penggunaan ini saja. Anda tidak dapat menentukan beberapa label di langkah `hasLabel`. Misalnya, `hasLabel("Label1::Label2")` tidak cocok dengan apa pun.
## Karakter melarikan diri
Neptune menyelesaikan semua karakter escape seperti yang dijelaskan dalambagian [Meng-Escape Karakter Khusus]( http://groovy-lang.org/syntax.html#_escaping_special_characters) dari dokumentasi bahasa Apache Groovy.
## Keterbatasan Groovy
Neptune tidak mendukung perintah Groovy yang tidak dimulai dengan `g`. Ini termasuk matematika (misalnya, `1+1`), panggilan sistem (misalnya, `System.nanoTime()`), dan definisi variabel (misalnya, `1+1`).
**penting**
Neptune tidak mendukung nama kelas yang memenuhi syarat. Misalnya, Anda harus menggunakan `single` dan bukan `org.apache.tinkerpop.gremlin.structure.VertexProperty.Cardinality.single` dalam permintaan Groovy Anda.
## Serialisasi
Neptune mendukung serialisasi berikut berdasarkan jenis MIME yang diminta.
Neptunus mengekspos semua serializer TinkerPop yang melakukannya, dengan dukungan untuk berbagai versi dan konfigurasi GraphSon dan. GraphBinary Meskipun ada banyak pilihan yang ada, panduan untuk digunakan sangat mudah:
+ Jika Anda menggunakan TinkerPop driver Apache, pilih default untuk driver tanpa menentukan satu secara eksplisit. Kecuali Anda memiliki alasan yang sangat spesifik untuk melakukannya, Anda mungkin tidak perlu menentukan serializer dalam inisialisasi driver Anda. Secara umum, default yang digunakan oleh driver adalah`application/vnd.graphbinary-v1.0`.
+ Jika Anda terhubung ke Neptunus melalui HTTP, prioritaskan penggunaan `application/vnd.gremlin-v3.0+json;types=false` sebagai tipe tertanam dalam versi alternatif GraphSon 3 membuatnya rumit untuk dikerjakan.
+ `application/vnd.graphbinary-v1.0-stringd`Umumnya hanya berguna bila digunakan bersama dengan [Gremlin Console](https://docs.aws.amazon.com//neptune/latest/userguide/access-graph-gremlin-console.html) karena mengubah semua hasil menjadi representasi string untuk tampilan sederhana.
+ Format yang tersisa tetap ada karena alasan lama dan biasanya tidak boleh digunakan dengan driver tanpa alasan yang jelas.
| | | |
| --- |--- |--- |
| Jenis MIME | Serialisasi | Konfigurasi |
| `application/vnd.gremlin-v1.0+json` | GraphSONMessageSerializerV1 | ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV1] |
| `application/vnd.gremlin-v1.0+json;types=false` | GraphSONUntypedMessageSerializerV1 | ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV1] |
| `application/vnd.gremlin-v2.0+json` | GraphSONMessageSerializerV2 | ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV2] |
| `application/vnd.gremlin-v2.0+json;types=false` | GraphSONUntypedMessageSerializerV2 | ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV2] |
| `application/vnd.gremlin-v3.0+json` | GraphSONMessageSerializerV3 | ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV3] |
| `application/vnd.gremlin-v3.0+json;types=false` | GraphSONUntypedMessageSerializerV3 | ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV3] |
| `application/json` | GraphSONUntypedMessageSerializerV3 | ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV1] |
| `application/vnd.graphbinary-v1.0` | GraphBinaryMessageSerializerV1 | |
| `application/vnd.graphbinary-v1.0-stringd` | GraphBinaryMessageSerializerV1 | serializeResultToString: true |
| `application/vnd.gremlin-v1.0+json` | GraphSONMessageSerializerGremlinV1 | ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV1] |
| `application/vnd.gremlin-v2.0+json` | GraphSONMessageSerializerV2(hanya bekerja dengan WebSockets) | ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV2] |
| `application/vnd.gremlin-v3.0+json` | `GraphSONMessageSerializerV3` | |
| `application/json` | GraphSONMessageSerializerV3 | ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV3] |
| `application/vnd.graphbinary-v1.0` | GraphBinaryMessageSerializerV1 | |
**catatan**
Tabel serializer yang ditampilkan di sini mengacu pada penamaan pada 3.7.0. TinkerPop Jika Anda ingin tahu lebih banyak tentang perubahan ini, silakan lihat [dokumentasi TinkerPop pemutakhiran](https://tinkerpop.apache.org/docs/current/upgrade/#_serializer_renaming). Dukungan serialisasi Gryo tidak digunakan lagi di 3.4.3 dan secara resmi dihapus di 3.6.0. Jika Anda secara eksplisit menggunakan Gryo atau pada versi driver yang menggunakannya secara default, maka Anda harus beralih ke GraphBinary atau meningkatkan driver Anda.
## Langkah-langkah Lambda
Neptune tidak mendukung Lambda Steps.
## Metode Gremlin yang tidak didukung
Neptune tidak mendukung metode Gremlin berikut:
+ `org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal.program(org.apache.tinkerpop.gremlin.process.computer.VertexProgram)`
+ `org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal.sideEffect(java.util.function.Consumer)`
+ `org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal.from(org.apache.tinkerpop.gremlin.structure.Vertex)`
+ `org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal.to(org.apache.tinkerpop.gremlin.structure.Vertex)`
Misalnya, traversal berikut tidak diperbolehkan: `g.V().addE('something').from(__.V().next()).to(__.V().next())`.
**penting**
Ini ***hanya*** berlaku untuk metode di mana Anda mengirim kueri Gremlin sebagai ***string teks***.
## Langkah-langkah Gremlin yang tidak didukung
Neptune tidak mensupport langkah-langkah Gremlin berikut:
+ [Langkah Gremlin io ()](http://tinkerpop.apache.org/docs/3.7.2/reference/#io-step) hanya didukung sebagian di Neptunus. Ini dapat digunakan dalam konteks baca, seperti dalam`g.io((url)).read()`, tetapi tidak untuk menulis.
## Fitur grafik Gremlin di Neptunus
Implementasi Gremlin Neptune tidak mengekspos`graph`objek. Tabel berikut mencantumkan fitur Gremlin dan menunjukkan apakah Neptunus mendukungnya atau tidak.
### Dukungan Neptunus untuk fitur `graph`
Fitur grafik Neptunus, jika didukung, sama seperti yang akan dikembalikan oleh perintah. `graph.features()`
|
|
| Fitur grafik | Diaktifkan? |
| --- |--- |
| Transactions | true |
| ThreadedTransactions | SALAH |
| Computer | SALAH |
| Persistence | true |
| ConcurrentAccess | true |
### Dukungan Neptunus untuk fitur variabel
|
|
| Fitur variabel | Diaktifkan? |
| --- |--- |
| Variables | false |
| SerializableValues | false |
| UniformListValues | false |
| BooleanArrayValues | false |
| DoubleArrayValues | false |
| IntegerArrayValues | false |
| StringArrayValues | false |
| BooleanValues | false |
| ByteValues | false |
| DoubleValues | false |
| FloatValues | false |
| IntegerValues | false |
| LongValues | false |
| MapValues | false |
| MixedListValues | false |
| StringValues | false |
| ByteArrayValues | false |
| FloatArrayValues | false |
| LongArrayValues | false |
### Dukungan Neptunus untuk fitur vertex
|
|
| Fitur Vertex | Diaktifkan? |
| --- |--- |
| MetaProperties | false |
| DuplicateMultiProperties | SALAH |
| AddVertices | true |
| RemoveVertices | true |
| MultiProperties | true |
| UserSuppliedIds | true |
| AddProperty | true |
| RemoveProperty | true |
| NumericIds | SALAH |
| StringIds | BETUL |
| UuidIds | SALAH |
| CustomIds | false |
| AnyIds | false |
### Dukungan Neptunus untuk fitur properti vertex
|
|
| Fitur properti Vertex | Diaktifkan? |
| --- |--- |
| UserSuppliedIds | SALAH |
| AddProperty | true |
| RemoveProperty | true |
| NumericIds | true |
| StringIds | true |
| UuidIds | SALAH |
| CustomIds | false |
| AnyIds | SALAH |
| Properties | BETUL |
| SerializableValues | SALAH |
| UniformListValues | false |
| BooleanArrayValues | false |
| DoubleArrayValues | false |
| IntegerArrayValues | false |
| StringArrayValues | SALAH |
| BooleanValues | true |
| ByteValues | true |
| DoubleValues | true |
| FloatValues | true |
| IntegerValues | true |
| LongValues | true |
| MapValues | SALAH |
| MixedListValues | SALAH |
| StringValues | BETUL |
| ByteArrayValues | SALAH |
| FloatArrayValues | false |
| LongArrayValues | false |
### Dukungan Neptunus untuk fitur tepi
|
|
| Fitur tepi | Diaktifkan? |
| --- |--- |
| AddEdges | true |
| RemoveEdges | true |
| UserSuppliedIds | true |
| AddProperty | true |
| RemoveProperty | true |
| NumericIds | SALAH |
| StringIds | BETUL |
| UuidIds | SALAH |
| CustomIds | false |
| AnyIds | false |
### Dukungan Neptunus untuk fitur properti edge
|
|
| Fitur properti tepi | Diaktifkan? |
| --- |--- |
| Properties | true |
| SerializableValues | SALAH |
| UniformListValues | false |
| BooleanArrayValues | false |
| DoubleArrayValues | false |
| IntegerArrayValues | false |
| StringArrayValues | SALAH |
| BooleanValues | true |
| ByteValues | true |
| DoubleValues | true |
| FloatValues | true |
| IntegerValues | true |
| LongValues | true |
| MapValues | SALAH |
| MixedListValues | SALAH |
| StringValues | BETUL |
| ByteArrayValues | SALAH |
| FloatArrayValues | false |
| LongArrayValues | false |
# Kepatuhan standar SPARQL di Amazon Neptunus
Setelah mencantumkan standar SPARQL yang berlaku, bagian berikut memberikan rincian spesifik tentang bagaimana implementasi SPARQL Neptunus meluas atau menyimpang dari standar tersebut.
**Topics**
+ [Standar Berlaku untuk SPARQL](#feature-sparql-applicable-standards)
+ [Default Namespace Awalan di Neptune SPARQL](#sparql-default-prefixes)
+ [Grafik Standar SPARQL dan Grafik Bernama](#sparql-default-graph)
+ [Fungsi XPath Konstruktor SPARQL Didukung oleh Neptunus](#access-graph-sparql-xpath-constructors)
+ [Basis IRI default untuk kueri dan pembaruan](#opencypher-compliance-default-iri)
+ [XSD: Nilai DateTime di Neptune](#access-graph-sparql-xsd-date-time)
+ [Neptune Penanganan Nilai Titik Terapung Khusus](#feature-overview-special-values-comparisons)
+ [Batasan Neptune Nilai Sewenang-Panjang](#feature-overview-arbitrary-length-values)
+ [Neptune Memperpanjang Perbandingan Sama di SPARQL](#feature-overview-sparql-not-equal)
+ [Penanganan Out-of-Range Literal di Neptunus SPARQL](#feature-overview-sparql-out-of-range)
Amazon Neptune mematuhi standar berikut dalam menerapkan bahasa kueri grafik SPARQL.
## Standar Berlaku untuk SPARQL
+ SPARQL didefinisikan oleh rekomendasi W3C [Bahasa Kueri SPARQL 1.1](https://www.w3.org/TR/sparql11-query/) 21 Maret 2013.
+ Protokol pembaruan dan bahasa kueri SPARQL didefinisikan oleh spesifikasi W3C [Pembaruan SPARQL 1.1](https://www.w3.org/TR/sparql11-update/).
+ Untuk format numerik, SPARQL mengikuti spesifikasi [Bahasa Definisi Skema XML W3C (XSD) 1.1 Bagian 2: Tipe data](https://www.w3.org/TR/xmlschema11-2/), yang konsisten dengan spesifikasi IEEE 754 ([IEEE 754-2019 - Standar IEEE untuk Floating-Point Arithmetic](https://standards.ieee.org/content/ieee-standards/en/standard/754-2019.html). Untuk informasi selengkapnya, lihat juga [halaman Wikipedia IEEE 754](https://en.wikipedia.org/wiki/IEEE_754)). Namun, fitur yang diperkenalkan setelah versi `IEEE 754-1985` tidak termasuk dalam spesifikasi.
## Default Namespace Awalan di Neptune SPARQL
Neptune mendefinisikan awalan berikut secara default untuk digunakan dalam kueri SPARQL. Untuk informasi selengkapnya, lihat [Nama Prefiks](https://www.w3.org/TR/sparql11-query/#prefNames) dalam spesifikasi SPARQL.
+ `rdf` – `http://www.w3.org/1999/02/22-rdf-syntax-ns#`
+ `rdfs` – `http://www.w3.org/2000/01/rdf-schema#`
+ `owl` – `http://www.w3.org/2002/07/owl#`
+ `xsd` – `http://www.w3.org/2001/XMLSchema#`
## Grafik Standar SPARQL dan Grafik Bernama
Amazon Neptune mengasosiasikan setiap tripel dengan grafik bernama. Grafik default ditetapkan sebagai gabungan dari semua grafik bernama.
**Grafik Default untuk Query**
Jika Anda mengirimkan kueri SPARQL tanpa secara eksplisit menentukan grafik melalui kata kunci `GRAPH` atau konstruksi seperti `FROM NAMED`, Neptune selalu menganggap semua tripel dalam instans DB Anda. Misalnya, kueri berikut mengembalikan semua tripel dari titik akhir Neptune SPARQL:
`SELECT * WHERE { ?s ?p ?o }`
Tripel yang muncul di lebih dari satu grafik dikembalikan hanya sekali.
Untuk informasi tentang spesifikasi grafik default, lihat bagian [Set Data RDF](https://www.w3.org/TR/sparql11-query/#rdfDataset) dari spesifikasi Bahasa Kueri SPARQL 1.1.
**Menentukan grafik bernama untuk Loading, menyisipkan, atau update**
Jika Anda tidak menentukan grafik bernama ketika memuat, memasukkan, atau memperbarui tripel, Neptune menggunakan grafik bernama fallback yang ditentukan oleh URI, `http://aws.amazon.com/neptune/vocab/v01/DefaultNamedGraph`.
Saat Anda mengeluarkan permintaan `Load` Neptune menggunakan format berbasis triple, Anda dapat menentukan grafik bernama untuk menggunakan untuk semua triple dengan menggunakan parameter `parserConfiguration: namedGraphUri`. Untuk informasi tentang menggunakan sintaks perintah `Load`, lihat [Perintah Loader Neptune](load-api-reference-load.md).
**penting**
Jika Anda tidak menggunakan parameter ini, dan Anda tidak menentukan grafik bernama, URI mundur digunakan: `http://aws.amazon.com/neptune/vocab/v01/DefaultNamedGraph`.
Grafik bernama mundur ini juga digunakan jika Anda memuat triple melalui `SPARQL UPDATE` tanpa secara eksplisit memberikan target grafik bernama.
Anda dapat menggunakan format berbasis paha depan N-Quads untuk menentukan grafik bernama untuk setiap triple dalam database.
**catatan**
Menggunakan N-Quads memungkinkan Anda untuk meninggalkan grafik bernama kosong. Dalam kasus ini, `http://aws.amazon.com/neptune/vocab/v01/DefaultNamedGraph` digunakan.
Anda dapat mengganti grafik bernama default untuk N-Quads menggunakan opsi konfigurasi parser `namedGraphUri`.
## Fungsi XPath Konstruktor SPARQL Didukung oleh Neptunus
Standar SPARQL memungkinkan mesin SPARQL untuk mendukung serangkaian fungsi konstruktor yang dapat diperluas. XPath Neptune saat ini mendukung fungsi konstruktor berikut, di mana `xsd` didefinisikan sebagai `http://www.w3.org/2001/XMLSchema#`:
+ `xsd:boolean`
+ `xsd:integer`
+ `xsd:double`
+ `xsd:float`
+ `xsd:decimal`
+ `xsd:long`
+ `xsd:unsignedLong`
## Basis IRI default untuk kueri dan pembaruan
Karena cluster Neptunus memiliki beberapa titik akhir yang berbeda, menggunakan URL permintaan kueri atau pembaruan sebagai IRI dasar dapat menyebabkan hasil yang tidak terduga saat menyelesaikan relatif. IRIs
Pada [rilis mesin 1.2.1.0](engine-releases-1.2.1.0.md), Neptunus menggunakan IRI `http://aws.amazon.com/neptune/default/` sebagai basis jika basis eksplisit IRI bukan bagian dari permintaan.
Dalam permintaan berikut, basis IRI adalah bagian dari permintaan:
```
BASE
INSERT DATA { "n1" }
BASE
SELECT * { ?p ?o }
```
Dan hasilnya adalah:
```
?p ?o
http://example.org/default/id n1
```
Namun, dalam permintaan ini, tidak ada IRI dasar yang disertakan:
```
INSERT DATA { "n1" }
SELECT * { ?p ?o }
```
Dalam hal ini, hasilnya adalah:
```
?p ?o
http://aws.amazon.com/neptune/default/id n1
```
## XSD: Nilai DateTime di Neptune
Untuk alasan kinerja, Neptunus selalu date/time menyimpan nilai sebagai Coordinated Universal Time (UTC). Hal ini membuat perbandingan langsung sangat efisien.
Ini juga berarti bahwa jika Anda memasukkan nilai `dateTime` yang menentukan zona waktu tertentu, Neptune menerjemahkan nilai UTC dan membuang informasi zona waktu tersebut. Kemudian, ketika Anda mengambil nilai `dateTime` nanti, nilai itu dinyatakan dalam UTC, bukan waktu zona waktu asli, dan Anda tidak dapat lagi tahu apa zona waktu aslinya.
## Neptune Penanganan Nilai Titik Terapung Khusus
Neptune menangani nilai-nilai floating-point khusus di SPARQL sebagai berikut.
### SPARQL NaN Penanganan di Neptune
Di Neptune, SPARQL dapat menerima nilai `NaN` dalam kueri. Tidak ada perbedaan antara nilai `NaN` yang mengeluarkan sinyal dan diam. Neptune memperlakukan semua nilai `NaN` sebagai diam.
Secara semantik, tidak ada perbandingan `NaN` adalah mungkin, karena tidak ada yang lebih besar dari, kurang dari, atau sama dengan `NaN`. Ini berarti bahwa nilai `NaN` di satu sisi perbandingan dalam teori tidak pernah cocokdengan *apa pun* di sisi lain.
Namun, [Spesifikasi XSD](https://www.w3.org/TR/xmlschema-2/#double) benar-benar menganggap dua nilai `NaN` `xsd:double` atau `xsd:float` sebagai sama. Neptune mengikuti ini untuk filter `IN`, untuk operator yang sama dalam ekspresi filter, dan untuk semantik pencocokan tepat (memiliki `NaN` dalam posisi objek pola triple).
### SPARQL Penanganan Nilai Tak Terbatas di Neptune
Di Neptune, SPARQL dapat menerima nilai `INF` atau `-INF` dalam kueri. `INF`membandingkan sebagai lebih besar dari nilai numerik lainnya, dan `-INF`membandingkan sebagai kurang dari nilai numerik lainnya.
Dua nilai INF dengan tanda yang cocok dibandingkan sama satu sama lain terlepas dari jenisnya (misalnya, float `-INF` dibandingkan sebagai sama dengan `-INF` ganda).
Tentu saja, tidak ada perbandingan dengan `NaN` adalah mungkin karena tidak ada yang lebih besar dari, kurang dari, atau sama dengan `NaN`.
### Penanganan Nol Negatif SPARQL di Neptune
Neptune menormalkan nilai nol negatif ke nol unsigned. Anda dapat menggunakan nilai nol negatif dalam kueri, tetapi mereka tidak direkam seperti itu dalam database, dan mereka membandingkan sebagai sama dengan nol unsigned.
## Batasan Neptune Nilai Sewenang-Panjang
Neptune membatasi ukuran penyimpanan XSD integer, floating point, dan nilai desimal dalam SPARQL menjadi 64 bit. Menggunakan nilai yang lebih besar menghasilkan `InvalidNumericDataException` kesalahan.
## Neptune Memperpanjang Perbandingan Sama di SPARQL
Standar SPARQL mendefinisikan logika terner untuk ekspresi nilai, di mana ekspresi nilai dapat mengevaluasi `true`, `false`, atau `error`. Semantik default untuk kesetaraan istilah sebagaimana didefinisikan dalam [spesifikasi SPARQL 1.1](https://www.w3.org/TR/sparql11-query/#func-RDFterm-equal)), yang berlaku untuk perbandingan `=` dan `!=` di kondisi `FILTER`, menghasilkan `error` ketika membandingkan tipe data yang tidak secara eksplisit sebanding dalam [tabel operator](https://www.w3.org/TR/sparql11-query/#OperatorMapping) dalam spesifikasi.
Perilaku ini dapat menyebabkan hasil yang tidak intuitif, seperti dalam contoh berikut.
Data
```
"127.0.0.1"^^
```
Permintaan 1:
```
SELECT * WHERE {
?o .
FILTER(?o = "127.0.0.2"^^)
}
```
Permintaan 2:
```
SELECT * WHERE {
?o .
FILTER(?o != "127.0.0.2"^^)
}
```
Dengan semantik SPARQL default yang Neptune digunakan sebelum rilis 1.0.2.1, kedua kueri akan mengembalikan hasil kosong. Alasannya adalah bahwa `?o = "127.0.0.2"^^` ketika dievaluasi untuk `?o := "127.0.0.1"^^` menghasilkan `error` ketimbang `false` karena tidak ada aturan perbandingan eksplisit yang ditentukan untuk tipe data kustom ``. Akibatnya, versi dinegasikan dalam kueri kedua juga menghasilkan `error`. Dalam kedua kueri, `error` menyebabkan solusi kandidat untuk disaring.
Dimulai dengan rilis 1.0.2.1, Neptune telah memperpanjang operator ketidaksetaraan SPARQL sesuai dengan spesifikasi. Lihat [Bagian SPARQL 1.1 pada perluasan operator](https://www.w3.org/TR/sparql11-query/#operatorExtensibility), yang memungkinkan mesin untuk menentukan aturan tambahan tentang cara membandingkan seluruh tipe data yang ditetapkan pengguna dan built-in yang tidak dapat dibandingkan.
Menggunakan opsi ini, Neptune sekarang memperlakukan perbandingan dari setiap dua tipe data yang tidak secara eksplisit didefinisikan dalam tabel pemetaan operator sebagai mengevaluasi ke `true` jika nilai-nilai literal dan tipe data yang secara sintaksis sama, dan false sebaliknya. `error` tidak diproduksi dalam kasus apa pun.
Menggunakan semantik baru ini, kueri kedua akan mengembalikan `"127.0.0.1"^^` alih-alih hasil kosong.
## Penanganan Out-of-Range Literal di Neptunus SPARQL
Semantik XSD mendefinisikan setiap jenis numerik dengan ruang nilainya, kecuali untuk `integer` dan `decimal`. Definisi ini membatasi setiap jenis untuk rentang nilai. Sebagai contoh, kisaran dari kisaran `xsd:byte` adalah dari -128 ke \$1127, inklusif. Setiap nilai di luar kisaran ini dianggap tidak valid.
Jika Anda mencoba menetapkan nilai literal di luar ruang nilai suatu tipe (misalnya, jika Anda mencoba menyetel ke nilai literal 999), Neptunus menerima out-of-range nilai apa adanya, tanpa membulatkan atau memotongnya. `xsd:byte` Tapi itu tidak bertahan sebagai nilai numerik karena jenis yang diberikan tidak bisa mewakilinya.
Artinya, Neptune menerima `"999"^^xsd:byte` meskipun itu adalah nilai di luar kisaran nilai `xsd:byte` yang didefinisikan. Namun, setelah nilai bertahan dalam database, itu hanya dapat digunakan dalam semantik pertandingan tepat, dalam posisi objek dari pola triple. Tidak ada filter rentang yang dapat dijalankan di atasnya karena out-of-range literal tidak diperlakukan sebagai nilai numerik.
Spesifikasi SPARQL 1.1 mendefinisikan [operator rentang](https://www.w3.org/TR/sparql11-query/#OperatorMapping) dalam bentuk `numeric`*operator-*`numeric`,`string`*-operator-*`string`,`literal`*-operator-*`literal`, dan seterusnya. Neptune tidak dapat mengeksekusi operator perbandingan jangkauan seperti `invalid-literal`*-operator-*`numeric-value`.
# Kepatuhan spesifikasi OpenCypher di Amazon Neptunus
[Rilis Amazon Neptunus dari OpenCypher umumnya mendukung klausa, operator, ekspresi, fungsi, dan sintaks yang ditentukan oleh spesifikasi OpenCypher saat ini, yang merupakan Referensi Bahasa Kueri Cypher Versi 9.](https://s3.amazonaws.com/artifacts.opencypher.org/openCypher9.pdf) Keterbatasan dan perbedaan dalam dukungan Neptunus untuk OpenCypher disebut di bawah ini.
Amazon Neptunus juga mendukung beberapa fitur di luar cakupan spesifikasi OpenCypher. Lihat [Ekstensi OpenCypher di Amazon Neptunus](access-graph-opencypher-extensions.md) untuk detailnya.
**catatan**
Implementasi Neo4j Cypher saat ini berisi fungsionalitas yang tidak terkandung dalam spesifikasi OpenCypher yang disebutkan di atas. Jika Anda memigrasikan kode Cypher saat ini ke Neptunus, lihat dan untuk informasi lebih lanjut. [Kompatibilitas Neptunus dengan Neo4j](migration-compatibility.md) [Menulis ulang kueri Cypher untuk dijalankan di OpenCypher di Neptunus](migration-opencypher-rewrites.md)
## Support untuk klausa OpenCypher di Neptune
Neptunus mendukung klausa berikut, kecuali seperti yang disebutkan:
+ `MATCH`— Didukung, kecuali itu *`shortestPath()`* dan *`allShortestPaths()`* saat ini tidak didukung.
+ `OPTIONAL MATCH`
+ *`MANDATORY MATCH`*— saat ini **tidak** didukung di Neptunus. Neptunus, bagaimanapun, [mendukung nilai ID kustom](access-graph-opencypher-extensions.md#opencypher-compliance-custom-ids) dalam kueri. `MATCH`
+ `RETURN`— Didukung, kecuali bila digunakan dengan nilai non-statis untuk `SKIP` atau`LIMIT`. Misalnya, berikut ini saat ini tidak berfungsi:
```
MATCH (n)
RETURN n LIMIT toInteger(rand()) // Does NOT work!
```
+ `WITH`— Didukung, kecuali bila digunakan dengan nilai non-statis untuk `SKIP` atau`LIMIT`. Misalnya, berikut ini saat ini tidak berfungsi:
```
MATCH (n)
WITH n SKIP toInteger(rand())
WITH count() AS count
RETURN count > 0 AS nonEmpty // Does NOT work!
```
+ `UNWIND`
+ `WHERE`
+ `ORDER BY`
+ `SKIP`
+ `LIMIT`
+ `CREATE`— Neptunus memungkinkan Anda [membuat nilai ID kustom](access-graph-opencypher-extensions.md#opencypher-compliance-custom-ids) dalam kueri. `CREATE`
+ `DELETE`
+ `SET`
+ `REMOVE`
+ `MERGE`- Neptunus [mendukung nilai ID kustom](access-graph-opencypher-extensions.md#opencypher-compliance-custom-ids) dalam kueri. `MERGE`
+ *`CALL[YIELD...]`*— saat ini **tidak** didukung di Neptunus.
+ `UNION, UNION ALL`**— kueri hanya-baca didukung, tetapi kueri mutasi saat ini tidak didukung.**
+ `USING`— `USING` didukung dari versi mesin [1.3.2.0](https://docs.aws.amazon.com//neptune/latest/userguide/engine-releases-1.3.2.0.html). Lihat [Petunjuk kueri](https://docs.aws.amazon.com//neptune/latest/userguide/opencypher-query-hints.html) untuk informasi selengkapnya.
## Support untuk operator OpenCypher di Neptune
Neptunus mendukung operator berikut, kecuali seperti yang disebutkan:
**Operator umum**
+ `DISTINCT`
+ `.`Operator untuk mengakses properti peta literal bersarang.
**Operator matematika**
+ Operator `+` tambahan.
+ `-`Operator pengurangan.
+ `*`Operator perkalian.
+ Operator `/` divisi.
+ Operator divisi `%` modulo.
+ Operator `^` eksponensial. *is NOT supported*
**Operator perbandingan**
+ Operator `=` tambahan.
+ Operator `<>` ketidaksetaraan.
+ Operator `<` less-than didukung kecuali jika salah satu argumennya adalah Path, List, atau Map.
+ Operator `>` yang lebih besar dari didukung kecuali jika salah satu argumennya adalah Path, List, atau Map.
+ Operator `<=` less-than-or-equal -to didukung kecuali jika salah satu argumen adalah Path, List, atau Map.
+ Operator `>=` greater-than-or-equal -to didukung kecuali jika salah satu argumen adalah Path, List, atau Map.
+ `IS NULL`
+ `IS NOT NULL`
+ `STARTS WITH`didukung jika data yang dicari adalah string.
+ `ENDS WITH`didukung jika data yang dicari adalah string.
+ `CONTAINS`didukung jika data yang dicari adalah string.
**Operator Boolean**
+ `AND`
+ `OR`
+ `XOR`
+ `NOT`
**Operator String**
+ `+`Operator penggabungan.
**Daftar operator**
+ `+`Operator penggabungan.
+ `IN`(memeriksa keberadaan item dalam daftar)
## Support untuk ekspresi OpenCypher di Neptune
Neptunus mendukung ekspresi berikut, kecuali seperti yang disebutkan:
+ `CASE`
+ `[]`Ekspresi saat ini **tidak** didukung di Neptunus untuk mengakses kunci properti yang dihitung secara dinamis dalam node, relasi, atau peta. Misalnya, berikut ini tidak berfungsi:
```
MATCH (n)
WITH [5, n, {key: 'value'}] AS list
RETURN list[1].name
```
## Support untuk fungsi OpenCypher di Neptune
Neptunus mendukung fungsi-fungsi berikut, kecuali seperti yang disebutkan:
**Fungsi predikat**
+ `exists()`
**Fungsi skalar**
+ `coalesce()`
+ `endNode()`
+ `epochmillis()`
+ `head()`
+ `id()`
+ `last()`
+ `length()`
+ `randomUUID()`
+ `properties()`
+ `removeKeyFromMap`
+ `size()`— metode kelebihan beban saat ini hanya berfungsi untuk ekspresi pola, daftar, dan string
+ `startNode()`
+ `timestamp()`
+ `toBoolean()`
+ `toFloat()`
+ `toInteger()`
+ `type()`
**Fungsi agregasi**
+ `avg()`
+ `collect()`
+ `count()`
+ `max()`
+ `min()`
+ `percentileDisc()`
+ `stDev()`
+ `percentileCont()`
+ `stDevP()`
+ `sum()`
**Daftar fungsi**
+ [`join()`](access-graph-opencypher-extensions.md#opencypher-compliance-join-function)(menggabungkan string dalam daftar menjadi satu string)
+ `keys()`
+ `labels()`
+ `nodes()`
+ `range()`
+ `relationships()`
+ `reverse()`
+ `tail()`
**Fungsi Matematika — Numerik**
+ `abs()`
+ `ceil()`
+ `floor()`
+ `rand()`
+ `round()`
+ `sign()`
**Fungsi matematika — logaritmik**
+ `e()`
+ `exp()`
+ `log()`
+ `log10()`
+ `sqrt()`
**Fungsi matematika — trigonometri**
+ `acos()`
+ `asin()`
+ `atan()`
+ `atan2()`
+ `cos()`
+ `cot()`
+ `degrees()`
+ `pi()`
+ `radians()`
+ `sin()`
+ `tan()`
**Fungsi string**
+ [`join()`](access-graph-opencypher-extensions.md#opencypher-compliance-join-function)(menggabungkan string dalam daftar menjadi satu string)
+ `left()`
+ `lTrim()`
+ `replace()`
+ `reverse()`
+ `right()`
+ `rTrim()`
+ `split()`
+ `substring()`
+ `toLower()`
+ `toString()`
+ `toUpper()`
+ `trim()`
**Fungsi yang ditentukan pengguna**
*User-defined functions*Saat ini **tidak** didukung di Neptunus.
## Detail implementasi OpenCypher khusus Neptunus
[Bagian berikut menjelaskan cara-cara di mana implementasi Neptunus OpenCypher mungkin berbeda dari atau melampaui spesifikasi OpenCypher.](https://s3.amazonaws.com/artifacts.opencypher.org/openCypher9.pdf)
### Evaluasi jalur panjang variabel (VLP) di Neptunus
Variable length path (`VLP`) evaluasi menemukan jalur antara node dalam grafik. Panjang jalur dapat tidak dibatasi dalam kueri. Untuk mencegah siklus, [spesifikasi OpenCypher](https://s3.amazonaws.com/artifacts.opencypher.org/openCypher9.pdf) menetapkan bahwa setiap tepi harus dilalui paling banyak sekali per solusi.
Untuk VLPs, implementasi Neptunus menyimpang dari spesifikasi OpenCypher karena hanya mendukung nilai konstan untuk filter kesetaraan properti. Ambil kueri berikut:
```
MATCH (x)-[:route*1..2 {dist:33, code:x.name}]->(y) return x,y
```
Karena nilai filter kesetaraan `x.name` properti bukan konstanta, kueri ini menghasilkan pesan `UnsupportedOperationException` dengan: `Property predicate over variable-length relationships with non-constant expression is not supported in this release.`
### Dukungan temporal dalam implementasi Neptunus OpenCypher (database Neptunus 1.3.1.0 dan di bawahnya)
Neptunus saat ini menyediakan dukungan terbatas untuk fungsi temporal di OpenCypher. Ini mendukung tipe `DateTime` data untuk tipe temporal.
`datetime()`Fungsi ini dapat digunakan untuk mendapatkan tanggal dan waktu UTC saat ini seperti ini:
```
RETURN datetime() as res
```
Nilai tanggal dan waktu dapat diuraikan dari string dalam `"` format `T` *waktu `"`* *tanggal* di mana *tanggal* dan *waktu* keduanya dinyatakan dalam salah satu formulir yang didukung di bawah ini:
**Format tanggal yang didukung**
+ `yyyy-MM-dd`
+ `yyyyMMdd`
+ `yyyy-MM`
+ `yyyy-DDD`
+ `yyyyDDD`
+ `yyyy`
**Format waktu yang didukung**
+ `HH:mm:ssZ`
+ `HHmmssZ`
+ `HH:mm:ssZ`
+ `HH:mmZ`
+ `HHmmZ`
+ `HHZ`
+ `HHmmss`
+ `HH:mm:ss`
+ `HH:mm`
+ `HHmm`
+ `HH`
Contoh:
```
RETURN datetime('2022-01-01T00:01') // or another example:
RETURN datetime('2022T0001')
```
Perhatikan bahwa semua date/time nilai di Neptunus OpenCypher disimpan dan diambil sebagai nilai UTC.
Neptunus OpenCypher menggunakan jam, `statement` yang berarti bahwa waktu yang sama digunakan sepanjang durasi kueri. Kueri yang berbeda dalam transaksi yang sama dapat menggunakan waktu instan yang berbeda.
Neptunus tidak mendukung penggunaan fungsi dalam panggilan ke. `datetime()` Misalnya, berikut ini tidak akan berfungsi:
```
CREATE (:n {date:datetime(tostring(2021))}) // ---> NOT ALLOWED!
```
Neptunus memang mendukung fungsi `epochmillis()` yang mengubah a to. `datetime` `epochmillis` Contoh:
```
MATCH (n) RETURN epochMillis(n.someDateTime)
1698972364782
```
Neptunus saat ini tidak mendukung fungsi dan operasi lain `DateTime` pada objek, seperti penambahan dan pengurangan.
### Dukungan sementara dalam implementasi Neptunus OpenCypher (Neptunus Analytics dan Neptunus Database 1.3.2.0 dan di atasnya)
Fungsionalitas datetime berikut OpenCypher berlaku untuk Neptune Analytics. Atau, Anda dapat menggunakan parameter labmode `DatetimeMillisecond=enabled` untuk mengaktifkan fungsionalitas datetime berikut pada rilis mesin Neptunus versi 1.3.2.0 dan yang lebih baru. Untuk detail selengkapnya tentang penggunaan fungsi ini di labmode, lihat[Dukungan datetime yang diperpanjang](features-lab-mode.md#labmode-extended-datetime-support).
+ Support untuk milidetik. Datetime literal akan selalu dikembalikan dengan milidetik, bahkan jika milidetik adalah 0. (Perilaku sebelumnya adalah memotong milidetik.)
```
CREATE (:event {time: datetime('2024-04-01T23:59:59Z')})
# Returning the date returns with 000 suffixed representing milliseconds
MATCH(n:event)
RETURN n.time as datetime
{
"results" : [ {
"n" : {
"~id" : "0fe88f7f-a9d9-470a-bbf2-fd6dd5bf1a7d",
"~entityType" : "node",
"~labels" : [ "event" ],
"~properties" : {
"time" : "2024-04-01T23:59:59.000Z"
}
}
} ]
}
```
+ Support untuk memanggil fungsi datetime () melalui properti yang disimpan atau hasil perantara. Misalnya, kueri berikut tidak dimungkinkan sebelum fitur ini.
Datetime () atas properti:
```
// Create node with property 'time' stored as string
CREATE (:event {time: '2024-04-01T23:59:59Z'})
// Match and return this property as datetime
MATCH(n:event)
RETURN datetime(n.time) as datetime
```
Datetime () atas hasil menengah:
```
// Parse datetime from parameter
UNWIND $list as myDate
RETURN datetime(myDate) as d
```
+ Sekarang juga dimungkinkan untuk menyimpan kinerja datetime yang dibuat dalam kasus yang disebutkan di atas.
Menyimpan datetime dari properti string dari satu properti ke properti lainnya:
```
// Create node with property 'time' stored as string
CREATE (:event {time: '2024-04-01T23:59:59Z', name: 'crash'})
// Match and update the same property to datetime type
MATCH(n:event {name: 'crash'})
SET n.time = datetime(n.time)
// Match and update another node's property
MATCH(e:event {name: 'crash'})
MATCH(n:server {name: e.servername})
SET n.time = datetime(e.time)
```
Batch membuat node dari parameter dengan properti datetime:
```
// Batch create from parameter
UNWIND $list as events
CREATE (n:crash) {time: datetime(events.time)}
// Parameter value
{
"x":[
{"time":"2024-01-01T23:59:29", "name":"crash1"},
{"time":"2023-01-01T00:00:00Z", "name":"crash2"}
]
}
```
+ Support untuk subset format ISO8601 datetime yang lebih besar. Lihat di bawah ini.
Format yang didukung
Format nilai datetime adalah [Tanggal] T [Waktu] [Zona Waktu], di mana T adalah pemisah. Jika zona waktu eksplisit tidak disediakan, UTC (Z) dianggap sebagai default.
Zona waktu
Format zona waktu yang didukung adalah:
+ \$1/- HH: mm
+ \$1/-HHmm
+ \$1/- HH
Kehadiran zona waktu dalam string datetime adalah opsional. Jika offset zona waktu adalah 0, Z dapat digunakan sebagai pengganti postfix zona waktu di atas untuk menunjukkan waktu UTC. Rentang zona waktu yang didukung adalah dari - 14:00 hingga \$1 14:00.
Date
Jika tidak ada zona waktu, atau zona waktunya adalah UTC (Z), format tanggal yang didukung adalah sebagai berikut:
**catatan**
DDD mengacu pada tanggal ordinal, yang mewakili hari dalam setahun dari 001 hingga 365 (366 dalam tahun kabisat). Misalnya, 2024-002 mewakili 2 Januari 2024.
+ `yyyy-MM-dd`
+ `yyyyMMdd`
+ `yyyy-MM`
+ `yyyyMM`
+ `yyyy-DDD`
+ `yyyyDDD`
+ `yyyy`
Jika zona waktu selain Z dipilih, format tanggal yang didukung dibatasi sebagai berikut:
+ `yyyy-MM-dd`
+ `yyyy-DDD`
+ `yyyyDDD`
Rentang yang didukung untuk tanggal adalah dari 1400-01-01 hingga 9999-12-31.
Waktu
Jika tidak ada zona waktu, atau zona waktunya adalah UTC (Z), format waktu yang didukung adalah:
+ `HH:mm:ss.SSS`
+ `HH:mm:ss`
+ `HHmmss.SSS`
+ `HHmmss`
+ `HH:mm`
+ `HHmm`
+ `HH`
Jika zona waktu selain Z dipilih, format waktu yang didukung dibatasi sebagai berikut:
+ `HH:mm:ss`
+ `HH:mm:ss.SSS`
### Perbedaan semantik bahasa Neptunus OpenCypher
Neptunus mewakili simpul dan IDs hubungan sebagai string daripada bilangan bulat. ID sama dengan ID yang diberikan melalui pemuat data. Jika ada namespace untuk kolom, namespace ditambah ID. Akibatnya, `id` fungsi mengembalikan string bukan integer.
Jenis `INTEGER` data terbatas pada 64 bit. Saat mengonversi nilai floating point atau string yang lebih besar menjadi bilangan bulat menggunakan `TOINTEGER` fungsi, nilai negatif terpotong `LLONG_MIN` dan nilai positif dipotong menjadi. `LLONG_MAX`
Contoh:
```
RETURN TOINTEGER(2^100)
> 9223372036854775807
RETURN TOINTEGER(-1 * 2^100)
> -9223372036854775808
```
### Properti multi-nilai
Meskipun OpenCypher CREATE tidak membuat properti multi-nilai, mereka dapat ada dalam data yang dibuat menggunakan Gremlin (Database Neptunus) atau saat memuat data (Database Neptunus dan Neptunus Analytics). Jika Neptunus OpenCypher menemukan properti multi-nilai, salah satu nilai dipilih secara sewenang-wenang, menciptakan hasil non-deterministik.
### Penanganan NaN valuse
Penanganan Neptunus terhadap perbandingan nilai `NaN` properti tidak terdefinisi. Mengandalkan perbandingan tersebut dapat menghasilkan hasil yang tidak terduga atau non-deterministik.