

本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。

# 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 Documentation](http://tinkerpop.apache.org/docs/current/reference/) 和 Gremlin 的 Apache TinkerPop 實作定義，而不是由型式規格定義。
+ 對於數值格式，Gremlin 遵循 IEEE 754 標準 ([IEEE 754-2019 - 浮點數運算的 IEEE 標準](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 變數或參數化，但是您可能經常會在網際網路上遇到 Gemlin 伺服器的範例指令碼，其中包含變數宣告，例如：

```
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，您可能會遇到很多這樣的範例，而且關於需要參數化，它們聽起來都非常有說服力。

不過，變數宣告功能和參數化功能 (以及警告) 只在使用 `GremlinGroovyScriptEngine` 時才適用於 TinkerPop 的 Grimlin 伺服器。當 Gremlin 伺服器使用 Gramlin 的 `gremlin-language` ANTLR 文法來解析查詢時，它們不適用。ANTLR 語法不支援變數宣告或參數化，因此在使用 ANTLR 時，您不必擔心無法參數化。因為 ANTLR 文法是 TinkerPop 的較新元件，因此您在網際網路上可能遇到的較舊內容通常不會反映這種差異。

Neptune 會在其查詢處理引擎中使用 ANTLR 文法，而不是 `GremlinGroovyScriptEngine`，因此它不支援變數或參數化或 `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 請求中使用 `single`，而不是 `org.apache.tinkerpop.gremlin.structure.VertexProperty.Cardinality.single`。

列舉類型由參數類型決定。

下表顯示允許的列舉值和相關的 TinkerPop 完全合格名稱。

| 允許值 | 類別 | 
| --- |--- |
| id, 金鑰, 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.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) | 
| 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, 無 | [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 不支援任意 Java 所定義以外的呼叫方法或除了支援的 Gremlin API 以外的 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 並將其轉換為字串，格式如下：`"48af8178-50ce-971a-fc41-8c9a954cea62"`。這些 UUID 不符合 RFC 標準，因此，如果您需要標準 UUID，則應在外部產生它們，並在您新增頂點或邊緣時提供它們。

**注意**  
不過，Neptune `Load` 命令要求您使用 Neptune CSV 格式的 **\$1id** 欄位提供 ID。

## 使用者提供的 ID
<a name="feature-gremlin-differences-user-supplied-ids"></a>

使用者提供的 ID 允許使用在 Neptune Gremlin，條文如下。
+ 提供的 ID 是選用的。
+ 僅支援頂點和邊緣。
+ 僅支援 `String` 類型。

若要建立使用自訂 ID 的新頂點，請使用 `property` 步驟搭配 `id` 關鍵字：`g.addV().property(id, 'customid')`。

**注意**  
 不要將引號放在 `id` 關鍵字旁邊。它指的是 `T.id`。

所有的頂點 ID 必須各不相同，且所有的邊緣 ID 必須各不相同。不過，Neptune 確實允許頂點和邊緣具有相同的 ID。

如果您嘗試使用 `g.addV()` 建立新頂點，而使用該 ID 的頂點已存在，則操作會失敗。例外狀況為，如果您為頂點指定新的標籤，操作即會成功，但會將新標籤及指定的任何其他屬性新增至現有的頂點。不會覆寫任何項目。此舉不會建立新的頂點。頂點 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>

Vertex 屬性 ID 將自動產生，且查詢時可顯示為正數或負數。

## 頂點屬性的基數
<a name="feature-gremlin-differences-vertex-property-cardinality"></a>

Neptune 支援成組基數和單一基數。如未指定，則選取設定基數。這表示，如果您設定屬性值，它將新增新的值至屬性，但前提是其不能出現在值組內。此為 [Set](https://tinkerpop.apache.org/javadocs/3.7.2/core/org/apache/tinkerpop/gremlin/structure/VertexProperty.Cardinality.html) 的 Gremlin 列舉值。

不支援 `List`。如需屬性基數的詳細資訊，請參閱 Gremlin JavaDoc 中的 [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...-) 主題。

## 更新頂點屬性
<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")` 將新增有三種不同標籤的頂點。`hasLabel` 步驟將比對此頂點和這三個標籤：`hasLabel("Label1")`、`hasLabel("Label2")` 和 `hasLabel("Label3")`。

**重要**  
`::` 分隔符號僅針對本用途保留。您不能在 `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 請求中使用 `single`，而不是 `org.apache.tinkerpop.gremlin.structure.VertexProperty.Cardinality.single`。

## 序列化
<a name="feature-gremlin-differences-serialization"></a>

Neptune 根據請求的 MIME 類型支援下列序列化。

 Neptune 會公開 TinkerPop 執行的所有序列化程式，並支援 GraphSON 和 GraphBinary 的各種版本和組態。雖然存在許多選項，但使用 的指引非常簡單：
+  如果您使用的是 Apache TinkerPop 驅動程式，則偏好驅動程式的預設值，而不明確指定一個驅動程式。除非您有非常具體的原因，否則您可能不需要在驅動程式初始化中指定序列化程式。一般而言，驅動程式使用的預設值為 `application/vnd.graphbinary-v1.0`。
+  如果您是透過 HTTP 連線至 Neptune，請優先使用 `application/vnd.gremlin-v3.0+json;types=false`做為替代 GraphSON 3 版本中的內嵌類型，讓使用 變得複雜。
+  通常只有在與 [Gremlin 主控台](https://docs.aws.amazon.com//neptune/latest/userguide/access-graph-gremlin-console.html)搭配使用時`application/vnd.graphbinary-v1.0-stringd`才有用，因為它會將所有結果轉換為字串表示法以進行簡單顯示。
+  由於傳統原因，其餘格式仍然存在，通常不應在沒有明確原因的情況下與驅動程式搭配使用。

|  |  |  | 
| --- |--- |--- |
| 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 或預設使用它的驅動程式版本，則應切換到 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 步驟：
+ Neptune 中僅部分支援 Gremlin [io( ) 步驟](http://tinkerpop.apache.org/docs/3.7.2/reference/#io-step)。它可以在讀取內容中使用，如 `g.io((url)).read()` 中所示，但不能寫入。

## Neptune 中的 Gremlin 圖形功能
<a name="gremlin-api-reference-features"></a>

Gremlin 的 Neptune 實作不會公開 `graph` 物件。下表列出 Grimlin 功能，並指出 Neptune 是否支持它們。

### Neptune 對 `graph` 功能的支援
<a name="gremlin-api-graph-features"></a>

Neptune 圖形功能 (如果支援) 與 `graph.features()` 命令將傳回的功能相同。


| 
| 
| 圖形功能 | 已啟用？ | 
| --- |--- |
| 交易 |  true | 
| ThreadedTransactions |  false | 
| Computer |  false | 
| Persistence |  true | 
| ConcurrentAccess |  true | 

### Neptune 對變數功能的支援
<a name="gremlin-api-variable-features"></a>


| 
| 
| 變數功能 | 已啟用？ | 
| --- |--- |
| 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 | 

### 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 | 
| Properties |  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>


| 
| 
| 邊緣屬性功能 | 已啟用？ | 
| --- |--- |
| Properties |  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 部分：Datatypes](https://www.w3.org/TR/xmlschema11-2/) 規格，其與 IEEE 754 規格一致 ([IEEE 754-2019 - 浮點數運算的 IEEE 標準](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 規格中的 [Prefixed Names](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 會將每個三元組與一個具名圖形建立關聯。預設圖形是定義成所有具名圖形的聯集。

**查詢的預設圖形**  
若您提交 SPARQL 查詢而未透過 `GRAPH` 關鍵字或 `FROM NAMED` 之類的建構式明確指定圖形，Neptune 一律會考慮資料庫執行個體中的所有三元組。例如，以下查詢將從 Neptune SPARQL 端點傳回所有三元組：

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

顯現於多個圖形中的三元組將僅傳回一次。

如需預設圖形規格的相關資訊，請參閱 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 叢集具有數個不同的端點，所以在解析相對 IRI 時，使用查詢或更新的請求 URL 做為基礎 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 特殊浮點值的方式如下。

### Neptune 中的 SPARQL NaN 處理
<a name="feature-overview-NaN-comparisons"></a>

在 Neptune 中，SPARQL 可以接受查詢中的 `NaN` 值。signalling 和 quiet `NaN` 值之間沒有任何區別。Neptune 會將所有 `NaN` 值視為 quiet。

在語意上，不可能進行 `NaN` 的比較，因為沒有任何值大於、小於或等於 `NaN`。這表示理論上，比較一端的 `NaN` 值和另一端的「任何內容」**永遠不相符。

 不過，[XSD 規格](https://www.w3.org/TR/xmlschema-2/#double)確實將兩個 `xsd:double` 或 `xsd:float` `NaN` 值視為相等。對於 `IN` 篩選條件、篩選條件表達式的等於運算子，以及完全相符語義 (在三重模式的物件位置中具有 `NaN`)，Neptune 皆遵循此原則。

### Neptune 中的 SPARQL 無限值處理
<a name="feature-overview-infinity-comparisons"></a>

在 Neptune 中，SPARQL 可接受查詢中的 `INF` 或 `-INF` 值。`INF` 會相比為大於任何其他數值，而 `-INF` 會相比為小於任何其他數值。

比較具有相符符號的兩個 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 整數、浮點數和小數值的儲存大小限制在 64 位元。使用較大的值會導致 `InvalidNumericDataException` 錯誤。

## Neptune 擴充 SPARQL 中的等於比較
<a name="feature-overview-sparql-not-equal"></a>

SPARQL 標準為值運算式定義了三元邏輯，其中，值運算式可評估為 `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>` 時會產生 `error`，而不是 `false`，因為沒有為自訂資料類型 `<http://example.com/IPAddress>` 指定明確的比較規則。因此，第二個查詢中的否定版本也會產生 `error`。在這兩個查詢中，`error` 會導致篩選出候選解決方案。

從 1.0.2.1 版開始，Neptune 已根據規格擴展 SPARQL 不等式運算子。請參閱 [SPARQL 第 1.1 節，運算子可擴充性](https://www.w3.org/TR/sparql11-query/#operatorExtensibility)，讓引擎定義如何跨使用者定義和不可比較內建資料類型進行比較的其他相關規則。

使用此選項，如果常值和資料類型在語法上相等，則 Neptune 會立即將在運算子對應表中未明確定義的任何兩個資料類型的比較視同評估為 `true`，否則為 false。任何情況下都不會發生 `error`。

使用這些新的語意，第二個查詢就會傳回 `"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 的常值)，Neptune 會接受此超出範圍值的原樣，但不會四捨五入或截斷。但因為指定的類型不能代表此值，所以不會保存為數值。

也就是說，即使 `"999"^^xsd:byte` 是已定義之 `xsd:byte` 值範圍外的值，Neptune 也會接受它。但是，在資料庫中保存該值之後，此值只能用於三重模式物件位置的完全相符語義。因為超出範圍的常值不被視為數值，所以不會對其執行任何範圍篩選。

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 查詢語言參考第 9 版](https://s3.amazonaws.com/artifacts.opencypher.org/openCypher9.pdf)) 中定義的子句、運算子、運算式、函數和語法。下面列出了 Neptune 對 OpenCypher 支援的限制和差異。

 Amazon Neptune 也支援 openCypher 規格範圍以外的多種功能。請參閱 [Amazon Neptune 中的 openCypher 延伸模組](access-graph-opencypher-extensions.md) 以取得詳細資訊。

**注意**  
Cypher 的目前 Neo4j 實作包含了上述 OpenCypher 規格中未包含的功能。如果您要將目前 Cypher 程式碼遷移至 Neptune，請參閱 [Neptune 與 Neo4j 的相容性](migration-compatibility.md) 和 [重寫 Cypher 查詢以在 Neptune 上的 OpenCpher 中執行](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) (將清單中的字串串連為單一字串)
+ `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) (將清單中的字串串連為單一字串)
+ `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)指定每個解決方案必須周遊每個邊緣最多一次。

對於 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。或者，您可以使用 實驗室模式參數`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() 函數。例如，在此功能之前，以下查詢是不可能的。

  透過屬性的日期時間 ()：

  ```
  // 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
  ```

  中繼結果的日期時間 ()：

  ```
  // Parse datetime from parameter
  UNWIND $list as myDate
  RETURN datetime(myDate) as d
  ```
+ 現在也可以儲存在上述情況下建立 的日期時間權限。

  將日期時間從一個屬性的字串屬性儲存至另一個屬性：

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

  使用 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"}
    ]
  }
  ```
+ 支援較大的 ISO8601 日期時間格式子集。請參閱以下 。

支援的格式

 日期時間值的格式為 【Date】T【Time】【Timezone】，其中 T 是分隔符號。如果未提供明確的時區，則會假設 UTC (Z) 為預設值。

時區

支援的時區格式為：
+ \$1/-HH：mm
+ \$1/-HHmm
+ \$1/-HH

 日期時間字串中存在時區是選用的。如果時區位移為 0，則可以使用 Z 而不是上面的時區後綴來表示 UTC 時間。時區的支援範圍是 -14：00 到 \$114：00。

Date

如果沒有時區，或時區為 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。

時間

如果沒有時區，或時區為 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 valuse 的處理
<a name="openCypher-compliance-handling-nan"></a>

 Neptune 對`NaN`屬性值比較的處理方式未定義。依賴這類比較可能會導致非預期或非確定性的結果。