Amazon Neptune 中的 openCypher 延伸模組

Amazon Neptune 支援 openCypher 規格參考第 9 版。如需詳細資訊，請參閱 Amazon Neptune Amazon Neptune 中的 openCypher 規格合規中的 。此外，Amazon Neptune 支援此處列出的功能。除非提及特定版本，否則這些功能可在 Neptune 資料庫和 Neptune Analytics 中使用。

Neptune 特定 join() 函數

可用於 Neptune 資料庫和 Neptune Analytics。

Neptune 實作一個不存在於 openCypher 規格中的 join() 函數。它從字串常值清單和字串分隔符號中建立一個字串常值。它需要兩個引數：

• 第一個引數是字串常值的清單。

• 第二個引數是分隔符號，它可以由零個、一個或多個字元組成。

範例：

join(["abc", "def", "ghi"], ", ")    // Returns "abc, def, ghi"

Neptune 特定 removeKeyFromMap() 函數

可用於 Neptune 資料庫和 Neptune Analytics。

Neptune 實作一個不存在於 openCypher 規格中的 removeKeyFromMap() 函數。它從映射中刪除指定的索引鍵，並傳回產生的新映射。

函數需要兩個引數：

• 第一個引數是要從中移除索引鍵的映射。

• 第二個引數是要從映射中移除的索引鍵。

在您想要透過展開映射清單來設定節點或關係值的情況下，removeKeyFromMap() 函數特別有用。例如：

UNWIND [{`~id`: 'id1', name: 'john'}, {`~id`: 'id2', name: 'jim'}] as val
CREATE (n {`~id`: val.`~id`})
SET n = removeKeyFromMap(val, '~id')

節點和關係屬性的自訂 ID 值

可用於 Neptune 資料庫 1.2.0.2 及更高版本，以及 Neptune Analytics。

從引擎 1.2.0.2 版開始，Neptune 已擴展 OpenCypher 規格，因此您現在可以在 CREATE、MERGE 和 MATCH 子句中指定節點和關係的 id 值。這可讓您指派易於使用的字串，而不是系統產生的 UUID 來識別節點和關係。

在 Neptune Analytics 中，自訂 ID 值不適用於邊緣。

警告

OpenCypher 規格的這個延伸模組不與舊版相容，因為 ~id 現在被視為保留的屬性名稱。如果您已在資料和查詢中使用 ~id 做為屬性，則必須將現有屬性遷移至新的屬性索引鍵，並移除舊的屬性索引鍵。請參閱 如果您目前使用 ~id 做為屬性，該怎麼辦。

以下範例展示如何建立具有自訂 IDS 的節點和關聯性：

CREATE (n {`~id`: 'fromNode', name: 'john'})
  -[:knows {`~id`: 'john-knows->jim', since: 2020}]
  ->(m {`~id`: 'toNode', name: 'jim'})

如果您嘗試建立已在使用中的自訂 ID，Neptune 會擲回 DuplicateDataException 錯誤。

以下是在 MATCH 子句中使用自訂 ID 的範例：

MATCH (n {`~id`: 'id1'})
RETURN n

以下是在 MERGE 子句中使用自訂 ID 的範例：

MATCH (n {name: 'john'}), (m {name: 'jim'})
MERGE (n)-[r {`~id`: 'john->jim'}]->(m)
RETURN r

如果您目前使用 ~id 做為屬性，該怎麼辦

使用引擎 1.2.0.2 版，OpenCypher 子句中的 ~id 金鑰現在被視為 id，而不是做為一個屬性。這表示，如果您有一個名為 ~id 的屬性，將無法存取它。

如果您使用的是 ~id 屬性，則在升級至引擎版本 1.2.0.2 或更高版本之前必須做的事情，首先是將現有 ~id 屬性遷移至新的屬性索引鍵，然後刪除 ~id 屬性。例如，下面查詢：

• 為所有節點建立一個名為 'newId' 的新屬性、

• 將 '~id' 屬性的值複製到 'NewID' 屬性，

• 然後從資料中刪除 '~id' 屬性

MATCH (n)
WHERE exists(n.`~id`)
SET n.newId = n.`~id`
REMOVE n.`~id`

對於資料中具有 ~id 屬性的任何關係，也需要執行相同的操作。

您還必須變更您正在使用且參考 ~id 屬性的任何查詢。例如，這個查詢：

MATCH (n)
WHERE n.`~id` = 'some-value'
RETURN n

...將會變更這樣：

MATCH (n)
WHERE n.newId = 'some-value'
RETURN n

Neptune 中的 CALL 子查詢支援

可用於 Neptune 資料庫 1.4.1.0 及更新版本，以及 Neptune Analytics。

Amazon Neptune 支援CALL子查詢。CALL 子查詢是主要查詢的一部分，在CALL子查詢的每個輸入隔離範圍內執行。

例如，假設圖表包含有關人們、朋友和他們居住城市的資料。我們可以使用CALL子查詢來擷取每個朋友都住在其中的兩個最大城市：

MATCH (person:Person)-[:knows]->(friend) 
CALL { 
  WITH friend 
  MATCH (friend)-[:lived_in]->(city) 
  RETURN city 
  ORDER BY city.population DESC
  LIMIT 2 
} 
RETURN person, friend, city

在此範例中，CALL { ... }會針對前面 MATCH 子句相符friend的每個 執行內部的查詢部分。執行內部查詢時， ORDER和 LIMIT子句位於特定朋友居住城市的本機，因此我們為每個朋友取得 （最多） 兩個城市。

所有查詢子句都可在CALL子查詢中使用。這也包括巢狀CALL子查詢。第一個WITH子句和發出的變數存在一些限制，如下所述。

CALL 子查詢內的變數範圍

在子查詢內使用的CALL子查詢之前，子句中的變數必須由初始WITH子句匯入。與一般WITH子句不同，它只能包含變數清單，但不允許別名，並且不能與 DISTINCT、ORDER BY、WHERE、 SKIP或 一起使用LIMIT。

從 CALL 子查詢傳回的變數

從CALL子查詢發出的變數會以最終RETURN子句指定。請注意，在CALL子查詢之前，發出的變數不能與變數重疊。

限制

目前不支援CALL子查詢內的更新。

Neptune openCypher 函數

可用於 Neptune 資料庫 1.4.1.0 及更新版本，以及 Neptune Analytics。

textIndexOf

textIndexOf(text :: STRING, lookup :: STRING, from = 0 :: INTEGER?, to = -1 :: INTEGER?) :: (INTEGER?)

傳回lookup從位移 from（包含） text 開始到位移 to（排除） 範圍內第一次出現 的索引。如果 to是 -1，範圍會繼續到 的結尾text。索引是以零為基礎，並以 Unicode 純量值 （非替代程式碼點） 表示。

RETURN textIndexOf('Amazon Neptune', 'e')
{
  "results": [{
      "textIndexOf('Amazon Neptune', 'e')": 8
    }]
}

collToSet

collToSet(values :: LIST OF ANY?) :: (LIST? OF ANY?)

傳回只包含原始清單中唯一元素的新清單。維護原始清單的順序 （例如[1, 6, 5, 1, 5]傳回 [1, 6, 5])。

RETURN collToSet([1, 6, 5, 1, 1, 5])
{
  "results": [{
      "collToSet([1, 6, 5, 1, 1, 5])": [1, 6, 5]
    }]
}

collSubtract

collSubtract(first :: LIST OF ANY?, second :: LIST OF ANY?) :: (LIST? OF ANY?)

傳回新清單，其中包含從 first 排除元素的所有唯一元素second。

RETURN collSubtract([2, 5, 1, 0], [1, 5])
{
  "results": [{
      "collSubtract([2, 5, 1, 0], [1, 5])": [0, 2]
    }]
}

collIntersection

collIntersection(first :: LIST? OF ANY?, second :: LIST? OF ANY?) :: (LIST? OF ANY?)

傳回新清單，其中包含 first和 交集的所有唯一元素second。

RETURN collIntersection([2, 5, 1, 0], [1, 5])
{
  "results": [{
      "collIntersection([2, 5, 1, 0], [1, 5])": [1, 5]
    }]
}

排序函數

下列各節定義要排序集合的函數。這些函數採用 （在某些情況下為選用） config 映射引數，或定義排序索引鍵和/或排序方向的多個此類映射清單：

{ key: STRING, order: STRING }

key 以下是對應或節點屬性，其值將用於排序。 分別order是「asc」或「desc」（不區分大小寫） 來指定遞增或遞減排序。根據預設，排序會以遞增順序執行。

collSort

collSort(coll :: LIST OF ANY, config :: MAP?) :: (LIST? OF ANY?)

傳回包含coll輸入清單中元素的新排序清單。

RETURN collSort([5, 3, 1], {order: 'asc'})
{
  "results": [{
      "collSort([5, 3, 1])": [1, 3, 5]
    }]
}

collSortMaps

collSortMaps(coll :: LIST OF MAP, config :: MAP) :: (LIST? OF ANY?)

傳回依指定key屬性值排序的映射清單。

RETURN collSortMaps([{name: 'Alice', age: 25}, {name: 'Bob', age: 35}, {name: 'Charlie', age: 18}], {key: 'age', order: 'desc'})
{
  "results": [{
      "x": [{
          "age": 35,
          "name": "Bob"
        }, {
          "age": 25,
          "name": "Alice"
        }, {
          "age": 18,
          "name": "Charlie"
        }]
    }]
}

collSortMulti

collSortMulti(coll :: LIST OF MAP?, 
configs = [] :: LIST OF MAP, 
limit = -1 :: INTEGER?, 
skip = 0 :: INTEGER?) :: (LIST? OF ANY?)

傳回依指定key屬性值排序的映射清單，選擇性地套用限制並略過。

RETURN collSortMulti([{name: 'Alice', age: 25}, {name: 'Bob', age: 35}, {name: 'Charlie', age: 18}], [{key: 'age', order: 'desc'}, {key:'name'}]) as x
{
  "results": [{
      "x": [{
          "age": 35,
          "name": "Bob"
        }, {
          "age": 25,
          "name": "Alice"
        }, {
          "age": 18,
          "name": "Charlie"
        }]
    }]
}

collSortNodes

collSortNodes(coll :: LIST OF NODE, config :: MAP) :: (LIST? OF NODE?)

傳回coll輸入清單的排序版本，依其各自key屬性的值排序節點元素。

create (n:person {name: 'Alice', age: 23}), (m:person {name: 'Eve', age: 21}), (o:person {name:'Bob', age:25})
{"results":[]}

match (n:person) with collect(n) as people return collSortNodes(people, {key: 'name', order: 'desc'})
{
  "results": [{
      "collSortNodes(people, 'name')": [{
          "~id": "e599240a-8c23-4337-8aa8-f603c8fb5488",
          "~entityType": "node",
          "~labels": ["person"],
          "~properties": {
            "age": 21,
            "name": "Eve"
          }
        }, {
          "~id": "8a6ef785-59e3-4a0b-a0ff-389655a9c4e6",
          "~entityType": "node",
          "~labels": ["person"],
          "~properties": {
            "age": 25,
            "name": "Bob"
          }
        }, {
          "~id": "466bc826-f47f-452c-8a27-6b7bdf7ae9b4",
          "~entityType": "node",
          "~labels": ["person"],
          "~properties": {
            "age": 23,
            "name": "Alice"
          }
        }]
    }]
}

match (n:person) with collect(n) as people return collSortNodes(people, {key: 'age'})
{
  "results": [{
      "collSortNodes(people, '^age')": [{
          "~id": "e599240a-8c23-4337-8aa8-f603c8fb5488",
          "~entityType": "node",
          "~labels": ["person"],
          "~properties": {
            "age": 21,
            "name": "Eve"
          }
        }, {
          "~id": "466bc826-f47f-452c-8a27-6b7bdf7ae9b4",
          "~entityType": "node",
          "~labels": ["person"],
          "~properties": {
            "age": 23,
            "name": "Alice"
          }
        }, {
          "~id": "8a6ef785-59e3-4a0b-a0ff-389655a9c4e6",
          "~entityType": "node",
          "~labels": ["person"],
          "~properties": {
            "age": 25,
            "name": "Bob"
          }
        }]
    }]
}

暫時函數

暫時函數可從 Neptune 1.4.5.0 版及更新版本取得。

day

day(temporal :: (datetime | date)) :: (LONG)

從 datetime或 date值傳回當月day的 。對於 datetime：值會根據輸入標準化為 UTC，然後再擷取日期。對於 date：根據時區擷取日。

datetime 輸入可在 Neptune 資料庫和 Neptune Analytics 中使用：

RETURN day(datetime('2021-06-03T01:48:14Z'))
{
  "results": [{
      "day(datetime('2021-06-03T01:48:14Z'))": 3
    }]
}

在這裡， datetime 會標準化為 UTC，因此 +08：00 會切換回 6 月 2 日。

RETURN day(datetime('2021-06-03T00:00:00+08:00'))
{
  "results": [{
      "day(datetime('2021-06-03T00:00:00+08:00'))": 2
    }]
}

date 輸入僅適用於 Neptune Analytics：

RETURN day(date('2021-06-03Z'))
{
  "results": [{
      "day(date('2021-06-03Z'))": 3
    }]
}

會date保留時區，並保留 6 月 3 日。

RETURN day(date('2021-06-03+08:00'))
{
  "results": [{
      "day(date('2021-06-03+08:00'))": 3
    }]
}

month

month(temporal :: (datetime | date)) :: (LONG)

從 datetime或 date值 (1-12) 傳回月份。對於 datetime：在擷取月份之前，值會根據輸入標準化為 UTC。對於 date：根據時區擷取月份。

datetime 輸入可在 Neptune 資料庫和 Neptune Analytics 中使用：

RETURN month(datetime('2021-06-03T01:48:14Z'))
{
  "results": [{
      "month(datetime('2021-06-03T01:48:14Z'))": 6
    }]
}

在這裡， datetime 會標準化為 UTC，因此 +08：00 會切換回 5 月 31 日。

RETURN month(datetime('2021-06-01T00:00:00+08:00'))
{
  "results": [{
      "month(datetime('2021-06-01T00:00:00+08:00'))": 5
    }]
}

date 輸入僅適用於 Neptune Analytics：

RETURN month(date('2021-06-03Z'))
{
  "results": [{
      "month(date('2021-06-03Z'))": 6
    }]
}

會date保留時區，並保留 6 月 1 日。

RETURN month(date('2021-06-01+08:00'))
{
  "results": [{
      "month(date('2021-06-01+08:00'))": 6
    }]
}

year

year(temporal :: (datetime | date)) :: (LONG)

從 datetime或 date值傳回年份。對於 datetime：在擷取年份之前，根據輸入將值標準化為 UTC。對於 date：根據時區擷取年份。

datetime 輸入可在 Neptune 資料庫和 Neptune Analytics 中使用：

RETURN year(datetime('2021-06-03T01:48:14Z'))
{
  "results": [{
      "year(datetime('2021-06-03T01:48:14Z'))": 2021
    }]
}

在這裡， datetime 會標準化為 UTC，因此 +08：00 會切換回 2020 年 12 月 31 日。

RETURN year(datetime('2021-01-01T00:00:00+08:00'))
{
  "results": [{
      "year(datetime('2021-01-01T00:00:00+08:00'))": 2020
    }]
}

date 輸入僅適用於 Neptune Analytics：

RETURN year(date('2021-06-03Z'))
{
  "results": [{
      "year(date('2021-06-03Z'))": 2021
    }]
}

會date保留時區，並保留 2021 年 6 月。

RETURN year(date('2021-01-01+08:00'))
{
  "results": [{
      "year(date('2021-01-01+08:00'))": 2021
    }]
}