Amazon Neptune의 openCypher 확장 - Amazon Neptune
join() 함수removeKeyFromMap() 함수사용자 지정 ID 값Neptune에서 CALL 하위 쿼리 지원Neptune openCypher 함수정렬 함수시간 함수

기계 번역으로 제공되는 번역입니다. 제공된 번역과 원본 영어의 내용이 상충하는 경우에는 영어 버전이 우선합니다.

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() 함수를 구현합니다. 문자열 리터럴 목록과 문자열 구분 기호를 사용하여 문자열 리터럴을 생성합니다. 2가지 인수를 사용합니다.

  • 첫 번째 인수는 문자열 리터럴 목록입니다.

  • 두 번째 인수는 0자, 1자 또는 2자 이상의 문자로 구성될 수 있는 구분 기호 문자열입니다.

예제:

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

Neptune 전용 removeKeyFromMap() 함수

Neptune 데이터베이스 및 Neptune Analytics에서 사용할 수 있습니다.

Neptune은 openCypher 사양에 없는 removeKeyFromMap() 함수를 구현합니다. 맵에서 지정된 키를 제거하고 생성된 새 맵을 반환합니다.

함수는 2가지 인수를 사용합니다.

  • 첫 번째 인수는 키를 제거할 맵입니다.

  • 두 번째 인수는 맵에서 제거할 키입니다.

이 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를 속성으로 사용 중인 경우 취해야 할 조치을(를) 참조하세요.

다음은 사용자 지정 ID가 있는 노드와 관계를 생성하는 방법을 보여주는 예제입니다.

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 하위 쿼리 내에서 사용되는 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?)

text 범위에서 from 오프셋(포함)부터 to 오프셋(제외)까지의 범위 내에서 lookup의 첫 번째 발생 위치의 인덱스를 반환합니다. to가 -1인 경우 범위는 text의 끝까지 계속됩니다. 인덱싱은 0을 기준으로 하며 Unicode scalar 값(대체 코드 포인트가 아닌)으로 표현됩니다.

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?)

second에서 요소를 제외하는 first의 모든 고유 요소가 포함된 새 목록을 반환합니다.

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?)

각 key 속성의 값을 기준으로 노드 요소를 정렬하여 coll 입력 목록의 정렬된 버전을 반환합니다.

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(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(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
    }]
}

Neptune openCypher 함수

Neptune 데이터베이스 1.4.6.0 이상 및 Neptune Analytics에서 사용할 수 있습니다.

reduce()

reduce는 각 목록 요소를 누적 합계 또는 '누적기'와 결합하여 순차적으로 처리합니다. 초기값으로 시작하여, 각 연산 후 누적기를 업데이트하고 그 업데이트된 값을 다음 반복에 사용합니다.

for i in (0, ..., n) acc = acc X list[I], where X denotes any binary operator

모든 요소가 처리되면 최종 누적 결과를 반환합니다.

일반적인 reduce() 구조: reduce(accumulator = initial , variable IN list | expression)

유형 사양:

- initial: starting value for the accumulator :: (Long | FLOAT | STRING | LIST? OF (STRING, LONG, FLOAT)) - list: the input list :: LIST OF T where T matches initial type - variable :: represents each element in the input list - expression :: Only supports '+' and '*' operator - return :: Same type as initial

제한 사항:

현재 reduce() 표현식은 다음만 지원합니다.

  • 숫자 곱셈

  • 숫자 덧셈

  • 문자열 연결

  • 목록 연결

+ 또는 * 연산자로 표시됩니다. 표현식(이진 표현식): expression pattern: accumulator + any variable or accumulator * any variable

오버플로 처리:

Neptune은 reduce() 평가 중에 숫자 오버플로를 감지하고 데이터 유형에 따라 다르게 응답합니다.

LONG (signed 64‑bit)
--------------------
• Valid range: –9 223 372 036 854 775 808 … 9 223 372 036 854 775 807  
• If any intermediate or final value falls outside this range,
  Neptune aborts the query with long overflow error message.
  
FLOAT (IEEE‑754 double)
-----------------------
• Largest finite value ≈ 1.79 × 10^308  
• Larger results overflow to INF
  Once `INF` is produced, it propagates through the remainder
  of the reduction.
예시:

reduce() 함수에 대한 다음 예제를 참조하세요.


1. Long Addition:
RETURN reduce(sum = 0, n IN [1, 2, 3] | sum + n)
{
  "results": [{
      "reduce(sum = 0, n IN [1, 2, 3] | sum + n)": 6
    }]
}

2. String Concatenation:
RETURN reduce(str = "", x IN ["A", "B", "C"] | str + x) 
{
  "results": [{
      "reduce(str = "", x IN ["A", "B", "C"] | str + x)": "ABC"
    }]
}

3. List Combination:
RETURN reduce(lst = [], x IN [1, 2, 3] | lst + x)
{
  "results": [{
      "reduce(lst = [], x IN [1, 2, 3] | lst + x)": [1, 2, 3]
    }]
}

4. Float Addition:
RETURN reduce(total = 0.0, x IN [1.5, 2.5, 3.5] | total + x) 
{
  "results": [{
      "reduce(total = 0.0, x IN [1.5, 2.5, 3.5] | total + x)": 7.5
    }]
}

5. Long Multiplication:
RETURN reduce(product = 1, n IN [1, 2, 3] | product * n)
{
  "results": [{
      "reduce(product = 0, n IN [1, 2, 3] | product * n)": 6
    }]
}

6. Float Multiplication:
RETURN reduce(product = 1.0, n IN [1.5, 2.5, 3.5] | product * n)
{
  "results": [{
      "reduce(product = 1.0, n IN [1.5, 2.5, 3.5] | product * n)": 13.125
    }]
}

7. Long Overflow (Exception):
RETURN reduce(s = 9223372036854775807, x IN [2, 3] | s * x) AS result
{
"results": [{
    "reduce(s = 9223372036854775807, x IN [2, 3] | s * x) AS result": long overflow
    }]
}

8. Float Overflow:
RETURN reduce(s = 9.0e307, x IN [8.0e307, 1.0e307] | s + x) AS result
{
"results": [{
    "reduce(s = 9.0e307, x IN [8.0e307, 1.0e307] | s + x) AS result": INF
    }]
}