기계 번역으로 제공되는 번역입니다. 제공된 번역과 원본 영어의 내용이 상충하는 경우에는 영어 버전이 우선합니다.
# Amazon Neptune의 openCypher 확장
Amazon Neptune은 openCypher 사양 참조 버전 9를 지원합니다. 자세한 내용은 Amazon Neptune의 [Amazon Neptune에 적용되는 openCypher 사양 규정 준수](feature-opencypher-compliance.md) 섹션을 참조하세요. 또한 Amazon Neptune은 여기에 나열된 기능을 지원합니다. 특정 버전이 언급되지 않는 한이 기능은 Neptune 데이터베이스 및 Neptune Analytics에서 사용할 수 있습니다.
## 쿼리 시간 S3 데이터 액세스
Neptune 데이터베이스 1.4.7.0 이상에서 사용할 수 있습니다.
Neptune은 openCypher 쿼리 내에서 Amazon S3에서 직접 CSV 또는 Parquet 데이터를 읽는 `neptune.read()` 함수를 지원합니다. 쿼리 전에 데이터를 가져오는 대량 로더와 달리는 쿼리 실행 시 Amazon S3 데이터에 `neptune.read()` 액세스합니다.
전체 설명서는 섹션을 참조하세요[neptune.read()](access-graph-opencypher-21-extensions-s3-read.md).
## 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](engine-releases-1.2.0.2.md)부터 Neptune은 openCypher 사양을 확장하여 이제 `CREATE`, `MERGE`, `MATCH` 절에서 노드 및 관계 `id` 값을 지정할 수 있게 되었습니다. 이를 통해 시스템에서 생성한 UUID 대신 사용자에게 친숙한 문자열을 할당하여 노드와 관계를 식별할 수 있습니다.
Neptune Analytics에서는 엣지에 사용자 지정 ID 값을 사용할 수 없습니다.
**주의**
openCypher 사양에 대한 이 확장은 이제 `~id`를 예약된 속성 이름으로 간주하므로, 이전 버전과는 호환되지 않습니다. 이미 `~id`를 데이터 및 쿼리의 속성으로 사용하고 있는 경우 기존 속성을 새 속성 키로 마이그레이션하고 이전 속성을 제거해야 합니다. [현재 `~id`를 속성으로 사용 중인 경우 취해야 할 조치](#opencypher-compliance-custom-ids-migrating)을(를) 참조하세요.
다음은 사용자 지정 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](engine-releases-1.2.0.2.md)부터 openCypher 절의 `~id` 키는 이제 속성 대신 `id`로 취급됩니다. 즉, 이름이 `~id`로 지정된 속성이 있으면 해당 속성에 액세스할 수 없게 됩니다.
`~id` 속성을 사용하는 경우 엔진 릴리스 `1.2.0.2` 이상으로 업그레이드하기 전에 먼저 기존 `~id` 속성을 새 속성 키로 마이그레이션한 후 `~id` 속성을 제거해야 합니다. 그 예로, 아래 쿼리를 살펴보겠습니다.
+ 모든 노드에 대해 'newId'라는 새 속성을 생성합니다.
+ '\$1id' 속성의 값을 'newId' 속성에 복사합니다.
+ 데이터에서 '\$1id' 속성을 제거합니다.
```
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](https://docs.aws.amazon.com/releases/release-1.4.5.0.xml) 이상에서 사용할 수 있습니다.
### 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로 정규화되므로 \$108: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\$112)에서 월을 반환합니다. `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로 정규화되므로 \$108: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로 정규화되므로 \$108: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
}]
}
```