

翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。

# Amazon Neptune 標準への準拠に関する注意事項
<a name="feature-overview-standards-compliance"></a>

Amazon Neptune は、ほとんどの場合、Gremlin および SPARQL グラフクエリ言語を実装する際に該当する標準に準拠します。

以下のセクションでは標準について説明します。さらに Neptune が標準を超えたり逸脱したりする領域についても説明します。

**Topics**
+ [Amazon Neptune の Gremlin 標準への準拠](access-graph-gremlin-differences.md)
+ [Amazon Neptune の SPARQL 標準準拠](feature-sparql-compliance.md)
+ [Amazon Neptune における openCypher の仕様準拠](feature-opencypher-compliance.md)

# Amazon Neptune の Gremlin 標準への準拠
<a name="access-graph-gremlin-differences"></a>

以下のセクションでは、Gremlin の Neptune 実装の概要と、Apache TinkerPop の実装との違いについて説明します。

Neptune はそのエンジンでいくつかの Gremlin ステップをネイティブに実装し、Apache TinkerPop Gremlin 実装を使用して他のステップを処理します ([Amazon Neptune でのネイティブ Gremlin ステップサポート](gremlin-step-support.md))。

**注記**  
Gremlin コンソールと Amazon Neptune における実装の違いの具体的な例については、クイックスタートの [Gremlin を使用して Amazon Neptune のグラフデータにアクセスする](get-started-graph-gremlin.md) セクションを参照してください。

**Topics**
+ [Gremlin に適用される標準](#feature-gremlin-applicable-standards)
+ [スクリプト内の変数とパラメータ](#feature-gremlin-differences-variables)
+ [TinkerPop の列挙](#feature-gremlin-differences-tinkerpop)
+ [Java コード](#feature-gremlin-differences-java)
+ [要素のプロパティ](#feature-gremlin-differences-properties-on-elements)
+ [スクリプトの実行](#feature-gremlin-differences-script)
+ [セッション](#feature-gremlin-differences-sessions)
+ [トランザクション](#feature-gremlin-differences-transactions)
+ [頂点およびエッジ ID](#feature-gremlin-differences-vertex-edge-ids)
+ [ユーザーによって指定された ID](#feature-gremlin-differences-user-supplied-ids)
+ [頂点プロパティ ID](#feature-gremlin-differences-vertex-property-ids)
+ [頂点プロパティのカーディナリティ](#feature-gremlin-differences-vertex-property-cardinality)
+ [頂点プロパティの更新](#feature-gremlin-differences-vertex-property-update)
+ [ラベル](#feature-gremlin-differences-labels)
+ [エスケープ文字](#feature-gremlin-differences-escapes)
+ [Groovy の制限](#feature-gremlin-differences-groovy)
+ [シリアル化](#feature-gremlin-differences-serialization)
+ [Lambda ステップ](#feature-gremlin-differences-lambda)
+ [サポートされていない Gremlin メソッド](#feature-gremlin-differences-unsupported-methods)
+ [サポートされていない Gremlin ステップ](#feature-gremlin-differences-unsupported-steps)
+ [Neptune での Gremlin グラフ機能](#gremlin-api-reference-features)

## Gremlin に適用される標準
<a name="feature-gremlin-applicable-standards"></a>
+ Gremlin 言語は、正式な仕様によって定義されているのではなく、[Apache TinkerPop ドキュメント](http://tinkerpop.apache.org/docs/current/reference/)と Gremlin の Apache TinkerPop 実装によって定義されています。
+ 数値の形式については、Gremlin は IEEE 754 標準に従っています ([IEEE 754-2019 - IEEE Standard for Floating-Point Arithmetic](https://standards.ieee.org/content/ieee-standards/en/standard/754-2019.html)/[Wikipedia IEEE 754 ページ](https://en.wikipedia.org/wiki/IEEE_754)も参照してください)。

## スクリプト内の変数とパラメータ
<a name="feature-gremlin-differences-variables"></a>

事前にバインドされた変数に関しては、トラバーサルオブジェクト `g` はNeptune では事前にバインドされており、`graph` オブジェクトはサポートされていません。

Neptune は Gremlin 変数やスクリプト内のパラメータ化をサポートしていませんが、インターネット上では、次のような変数宣言を含む Gremlin Server 用のサンプルスクリプトをよく目にすることがあります。

```
String query = "x = 1; g.V(x)";
List<Result> results = client.submit(query).all().get();
```

また、クエリの送信時に[パラメータ化](https://tinkerpop.apache.org/docs/current/reference/#parameterized-scripts) (またはバインディング) を利用する例も多数あります。例えば、次のようになります。

```
Map<String,Object> params = new HashMap<>();
params.put("x",1);
String query = "g.V(x)";
List<Result> results = client.submit(query).all().get();
```

パラメータの例は通常、可能であればパラメータ化しないことによるパフォーマンス上のペナルティに関する警告と関連付けられます。TinkerPop にはこのような例がたくさんあり、パラメータ化の必要性についてはどれも納得のいくものです。

ただし、変数宣言機能とパラメータ化機能 (および警告) はどちらも、TinkerPop の Gremlin Server が `GremlinGroovyScriptEngine` を使用している場合にのみ適用されます。Gremlin Server が Gremlin の `gremlin-language` ANTLR 文法を使用してクエリを解析する場合には適用されません。ANTLR 文法は変数宣言もパラメータ化もサポートしていないため、ANTLR を使用するときにはパラメータ化の失敗を心配する必要はありません。ANTLR 文法は TinkerPop の新しいコンポーネントであるため、インターネット上で遭遇する可能性のある古いコンテンツには、一般的にこの区別が反映されていません。

Neptune は、クエリ処理エンジンでは `GremlinGroovyScriptEngine` ではなく ANTLR 文法を使用するため、変数、パラメータ化、または `bindings` プロパティをサポートしません。その結果、パラメータ化の失敗に関連する問題は、Neptune には当てはまりません。Neptune を使用すると、通常はパラメータ化するようなクエリをそのまま送信しても完全に安全です。そのため、前の例を次のように簡略化しても、パフォーマンスを低下させずに済みます。

```
String query = "g.V(1)";
List<Result> results = client.submit(query).all().get();
```

## TinkerPop の列挙
<a name="feature-gremlin-differences-tinkerpop"></a>

Neptune では、列挙値の完全修飾クラス名はサポートしていません。たとえば、Groovy リクエストでは `org.apache.tinkerpop.gremlin.structure.VertexProperty.Cardinality.single` ではなく `single` を使用する必要があります。

列挙型は、パラメータタイプによって決定されます。

次の表は、使用できる列挙値と関連する TinkerPop の完全修飾名を示しています。

| 許可された値 | Class | 
| --- |--- |
| id, key, ラベル, 値 | [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) | 
| 設定, single | [org.apache.tinkerpop.gremlin.structure.VertexProperty.Cardinality](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) | 
| グローバル, ローカル | [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) | 
| すべて, 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.Barrier](https://tinkerpop.apache.org/javadocs/3.7.2/core/org/apache/tinkerpop/gremlin/process/traversal/SackFunctions.Barrier.html) | 
| AddAll, と, assign, div, max, min, minus, mult, または, 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) | 
| キー, 値 | [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) | 
| すべて, なし | [org.apache.tinkerpop.gremlin.process.traversal.step.TraversalOptionParent.Pick](https://tinkerpop.apache.org/javadocs/current/full/org/apache/tinkerpop/gremlin/process/traversal/Pick.html) | 

## Java コード
<a name="feature-gremlin-differences-java"></a>

Neptune は、サポートされている Gremlin API 以外の、任意の Java または Java ライブラリ呼び出しにより定義されるメソッドへの呼び出しをサポートしていません。たとえば、`java.lang.*`、`Date()`、および `g.V().tryNext().orElseGet()` は許可されていません。

## 要素のプロパティ
<a name="feature-gremlin-differences-properties-on-elements"></a>

 Neptune は、要素のプロパティを返すために TinkerPop 3.7.0 で導入された `materializeProperties` フラグをサポートしていません。その結果、Neptune は頂点またはエッジのみを `id` および `label` のみの参照として返します。

## スクリプトの実行
<a name="feature-gremlin-differences-script"></a>

すべてのクエリは、トラバーサルオブジェクト `g` で始まる必要があります。

文字列クエリの送信で、複数のトラバーサルは、セミコロン (`;`) または改行文字 (`\n`) で区切って発行することができます。実行されるように、最終以外の各ステートメントは、`.iterate()` ステップで終わる必要があります。最終的なトラバーサルデータのみが返されます。これは GLV ByteCode クエリの送信には適用されない点に注意してください。

## セッション
<a name="feature-gremlin-differences-sessions"></a>

Neptune のセッションは、長さが 10 分のみに制限されます。詳細については、「[Gremlin スクリプトベースのセッション](access-graph-gremlin-sessions.md)」および[TinkerPop セッションリファレンス](https://tinkerpop.apache.org/docs/current/reference/#console-sessions)を参照してください。

## トランザクション
<a name="feature-gremlin-differences-transactions"></a>

Neptune は、各 Gremlin トラバーサルの開始時に新しいトランザクションを開き、トラバーサルが正常に完了したときにトランザクションを閉じます。エラーが発生すると、トランザクションはロールバックされます。

 セミコロン (`;`) または改行文字 (`\n`) で区切られた複数のステートメントは、単一のトランザクションに含まれています。最後のもの以外の各ステートメントは、`next()` ステップの実行で終わる必要があります。最終的なトラバーサルデータのみが返されます。

`tx.commit()` および `tx.rollback()` を使用した手動トランザクションロジックはサポートされていません。

**重要**  
これは Gremlin クエリを***テキスト文字列***として送信するメソッド***のみ***に当てはまります (「[Gremlin トランザクション](access-graph-gremlin-transactions.md)」を参照)。

## 頂点およびエッジ ID
<a name="feature-gremlin-differences-vertex-edge-ids"></a>

Neptune Gremlin 頂点およびエッジ ID は、タイプ `String` である必要があります。これらの ID 文字列は Unicode 文字をサポートし、サイズは 55 MB を超えることはできません。

ユーザーが指定した ID はサポートされますが、通常の使用ではオプションとなります。頂点やエッジを追加するときに ID を指定しなかった場合、Neptune は UUID を生成し、次のような形式の文字列に変換します。これらの UUID は RFC 標準に準拠していないため、標準 UUID が必要な場合は、外部で生成し、頂点やエッジを追加するときに指定する必要があります。

**注記**  
Neptune `Load` コマンドでは、**\$1id** フィールドを使用して、Neptune CSV 形式で ID を指定する必要があります。

## ユーザーによって指定された ID
<a name="feature-gremlin-differences-user-supplied-ids"></a>

ユーザーにより提供される ID は、以下の規定により Neptune Gremlin で許可されます。
+ 指定 ID はオプションです。
+ 頂点とエッジのみがサポートされています。
+ タイプ `String` のみがサポートされます。

カスタム ID で新しい頂点を作成するには、`id` キーワードで `property` ステップを使用します。`g.addV().property(id, 'customid')`。

**注記**  
 `id` キーワードを引用符で囲むことはできません。`T.id` を指します。

すべての頂点 ID およびすべてのエッジ ID は、一意である必要があります。ただし、Neptune では、頂点とエッジで同じ ID を持つことができます。

`g.addV()` を使用して新しい頂点を作成しようとする場合、既にその ID を持つ頂点が存在すると、オペレーションは失敗します。この例外として、頂点に新しいラベルを指定するとオペレーションは成功しますが、新しいラベルおよび既存の頂点に指定されたすべての追加のプロパティが追加されます。Nothing は上書きされます。新しい頂点は作成されません。頂点 ID は変更せず、一意のままになります。

たとえば、次の Gremlin コンソールコマンドは成功します。

```
gremlin> g.addV('label1').property(id, 'customid')
gremlin> g.addV('label2').property(id, 'customid')
gremlin> g.V('customid').label()
==>label1::label2
```

## 頂点プロパティ ID
<a name="feature-gremlin-differences-vertex-property-ids"></a>

頂点プロパティ ID は自動的に生成され、クエリを実行したときに、正または負の数値で表示されます。

## 頂点プロパティのカーディナリティ
<a name="feature-gremlin-differences-vertex-property-cardinality"></a>

Neptune は、セット濃度と単一濃度をサポートしています。指定されていない場合は、セット濃度が選択されます。つまり、プロパティ値を設定した場合、値のセットに既に表示されていない場合にのみ、プロパティに新しい値が追加されます。これは、[セット](https://tinkerpop.apache.org/javadocs/3.7.2/core/org/apache/tinkerpop/gremlin/structure/VertexProperty.Cardinality.html)の Gremlin 列挙の値です。

`List` はサポートされていません。プロパティ濃度の詳細については、Gremlin JavaDoc にある「[頂点](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...-)」 トピックを参照してください。

## 頂点プロパティの更新
<a name="feature-gremlin-differences-vertex-property-update"></a>

値のセットに追加の値を追加せずにプロパティ値を更新するには、`property` ステップで `single` 濃度を指定します。

```
g.V('exampleid01').property(single, 'age', 25)
```

これにより、既存のプロパティの値はすべて削除されます。

## ラベル
<a name="feature-gremlin-differences-labels"></a>

Neptune は、頂点の複数のラベルをサポートしています。ラベルを作成する際、`::` で区切ることで複数のラベルを指定できます。たとえば、`g.addV("Label1::Label2::Label3")` は頂点に 3 つの異なるラベルを追加します。`hasLabel` ステップでは、この頂点を `hasLabel("Label1")`、`hasLabel("Label2")`、および `hasLabel("Label3")` の 3 つのラベルのいずれかと一致させます。

**重要**  
`::` 区切り記号は、この使用のみに予約されます。`hasLabel` ステップで複数のラベルを指定することはできません。たとえば、`hasLabel("Label1::Label2")` はいずれにも一致しません。

## エスケープ文字
<a name="feature-gremlin-differences-escapes"></a>

Neptune は、Apache Groovy 言語ドキュメントの 特殊文字のエスケープ セクションで説明されているすべての[エスケープ文字]( http://groovy-lang.org/syntax.html#_escaping_special_characters)を解決します。

## Groovy の制限
<a name="feature-gremlin-differences-groovy"></a>

Neptune は、`g` 以外で始まる Groovy コマンドをサポートしていません。これには、算術 (`1+1` など)、システム呼び出し (`System.nanoTime()` など)、および変数の定義 (`1+1` など) が含まれます。

**重要**  
Neptune では、完全修飾クラス名はサポートしていません。たとえば、Groovy リクエストでは `org.apache.tinkerpop.gremlin.structure.VertexProperty.Cardinality.single` ではなく `single` を使用する必要があります。

## シリアル化
<a name="feature-gremlin-differences-serialization"></a>

Neptune は、リクエストされた MIME タイプに基づいて、以下のシリアル化をサポートしています。

 Neptune は、TinkerPop が実行するすべてのシリアライザーを公開し、GraphSON と GraphBinary のさまざまなバージョンと設定をサポートします。多くのオプションがありますが、使用するガイダンスは簡易です。
+  Apache TinkerPop ドライバーを使用している場合は、ドライバーを明示的に指定せずに、ドライバーのデフォルトを優先します。特に理由がない限り、ドライバーの初期化でシリアライザーを指定する必要はありません。一般的に、ドライバーで使用されるデフォルトは `application/vnd.graphbinary-v1.0` です。
+  HTTP 経由で Neptune に接続する場合は、GraphSON 3 の代替バージョンで埋め込みタイプとして `application/vnd.gremlin-v3.0+json;types=false` を使用することを優先し、操作を複雑にします。
+  一般的に、`application/vnd.graphbinary-v1.0-stringd` はすべての結果を文字列表現に変換して簡単に表示するため、[Gremlin コンソール](https://docs.aws.amazon.com//neptune/latest/userguide/access-graph-gremlin-console.html)と組み合わせて使用する場合にのみ活用できます。
+  残りの形式はレガシーの理由で残っており、通常、明確な原因がないドライバーでは使用しないでください。

|  |  |  | 
| --- |--- |--- |
| MIME type | Serialization | Configuration | 
| `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   (only works with 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 |  | 

**注記**  
 ここに示すシリアライザーテーブルは、TinkerPop 3.7.0 時点の命名を参照しています。この変更の詳細については、[TinkerPop アップグレードドキュメント](https://tinkerpop.apache.org/docs/current/upgrade/#_serializer_renaming)を参照してください。Gryo シリアル化のサポートは 3.4.3 で廃止され、3.6.0 で正式に削除されました。Gryo または Gryo をデフォルトで使用しているドライバーバージョンで明示的に使用している場合は、GraphBinary に切り替えるか、ドライバーをアップグレードする必要があります。

## Lambda ステップ
<a name="feature-gremlin-differences-lambda"></a>

Neptune では、Lambda ステップはサポートされていません。

## サポートされていない Gremlin メソッド
<a name="feature-gremlin-differences-unsupported-methods"></a>

Neptune は、以下の Gremlin メソッドをサポートしていません。
+ `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)`

たとえば、以下のトラバーサルは許可されません。`g.V().addE('something').from(__.V().next()).to(__.V().next())`。

**重要**  
これは Gremlin クエリを***テキスト文字列***として送信するメソッド***のみ***に当てはまります。

## サポートされていない Gremlin ステップ
<a name="feature-gremlin-differences-unsupported-steps"></a>

Neptune は、以下の Gremlin ステップをサポートしていません。
+ Gremlin [io( ) ステップ](http://tinkerpop.apache.org/docs/3.7.2/reference/#io-step)は、Neptune では部分的にしかサポートされていません。`g.io((url)).read()` のように読み取りコンテキストでは使用できますが、書き込みには使用できません。

## Neptune での Gremlin グラフ機能
<a name="gremlin-api-reference-features"></a>

Gremlin の Neptune 実装には、`graph` オブジェクトは表示されません。次の表は、Gremlin の機能と、Neptune がそれらをサポートしているかどうかを示しています。

### Neptune の `graph` 機能のサポート
<a name="gremlin-api-graph-features"></a>

Neptune グラフ機能は、サポートされている場合、`graph.features()` コマンドによって返されるものと同じです。


| 
| 
| グラフ機能 | 有効? | 
| --- |--- |
| トランザクション |  true | 
| ThreadedTransactions |  false | 
| [コンピュータ] |  false | 
| 永続的 |  true | 
| ConcurrentAccess |  true | 

### Neptune の変数機能のサポート
<a name="gremlin-api-variable-features"></a>


| 
| 
| 変数機能 | 有効? | 
| --- |--- |
| [変数] |  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 | 

### Neptune の頂点機能のサポート
<a name="gremlin-api-vertex-features"></a>


| 
| 
| 頂点機能 | 有効? | 
| --- |--- |
| MetaProperties |  false | 
| DuplicateMultiProperties |  false | 
| AddVertices |  true | 
| RemoveVertices |  true | 
| MultiProperties |  true | 
| UserSuppliedIds |  true | 
| AddProperty |  true | 
| RemoveProperty |  true | 
| NumericIds |  false | 
| StringIds |  true | 
| UuidIds |  false | 
| CustomIds |  false | 
| AnyIds |  false | 

### Neptune の頂点プロパティ機能のサポート
<a name="gremlin-api-vertex-property-features"></a>


| 
| 
| 頂点プロパティ機能 | 有効? | 
| --- |--- |
| UserSuppliedIds |  false | 
| AddProperty |  true | 
| RemoveProperty |  true | 
| NumericIds |  true | 
| StringIds |  true | 
| UuidIds |  false | 
| CustomIds |  false | 
| AnyIds |  false | 
| プロパティ |  true | 
| SerializableValues |  false | 
|  UniformListValues |  false | 
| BooleanArrayValues |  false | 
| DoubleArrayValues |  false | 
| IntegerArrayValues |  false | 
| StringArrayValues |  false | 
| BooleanValues |  true | 
| ByteValues |  true | 
| DoubleValues |  true | 
| FloatValues |  true | 
| IntegerValues |  true | 
| LongValues |  true | 
| MapValues |  false | 
| MixedListValues |  false | 
| StringValues |  true | 
| ByteArrayValues |  false | 
| FloatArrayValues |  false | 
| LongArrayValues |  false | 

### Neptune のエッジ機能のサポート
<a name="gremlin-api-edge-features"></a>


| 
| 
| エッジ機能 | 有効? | 
| --- |--- |
| AddEdges |  true | 
| RemoveEdges |  true | 
| UserSuppliedIds |  true | 
| AddProperty |  true | 
| RemoveProperty |  true | 
| NumericIds |  false | 
| StringIds |  true | 
| UuidIds |  false | 
| CustomIds |  false | 
| AnyIds |  false | 

### Neptune のエッジプロパティ機能のサポート
<a name="gremlin-api-edge-property-features"></a>


| 
| 
| エッジプロパティ機能 | 有効? | 
| --- |--- |
| プロパティ |  true | 
| SerializableValues |  false | 
| UniformListValues |  false | 
| BooleanArrayValues |  false | 
| DoubleArrayValues |  false | 
| IntegerArrayValues |  false | 
| StringArrayValues |  false | 
| BooleanValues |  true | 
| ByteValues |  true | 
| DoubleValues |  true | 
| FloatValues |  true | 
| IntegerValues |  true | 
| LongValues |  true | 
| MapValues |  false | 
| MixedListValues |  false | 
| StringValues |  true | 
| ByteArrayValues |  false | 
| FloatArrayValues |  false | 
| LongArrayValues |  false | 

# Amazon Neptune の SPARQL 標準準拠
<a name="feature-sparql-compliance"></a>

適用可能な SPARQL 標準を列挙したあと、以下のセクションでは、Neptune の SPARQL 実装がそれらの標準からどのように拡張し、または異なるかについて具体的な詳細を説明します。

**Topics**
+ [SPARQL に適用される標準](#feature-sparql-applicable-standards)
+ [Neptune SPARQL のデフォルトの名前空間プレフィックス](#sparql-default-prefixes)
+ [SPARQL デフォルトグラフと名前が付いたグラフ](#sparql-default-graph)
+ [Neptune でサポートされている SPARQL XPath コンストラクタ関数](#access-graph-sparql-xpath-constructors)
+ [クエリと更新のためのデフォルトベース IRI](#opencypher-compliance-default-iri)
+ [Neptune での xsd:dateTime の値](#access-graph-sparql-xsd-date-time)
+ [Neptune による特殊な浮動小数点値の処理](#feature-overview-special-values-comparisons)
+ [Neptune での任意長の値の制限](#feature-overview-arbitrary-length-values)
+ [Neptune で拡張される SPARQL の不等比較](#feature-overview-sparql-not-equal)
+ [Neptune SPARQL での範囲外リテラルの処理](#feature-overview-sparql-out-of-range)

Amazon Neptune は、SPARQL グラフクエリ言語を実装する際に次の標準に準拠しています。

## SPARQL に適用される標準
<a name="feature-sparql-applicable-standards"></a>
+ SPARQL は、2013 年 3 月 21 日の W3C [SPARQL 1.1 クエリ言語](https://www.w3.org/TR/sparql11-query/)勧告に基づいて定義されています。
+ SPARQL 更新プロトコルとクエリ言語は、W3C [SPARQL 1.1 更新](https://www.w3.org/TR/sparql11-update/)仕様で定義されています。
+ 数値形式の場合、SPARQL は [W3C XML スキーマ定義言語 (XSD) 1.1 パート 2: データ型](https://www.w3.org/TR/xmlschema11-2/)仕様に従っています。この仕様は IEEE 754 仕様を準拠しています ([IEEE 754-2019 - IEEE Standard for Floating-Point Arithmetic](https://standards.ieee.org/content/ieee-standards/en/standard/754-2019.html)/[Wikipedia IEEE 754 ページも参照](https://en.wikipedia.org/wiki/IEEE_754)してください)。ただし、`IEEE 754-1985` バージョン以降に導入された機能は、仕様には含まれません。

## Neptune SPARQL のデフォルトの名前空間プレフィックス
<a name="sparql-default-prefixes"></a>

Neptune は、SPARQL クエリで使用するためにデフォルトで以下のプレフィックスを定義します。詳細については、SPARQL 仕様の「[接頭辞付き名](https://www.w3.org/TR/sparql11-query/#prefNames)」を参照してください。
+ `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#`

## SPARQL デフォルトグラフと名前が付いたグラフ
<a name="sparql-default-graph"></a>

Amazon Neptune はすべてのトリプルを名前が付いたグラフに関連付けます。デフォルトグラフはすべての名前が付いたグラフの総合として定義されます。

**クエリ用のデフォルトグラフ**  
`GRAPH` キーワードや構成 (`FROM NAMED` など) を使用してグラフを明示的に指定せずに SPARQL クエリを送信すると、Neptune は常に DB インスタンスのすべてのトリプルを考慮します。たとえば、次のクエリはすべてのトリプルを Neptune SPARQL エンドポイントから返します。

`SELECT * WHERE { ?s ?p ?o }`

1 つ以上のグラフに表されるトリプルは、1 度だけ返されます。

デフォルトグラフ仕様についての詳細は、SPARQL 1.1 クエリ言語仕様の「[RDF データセット](https://www.w3.org/TR/sparql11-query/#rdfDataset)」セクションを参照してください。

**ロード、挿入や更新用に名前付きのグラフを指定する**  
トリプルのロード、挿入あるいは更新時に名前が付いたグラフを指定しない場合、Neptune は URI `http://aws.amazon.com/neptune/vocab/v01/DefaultNamedGraph` が定義するフォールバックの名前付きグラフを使用します。

Neptune がトリプルベースの形式を使用して `Load` リクエストを発行する場合、`parserConfiguration: namedGraphUri` パラメータを使用して、すべてのトリプルを使用するように名前付きのグラフを指定できます。`Load` コマンド構文の詳細については、「[Neptune ローダーコマンド](load-api-reference-load.md)」を参照してください。

**重要**  
 このパラメータを使用せず、名前付きのグラフを指定しない場合、フォールバック URI が使用されます。`http://aws.amazon.com/neptune/vocab/v01/DefaultNamedGraph`。

このフォールバックの名前付きグラフは、名前付きグラフターゲットを明示的に提供しないで、`SPARQL UPDATE` を介してトリプルをロードする場合にも使用されます。

クワッドベース形式の N-Quads を使用して、データベースの各トリプルに名前付きグラフを指定できます。

**注記**  
N-Quads では名前付きグラフを空にできます。この場合、`http://aws.amazon.com/neptune/vocab/v01/DefaultNamedGraph` が使用されます。  
`namedGraphUri` パーサー設定オプションを使用して、N-Quads のデフォルトの名前付きグラフを上書きできます。

## Neptune でサポートされている SPARQL XPath コンストラクタ関数
<a name="access-graph-sparql-xpath-constructors"></a>

SPARQL 標準により、SPARQL エンジンは一連の拡張可能な XPath コンストラクタ関数をサポートできます。Neptune は現在、以下のコンストラクター関数をサポートしています。ここで `xsd` プレフィックスは `http://www.w3.org/2001/XMLSchema#` と定義されます。
+ `xsd:boolean`
+ `xsd:integer`
+ `xsd:double`
+ `xsd:float`
+ `xsd:decimal`
+ `xsd:long`
+ `xsd:unsignedLong`

## クエリと更新のためのデフォルトベース IRI
<a name="opencypher-compliance-default-iri"></a>

Neptune クラスターには複数の異なるエンドポイントがあるため、クエリまたは更新のリクエスト URL をベース IRI として使用すると、相対 IRI を解決する際に予期しない結果が生じる可能性があります。

[エンジンリリース 1.2.1.0](engine-releases-1.2.1.0.md) では、明示的なベース IRI がリクエストに含まれていない場合、Neptune は `http://aws.amazon.com/neptune/default/` をベース IRI として使用します。

次のリクエストでは、ベース IRI はリクエストの一部です。

```
BASE <http://example.org/default/>
INSERT DATA { <node1> <id> "n1" }

BASE <http://example.org/default/>
SELECT * { <node1> ?p ?o }
```

結果は次のようになります。

```
?p                                                   ?o
http://example.org/default/id                        n1
```

ただし、このリクエストにはベース IRI は含まれていません。

```
INSERT DATA { <node1> <id> "n1" }

SELECT * { <node1> ?p ?o }
```

その場合、結果は以下のようになります。

```
?p                                                   ?o
http://aws.amazon.com/neptune/default/id             n1
```

## Neptune での xsd:dateTime の値
<a name="access-graph-sparql-xsd-date-time"></a>

パフォーマンス上の理由から、Neptune は 常に協定世界時 (UTC) として日付/時刻値を保存します。これにより、直接比較が非常に効率的になります。

つまり、特定のタイムゾーンを指定する `dateTime` 値を入力すると、Neptune は値を UTC に変換し、そのタイムゾーン情報を破棄します。その後、後で `dateTime` 値を取得すると、元のタイムゾーンの時間ではなく UTC で表され、元のタイムゾーンが何であったかを知ることができなくなります。

## Neptune による特殊な浮動小数点値の処理
<a name="feature-overview-special-values-comparisons"></a>

Neptune は、SPARQL の特殊な浮動小数点値を次のように処理します。

### SPARQL NaN Neptune での処理
<a name="feature-overview-NaN-comparisons"></a>

Neptune では、SPARQL はクエリで値として `NaN` を使用できます。シグナルおよびクワイエットの `NaN` 値は区別されません。Neptune は、すべての `NaN` 値をクワイエットとして扱います。

`NaN` より大きい、より小さい、または等しいものは何もないため、`NaN` の比較はできません。つまり、比較の一方の `NaN` の値は、比較の他方の*いずれの値*とも一致しません。

 しかし、[XSD仕様](https://www.w3.org/TR/xmlschema-2/#double)は 2 つの`xsd:double`または`xsd:float` `NaN`等しいものとして扱います。Neptune は、`IN` フィルター、フィルター式の等号演算子、完全一致セマンティクス (トリプルパターンのオブジェクト位置の `NaN` にある) についてはこれに従います。

### Neptune での SPARQL 無限値の処理
<a name="feature-overview-infinity-comparisons"></a>

Neptune では、SPARQL はクエリで `INF` または`-INF` の値を使用できます。`INF` は他のどの数値よりも大きい値、`-INF` は他のどの数値よりも小さい値と見なされます。

符号が一致する 2 つの INF 値は、型に関係なく互いに等しいと比較されます (たとえば、float `-INF` は double `-INF` と等しいと比較されます)。

`NaN` より大きい、より小さい、等しいものは何もないため、当然ながら `NaN` の比較はできません。

### Neptune での SPARQL 負のゼロ処理
<a name="feature-overview-zero-comparisons"></a>

Neptune は、負のゼロ値を符号なしゼロに正規化します。負のゼロ値はクエリで使用できますが、データベースにはそのように記録されず、符号なしゼロと等しいと見なされます。

## Neptune での任意長の値の制限
<a name="feature-overview-arbitrary-length-values"></a>

Neptune は、SPARQL の XSD 整数、浮動小数点、10 進値のストレージサイズを 64 ビットに制限します。より大きい値を使用すると、`InvalidNumericDataException` エラーが発生します。

## Neptune で拡張される SPARQL の不等比較
<a name="feature-overview-sparql-not-equal"></a>

SPARQL 標準は、値式の 3 項ロジックを定義します。値式は、`true`、`false`、または `error` のいずれかに評価されます。[SPARQL 1.1 仕様](https://www.w3.org/TR/sparql11-query/#func-RDFterm-equal) で定義される項等価のデフォルトのセマンティクスは、`FILTER` 条件で `=` および `!=` の比較に当てはまり、仕様で[演算子テーブル](https://www.w3.org/TR/sparql11-query/#OperatorMapping)において明示的に比較できないデータ型を比較する場合に、`error` を生成します。

この動作は、次の例のように、直感的でない結果につながる可能性があります。

データ:

```
<http://example.com/Server/1> <http://example.com/ip> "127.0.0.1"^^<http://example.com/datatype/IPAddress>
```

クエリ 1:

```
SELECT * WHERE {
    <http://example.com/Server/1> <http://example.com/ip> ?o .
    FILTER(?o = "127.0.0.2"^^<http://example.com/datatype/IPAddress>)
}
```

クエリ 2:

```
SELECT * WHERE {
    <http://example.com/Server/1> <http://example.com/ip> ?o .
    FILTER(?o != "127.0.0.2"^^<http://example.com/datatype/IPAddress>)
}
```

Neptune でリリース 1.0.2.1 より前に使用していたデフォルトの SPARQL セマンティクスでは、どちらのクエリからも空の結果が返されます。その理由として、`?o = "127.0.0.2"^^<http://example.com/IPAddress>` は、`?o := "127.0.0.1"^^<http://example.com/IPAddress>` に評価された場合に、`false` ではなく `error` を生成するためです。これは、カスタムデータ型 `<http://example.com/IPAddress>` に対して明示的に指定された比較ルールが存在しないことが原因です。その結果、2 番目のクエリの否定バージョンも `error` を生成します。どちらのクエリでも、`error` により、候補ソリューションが除外されます。

リリース 1.0.2.1 以降では、Neptune は仕様どおりに SPARQL の非等値演算子を拡張しています。[演算子の拡張性に関する SPARQL 1.1 セクション](https://www.w3.org/TR/sparql11-query/#operatorExtensibility)を参照してください。この拡張により、エンジンは、ユーザー定義や比較不可能な組み込みデータ型を比較する方法に関する追加のルールを定義できます。

このオプションを利用することで、Neptune は、演算子マッピングテーブルで明示的に定義されていない任意の 2 つのデータ型を比較した場合に、リテラル値とデータ型が構文的に等しいときは `true` として、そうでないときは false として評価するようになります。いずれの場合も、`error` は生成されません。

これらの新しいセマンティクスを使用すると、上の 2 番目のクエリからは空の結果の代わりに `"127.0.0.1"^^<http://example.com/IPAddress>` が返されます。

## Neptune SPARQL での範囲外リテラルの処理
<a name="feature-overview-sparql-out-of-range"></a>

XSD セマンティクスは、`integer` および `decimal` を除く各数値型を値空間で定義します。これらの定義は、各型を値の範囲に制限します。たとえば、`xsd:byte` 範囲の範囲は -128 から \$1127 までです。この範囲外の値は無効とみなされます。

型の値空間の外にリテラル値を割り当てようとした場合 (たとえば、`xsd:byte` をリテラル値 999 に設定しようとした場合) は、 は範囲外の値を切り上げたり切り捨てたりすることなく、そのままの範囲外の値を受け入れます。しかし、与えられた型はそれを表すことができないので、数値として持続しません。

つまり、定義された `xsd:byte` 値の範囲外の値であっても Neptune は `"999"^^xsd:byte` を受け入れます。ただし、値がデータベースで永続化されると、3 重パターンのオブジェクト位置で、完全一致セマンティクスでのみ使用できます。範囲外のリテラルは数値として扱われないため、範囲フィルターは実行できません。

SPARQL 1.1 仕様では、`numeric`*-operator-*`numeric`、`string`*-operator-*`string`、`literal`*-operator-*`literal`などのフォームで[範囲演算子](https://www.w3.org/TR/sparql11-query/#OperatorMapping)を定義します。Neptune は`invalid-literal`*-operator-*`numeric-value`などの範囲比較演算子を実行できません。

# Amazon Neptune における openCypher の仕様準拠
<a name="feature-opencypher-compliance"></a>

openCypher の Amazon Neptune リリースは、一般に、現在の openCypher 仕様 (「[Cypher Query Language Reference Version 9](https://s3.amazonaws.com/artifacts.opencypher.org/openCypher9.pdf)」) で定義されている句、演算子、式、関数、および構文をサポートしています。openCypher の Neptune サポートの制限と相違点を以下に説明します。

 Amazon Neptune は、openCypher 仕様の範囲を超えるいくつかの機能もサポートしています。詳細については、[Amazon Neptune の openCypher 拡張機能](access-graph-opencypher-extensions.md) を参照してください。

**注記**  
現在の Neo4j の Cypher 実装には、上記の openCypher 仕様には含まれていない機能が含まれています。現在の Cypher コードを Neptune に移行する場合、詳細については, 「[Neptune の Neo4j との互換性](migration-compatibility.md)」と「[Neptune 上の openCypherで実行するように Cypher クエリを書き直す](migration-opencypher-rewrites.md)」を参照してください。

## Neptune における openCypher 句のサポート
<a name="opencypher-compliance-clauses"></a>

Neptune は、特に注記がなければ、以下の句をサポートしています。
+ `MATCH` — サポートされています。ただし、*`shortestPath()`* と *`allShortestPaths()`* は、現在はサポートされていません。
+ `OPTIONAL MATCH`
+ *`MANDATORY MATCH`* — Neptune では現在サポートされて**いません**。ただし、Neptune は `MATCH` クエリでの[カスタム ID](access-graph-opencypher-extensions.md#opencypher-compliance-custom-ids) 値をサポートしています。
+ `RETURN` — サポートされています。ただし、`SKIP` または `LIMIT` として非静的な値が使用される場合を除きます。例えば、以下は現時点では機能しません。

  ```
  MATCH (n)
  RETURN n LIMIT toInteger(rand())    // Does NOT work!
  ```
+ `WITH` — サポートされています。ただし、`SKIP` または `LIMIT` として非静的な値が使用される場合を除きます。例えば、以下は現時点では機能しません。

  ```
  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` — Neptune では、`CREATE` クエリで[カスタム ID 値](access-graph-opencypher-extensions.md#opencypher-compliance-custom-ids)を作成できます。
+ `DELETE`
+ `SET`
+ `REMOVE`
+ `MERGE` - Neptune は `MERGE` クエリでの[カスタム ID 値](access-graph-opencypher-extensions.md#opencypher-compliance-custom-ids)をサポートしています。
+ *`CALL[YIELD...]`* — Neptune では現在**サポートされていません**。
+ `UNION, UNION ALL` — 読み取り専用クエリはサポートされていますが、ミューテーションクエリは現在サポートされて**いません**。
+  `USING` – `USING` はエンジンバージョン [1.3.2.0](https://docs.aws.amazon.com//neptune/latest/userguide/engine-releases-1.3.2.0.html) でサポートされています。詳細については、「[クエリヒント](https://docs.aws.amazon.com//neptune/latest/userguide/opencypher-query-hints.html)」を参照してください。

## Neptune における openCypher 演算子のサポート
<a name="opencypher-compliance-operators"></a>

Neptune は、特に注記がなければ、以下の演算子をサポートしています。

**一般的な演算子**
+ `DISTINCT`
+ ネストされたリテラルマップのプロパティにアクセスするための `.` 演算子。

**算術演算子**
+ `+` 加算演算子。
+ `-` 減算演算子。
+ `*` 乗算演算子。
+ `/` 除算演算子。
+ `%` 剰余除算演算子。
+ `^` 指数演算子は*サポート対象外*です。

**比較演算子**
+ `=` 加算演算子。
+ `<>` 不等式演算子。
+ `<` 小なり演算子は、引数のいずれかが Path、List、または Map の場合を除いてサポートされます。
+ `>` 大なり演算子は、引数のいずれかが Path、List、または Map の場合を除いてサポートされます。
+ `<=` 小なりイコール演算子は、引数のいずれかが Path、List、または Map の場合を除いてサポートされます。
+ `>=` 大なりイコール演算子は、引数のいずれかが Path、List、または Map の場合を除いてサポートされます。
+ `IS NULL`
+ `IS NOT NULL`
+ `STARTS WITH` は、検索するデータが文字列の場合にサポートされます。
+ `ENDS WITH` は、検索するデータが文字列の場合にサポートされます。
+ `CONTAINS` は、検索するデータが文字列の場合にサポートされます。

**ブール演算子**
+ `AND`
+ `OR`
+ `XOR`
+ `NOT`

**文字列演算子**
+ `+` 連結演算子。

**演算子一覧**
+ `+` 連結演算子。
+ `IN` (リスト内の項目の存在を確認します)

## Neptune での openCypher 式のサポート
<a name="opencypher-compliance-expressions"></a>

Neptune は、特に注記がなければ、以下の式をサポートしています。
+ `CASE`
+ ノード、リレーションシップ、またはマップ内で動的に計算されたプロパティキーにアクセスするための `[]` 式は、現在、Neptune ではサポートされて**いません**。例えば、以下は機能しません。

  ```
  MATCH (n)
  WITH [5, n, {key: 'value'}] AS list
  RETURN list[1].name
  ```

## Neptune における openCypher 関数のサポート
<a name="opencypher-compliance-functions"></a>

Neptune は、特に注記がなければ、以下の関数をサポートしています。

**述語関数**
+ `exists()`

**スカラー関数**
+ `coalesce()`
+ `endNode()`
+ `epochmillis()`
+ `head()`
+ `id()`
+ `last()`
+ `length()`
+ `randomUUID()`
+ `properties()`
+ `removeKeyFromMap`
+ `size()` — このオーバーロードされたメソッドは、現在のところ、パターン表現、リスト、文字列に対してのみ機能します。
+ `startNode()`
+ `timestamp()`
+ `toBoolean()`
+ `toFloat()`
+ `toInteger()`
+ `type()`

**集計関数**
+ `avg()`
+ `collect()`
+ `count()`
+ `max()`
+ `min()`
+ `percentileDisc()`
+ `stDev()`
+ `percentileCont()`
+ `stDevP()`
+ `sum()`

**関数の一覧表示**
+ [`join()`](access-graph-opencypher-extensions.md#opencypher-compliance-join-function) (リスト内の文字列を 1 つの文字列に連結する)
+ `keys()`
+ `labels()`
+ `nodes()`
+ `range()`
+ `relationships()`
+ `reverse()`
+ `tail()`

**数学関数 — 数値**
+ `abs()`
+ `ceil()`
+ `floor()`
+ `rand()`
+ `round()`
+ `sign()`

**数学関数 — 対数**
+ `e()`
+ `exp()`
+ `log()`
+ `log10()`
+ `sqrt()`

**数学関数 — 三角関数**
+ `acos()`
+ `asin()`
+ `atan()`
+ `atan2()`
+ `cos()`
+ `cot()`
+ `degrees()`
+ `pi()`
+ `radians()`
+ `sin()`
+ `tan()`

**文字列関数**
+ [`join()`](access-graph-opencypher-extensions.md#opencypher-compliance-join-function) (リスト内の文字列を 1 つの文字列に連結する)
+ `left()`
+ `lTrim()`
+ `replace()`
+ `reverse()`
+ `right()`
+ `rTrim()`
+ `split()`
+ `substring()`
+ `toLower()`
+ `toString()`
+ `toUpper()`
+ `trim()`

**ユーザー定義関数**

*ユーザー定義関数*は、Neptune では現在サポートされて**いません**。

## Neptune 固有の openCypher 実装の詳細
<a name="opencypher-compliance-differences"></a>

以下のセクションでは、openCypher の Neptune 実装が [openCypher 仕様](https://s3.amazonaws.com/artifacts.opencypher.org/openCypher9.pdf)と異なる場合や、それを超える場合があることについて説明します。

### Neptune における可変長パス (VLP) 評価
<a name="opencypher-compliance-differences-vlp"></a>

可変長パス (`VLP`) 評価は、グラフ内のノード間のパスを検出します。クエリではパスの長さに制限はありません。サイクルを防ぐため、[openCypher 仕様](https://s3.amazonaws.com/artifacts.opencypher.org/openCypher9.pdf)は、各エッジはソリューションごとに最大 1 回トラバースする必要があると規定しています。

VLP の場合、Neptune 実装は、プロパティ等価フィルターの定数値のみをサポートするという点で openCypher 仕様とは異なります。次のようなクエリがあるとします。

```
MATCH (x)-[:route*1..2 {dist:33, code:x.name}]->(y) return x,y
```

`x.name` プロパティ等価フィルターの値は定数ではないため、このクエリの結果は `UnsupportedOperationException` になり、`Property predicate over variable-length relationships with non-constant expression is not supported in this release.` というメッセージが表示されます。

### Neptune openCypher 実装での一時的なサポート (Neptune データベース 1.3.1.0 以前)
<a name="opencypher-compliance-time"></a>

Neptune は現在、openCypher の時間関数を限定的にサポートしています。時間型の `DateTime` データ型をサポートしています。

`datetime()` 関数を使用して、以下のように現在の UTC の日付と時刻を取得できます。

```
RETURN  datetime() as res
```

日付と時刻の値は、`"`*date*`T`*time*`"` 形式で文字列から解析できます。ここで、*date* と *time* は、どちらも以下のサポートされている形式のいずれかで表されます。

**サポートされている日付形式**
+ `yyyy-MM-dd`
+ `yyyyMMdd`
+ `yyyy-MM`
+ `yyyy-DDD`
+ `yyyyDDD`
+ `yyyy`

**サポートされている時刻形式**
+ `HH:mm:ssZ`
+ `HHmmssZ`
+ `HH:mm:ssZ`
+ `HH:mmZ`
+ `HHmmZ`
+ `HHZ`
+ `HHmmss`
+ `HH:mm:ss`
+ `HH:mm`
+ `HHmm`
+ `HH`

例えば、次のようになります。

```
RETURN datetime('2022-01-01T00:01')      // or another example:
RETURN datetime('2022T0001')
```

Neptune openCypher のすべての日付/時刻値は UTC 値として保存および取得されることに注意してください。

Neptune openCypher は `statement` クロックを使用します。つまり、クエリの実行中、時間的に同じインスタントが使用されます。同じトランザクション内の別のクエリでは、時間的に異なるインスタントが使用される場合があります。

Neptune は `datetime()` の呼び出し内での関数の使用をサポートしていません。例えば、以下は機能しません。

```
CREATE (:n {date:datetime(tostring(2021))})  // ---> NOT ALLOWED!
```

Neptune は `datetime` を `epochmillis` に変換する `epochmillis()` 関数をサポートしています。例えば、次のようになります。

```
MATCH (n) RETURN epochMillis(n.someDateTime)
1698972364782
```

Neptune は現在、`DateTime` オブジェクトに対する他の関数や演算 (加算や減算など) をサポートしていません。

### Neptune openCypher 実装 (Neptune Analytics および Neptune データベース 1.3.2.0 以降) での一時的なサポート
<a name="opencypher-compliance-time-na"></a>

OpenCypher の次の日時機能は、Neptune Analytics に適用されます。または、Labmode パラメータ `DatetimeMillisecond=enabled` を使用して、Neptune エンジンリリースバージョン 1.3.2.0 以降で次の日時機能を有効にすることもできます。ラボモードでこの機能を使用する方法の詳細については、「[拡張日時サポート](features-lab-mode.md#labmode-extended-datetime-support)」を参照してください。
+ ミリ秒のサポート。日時リテラルは、ミリ秒が 0 であっても、常にミリ秒単位で返されます。(以前の動作では、ミリ秒を切り捨てていました。)

  ```
  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"
        }
      }
    } ]
  }
  ```
+ 保存されたプロパティまたは中間結果に対して datetime() 関数を呼び出すためのサポート。例えば、この機能よりも前の機能では、次のクエリを実行できませんでした。

  プロパティに対する Datetime():

  ```
  // 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():

  ```
  // Parse datetime from parameter
  UNWIND $list as myDate
  RETURN datetime(myDate) as d
  ```
+ 上記の場合に作成された datetime プロパティを保存することも可能になりました。

  あるプロパティの文字列プロパティから別のプロパティに日時を保存する:

  ```
  // 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 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"}
    ]
  }
  ```
+ ISO8601 日時形式のより大きなサブセットのサポート。以下の「」を参照してください。

サポートされる形式

 日時値の形式は [Date]T[Time][Timezone] であり、T は区切り文字です。明示的なタイムゾーンが指定されていない場合は、UTC (Z) がデフォルトとみなされます。

Timezone

サポートされているタイムゾーン形式は次のとおりです。
+ \$1/-HH:mm
+ \$1/-HHmm
+ \$1/-HH

 日時文字列にタイムゾーンを配置することは任意です。タイムゾーンオフセットが 0 の場合は、上記のタイムゾーンのプレフィックスの代わりに Z を使用して UTC 時間を指定できます。サポートされているタイムゾーンの範囲は -14:00 から \$114:00 です。

日付

タイムゾーンが存在しない場合、またはタイムゾーンが UTC (Z) の場合、サポートされている日付形式は次のとおりです。

**注記**  
DDD は、001 から 365 (うるう年については 366) までの年を表す序数の日付を指します。例えば、2024-002 は 2024 年 1 月 2 日を表します。
+ `yyyy-MM-dd`
+ `yyyyMMdd`
+ `yyyy-MM`
+ `yyyyMM`
+ `yyyy-DDD`
+ `yyyyDDD`
+ `yyyy`

Z 以外のタイムゾーンを選択した場合、サポートされている日付形式は次のように制限されます。
+ `yyyy-MM-dd`
+ `yyyy-DDD`
+ `yyyyDDD`

サポートされている日付の範囲は 1400-01-01～9999-12-31 です。

Time

タイムゾーンが存在しない場合、またはタイムゾーンが UTC (Z) の場合、サポートされている時間形式は次のとおりです。
+ `HH:mm:ss.SSS`
+ `HH:mm:ss`
+ `HHmmss.SSS`
+ `HHmmss`
+ `HH:mm`
+ `HHmm`
+ `HH`

Z 以外のタイムゾーンを選択した場合、サポートされている時間形式は次のように制限されます。
+ `HH:mm:ss`
+ `HH:mm:ss.SSS`

### Neptune openCypher 言語セマンティクスの違い
<a name="opencypher-compliance-semantics"></a>

Neptune は、ノードとリレーションシップ ID を整数ではなく文字列で表します。ID は、データローダーによって指定された ID と等しくなります。カラムに名前空間がある場合、名前空間に ID を加えたもの。よって、`id` 関数は、整数の代わりに文字列を返します。

`INTEGER` データ型は 64 ビットに制限されています。より大きな浮動小数点値または文字列値を整数に変換する場合`TOINTEGER` 関数、負の値は `LLONG_MIN` に切り捨てられ、正の値は `LLONG_MAX` に切り捨てられます。

例えば、次のようになります。

```
RETURN TOINTEGER(2^100)
>  9223372036854775807

RETURN TOINTEGER(-1 * 2^100)
>  -9223372036854775808
```

### 複数値プロパティ
<a name="openCypher-compliance-mvp"></a>

 openCypher CREATE は複数値のプロパティを作成しませんが、Gremlin (Neptune データベース) を使用して作成されたデータや、データのロード時 (Neptune データベースと Neptune Analytics) に存在できます。Neptune openCypher が複数値プロパティを検出すると、いずれかの値が任意に選択され、非決定的な結果が作成されます。

### NaN 値の処理
<a name="openCypher-compliance-handling-nan"></a>

 Neptune による `NaN` プロパティ値の比較処理は未定義です。このような比較に依存すると、予期しない結果や非決定的な結果になる可能性があります。