RETURN#

GQL 절

쿼리를 끝내고 그 결과의 컬럼에 이름을 붙입니다.

개요#

RETURN [ DISTINCT | ALL ] { * | expression [ AS alias ] } [, ...]

굵게 키워드 · 기울임 직접 채우는 자리 · [ ] 생략 가능 · ... 반복 가능. 구문 표기 규약을 참고하십시오.

설명#

RETURN은 마지막 투영입니다. 작업 행마다 한 번씩 자기 표현식을 평가해 그것을 쿼리의 결과 컬럼으로 내놓습니다. 읽기 쿼리는 RETURN이나 FINISH로 끝나야 합니다. 쓰기 쿼리는 그 둘 중 하나로 끝나거나 쓰기 절 자체로 끝날 수 있습니다.

속성에서 끌어낸 컬럼은 jsonb로 돌아옵니다. RETURN m.title은 "The Matrix"를 따옴표와 함께 출력하고, RETURN m.title::text도 그렇습니다. 평범한 스칼라를 얻으려면 그 쿼리를 SQL로 감싸십시오. 참고를 보십시오.
*는 유효 범위의 이름 있는 바인딩을 모두 투영합니다. 이름을 붙이지 않은 패턴 요소는 투영되지 않습니다.
목록 안의 집계 함수는 암시적으로 그룹화합니다. 집계되지 않은 표현식이 그룹화 키가 되며, SQL에서 GROUP BY를 쓴 것과 같습니다.
DISTINCT는 중복된 결과 행을 없앱니다. ALL은 기본값을 명시적으로 적은 것이고 중복을 남깁니다.
ORDER BY, SKIP/OFFSET, LIMIT은 RETURN의 일부가 아니라 그 뒤에 오는 별개의 절입니다. 각각 자기 페이지가 있습니다. ORDER BY와 SKIP·LIMIT입니다.
WITH와 달리 RETURN은 같은 출력 이름을 두 번 허용합니다. 그 뒤에서 그것을 해석해야 하는 것이 없기 때문입니다.

매개변수#

DISTINCT: 결과에서 중복 행을 없앱니다.
ALL: 중복 행을 그대로 둡니다. 기본값입니다.
*: 지금 유효 범위에 있는 이름 있는 바인딩을 모두 투영합니다.
expression: 유효 범위의 바인딩에 대한 Cypher 표현식이면 무엇이든 됩니다. 정점·간선 변수, 속성 참조, 경로 변수, 함수 호출, 집계 함수, 산술 표현식이나 CASE 표현식, 리스트·맵 생성자, 상수가 그렇습니다.
alias: 결과 컬럼의 이름입니다. 큰따옴표가 없으면 소문자로 접힙니다. 적은 대소문자를 유지하려면 따옴표로 감싸십시오. 별칭이 없으면 속성 참조는 그 속성의 이름을 가져가고, 그 밖의 것은 ?column?이 됩니다.

예제#

모든 예제는 예제 데이터셋에서 실행됩니다.

정점 전체 반환하기#

MATCH (p:person {name: 'Keanu Reeves'})
RETURN p;

                         p
---------------------------------------------------
 person[4.1]{"born": 1964, "name": "Keanu Reeves"}
(1 row)

정점은 label[id]{properties} 형태로 출력됩니다. 간선은 양 끝점을 더해 출력합니다:

MATCH (:person {name: 'Keanu Reeves'})-[r:acted_in]->(:movie {title: 'The Matrix'})
RETURN r;

                   r
---------------------------------------
 acted_in[5.1][4.1,3.1]{"role": "Neo"}
(1 row)

별칭이 있을 때와 없을 때의 속성 반환#

MATCH (p:person {name: 'Keanu Reeves'})
RETURN p.born;

 born
------
 1964
(1 row)

별칭 없는 속성 참조는 그 속성의 이름을 가져갑니다. 계산된 표현식에는 가져갈 이름이 없습니다:

MATCH (p:person {name: 'Keanu Reeves'})
RETURN p.born + 1;

 ?column?
----------
 1965
(1 row)

따옴표 없는 별칭은 소문자로 접히고, 따옴표를 붙인 별칭은 그렇지 않습니다:

MATCH (p:person {name: 'Keanu Reeves'})
RETURN p.born AS BornIn;

 bornin
--------
 1964
(1 row)

MATCH (p:person {name: 'Keanu Reeves'})
RETURN p.born AS "BornIn";

 BornIn
--------
 1964
(1 row)

이름 있는 것 전부 반환하기#

MATCH (p:person {name: 'Ryan Gosling'})-[r:acted_in]->(m:movie)
RETURN *;

                         p                          |                   r                   |                                                                                                                                     m
----------------------------------------------------+---------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 person[4.10]{"born": 1980, "name": "Ryan Gosling"} | acted_in[5.13][4.10,3.9]{"role": "K"} | movie[3.9]{"plot": "A new blade runner unearths a long-buried secret that has the potential to plunge what's left of society into chaos.", "year": 2017, "genre": "Sci-Fi", "title": "Blade Runner 2049", "embedding": [0.21560573, -0.07505179, -0.01331814, 0.13403069]}
(1 row)

이름 있는 요소마다 하나씩 세 컬럼입니다. 그 패턴을 (p:person {name: 'Ryan Gosling'})-[:acted_in]->(m:movie)로 적었다면 RETURN *은 둘을 줬을 것입니다.

중복 행 없애기#

acted_in 간선 스물다섯 개가 세 장르의 영화를 가리킵니다:

MATCH (p:person)-[:acted_in]->(m:movie)
RETURN DISTINCT m.genre AS genre
ORDER BY genre;

    genre
-------------
 "Action"
 "Adventure"
 "Sci-Fi"
(3 rows)

DISTINCT가 없으면 같은 쿼리가 25행을 반환합니다. ALL이 그 기본값을 명시적으로 적은 형태입니다.

집계#

다른 표현식 없이 쓴 집계 함수는 입력 전체를 한 행으로 접습니다:

MATCH (m:movie)
RETURN count(*) AS films, min(m.year) AS earliest, max(m.year) AS latest;

 films | earliest | latest
-------+----------+--------
 18    | 1982     | 2021
(1 row)

그 옆에 다른 표현식을 나열하면 그 표현식이 그룹화 키가 됩니다:

MATCH (p:person)-[:acted_in]->(m:movie)
RETURN m.genre AS genre, count(*) AS roles
ORDER BY genre;

    genre    | roles
-------------+-------
 "Action"    | 13
 "Adventure" | 1
 "Sci-Fi"    | 11
(3 rows)

collect()는 한 그룹을 리스트로 모읍니다:

MATCH (p:person)-[:acted_in]->(m:movie {title: 'The Matrix'})
RETURN collect(p.name) AS cast;

                            cast
------------------------------------------------------------
 ["Keanu Reeves", "Laurence Fishburne", "Carrie-Anne Moss"]
(1 row)

상수 반환하기#

RETURN 앞에 패턴이 있어야 하는 것은 아닙니다:

RETURN 1 + 2 AS sum, 'Hello' AS greeting;

 sum | greeting
-----+----------
 3   | "Hello"
(1 row)

참고#

속성에서 끌어낸 컬럼이 jsonb로 돌아오므로, 네이티브 타입을 원하는 애플리케이션에게 RETURN은 좋지 않은 인터페이스입니다. Cypher를 SELECT 서브쿼리에 넣고 거기서 벗겨 내십시오. jsonb 연산자가 그 일을 합니다. ->>는 키를 텍스트로 읽고, #>> '{}'은 jsonb 스칼라 컬럼을 텍스트로 꺼냅니다.

SELECT d.props ->> 'title' AS film, r.score
FROM (MATCH (p:person)-[:directed]->(m:movie)
      WHERE p.name = 'Christopher Nolan'
      RETURN properties(m) AS props) d
JOIN rating r ON r.title = d.props ->> 'title'
WHERE r.source = 'critics'
ORDER BY r.score DESC;

     film     | score
--------------+-------
 Inception    |   8.8
 Interstellar |   8.7
(2 rows)

여기서 영화 제목은 따옴표 없는 텍스트이고, score는 그 테이블 자신의 numeric입니다. 이 방식은 SQL과 Cypher 섞기가 온전히 다룹니다.

호환성#

컬럼 타입#

ISO/IEC 39075 §14.11의 <return statement>는 결과 컬럼에 그 표현식의 선언된 타입을 줍니다. AgensGraph는 표현식의 타입과 무관하게, 명시적으로 형 변환한 뒤에도 모든 Cypher 결과 컬럼을 jsonb로 반환합니다. 위에서처럼 SQL에서 벗겨 내십시오.

DISTINCT와 ORDER BY#

RETURN DISTINCT 뒤의 ORDER BY는 투영에 나타나는 표현식으로만 정렬할 수 있습니다:

MATCH (m:movie) RETURN DISTINCT m.genre AS genre ORDER BY m.year;

ERROR:  for SELECT DISTINCT, ORDER BY expressions must appear in select list

SQL의 SELECT DISTINCT 규칙과 같습니다. 정렬 키를 투영하거나, DISTINCT를 빼고 그룹화 집계로 중복을 없애십시오.