함수

비교 함수

num_nonnulls(VARIADIC “any”)
인자 중 null이 아닌 인자의 개수를 반환합니다.
```
SELECT num_nonnulls(1, NULL, 2);
```
결과:
```
num_nonnulls
------------
           2
(1 row)
```

num_nulls(VARIADIC “any”)
인자 중 null인 인자의 개수를 반환합니다.

SELECT num_nulls(1, NULL, 2);

결과:

num_nonnulls
------------
           1
(1 row)

수학 함수

숫자와 관련된 다양한 함수를 제공하며, dp로 지정된 인자는 double precision을 나타냅니다.

abs(x)
인자의 절대값을 반환합니다.
```
SELECT abs(-17.4);
```
결과:
```
 abs
-----
17.4
(1 row)
```

cbrt(dp)
인자의 세제곱근을 반환합니다.

SELECT cbrt(27.0);

결과:

 cbrt
------
    3
(1 row)

ceil(dp or numeric) or ceiling(dp or numeric)
인자보다 크거나 같은 가장 가까운 정수를 반환합니다.
```
SELECT ceil(-42.8);
```
결과:
```
 ceil
------
  -42
(1 row)
```

degrees(dp)
라디안을 도(degree)로 변환합니다.

SELECT degrees(0.5);

결과:

     degrees      
------------------
 28.6478897565412
(1 row)

div(y numeric, x numeric)
y/x의 정수 몫을 반환합니다.
```
SELECT div(9,4);
```
결과:
```
 div
-----
   2
(1 row)
```

exp(dp or numeric)
지수값을 반환합니다.

SELECT exp(1.0);

결과:

        exp         
--------------------
 2.7182818284590452
(1 row)

floor(dp or numeric)
인자보다 작거나 같은 가장 가까운 정수를 반환합니다.
```
SELECT floor(-42.8);
```
결과:
```
 floor
-------
   -43
(1 row)
```

ln(dp or numeric)
인자의 자연로그를 반환합니다.

SELECT ln(2.0);

결과:

        ln
-------------------
 0.693147180559945
(1 row)

log(dp or numeric)
밑이 10인 로그를 반환합니다.

SELECT log(100.0);

결과:

        log
--------------------
 2.0000000000000000
(1 row)

log(b numeric, x numeric)
밑이 b인 로그를 반환합니다.

SELECT log(2.0, 64.0);

결과:

        log
--------------------
 6.0000000000000000
(1 row)

mod(y, x)
y/x의 나머지를 반환합니다.

SELECT mod(9,4);

결과:

 mod
-----
   1
(1 row)

pi()
원주율 “π” 상수를 반환합니다.

SELECT pi();

결과:

        pi
------------------
 3.14159265358979
(1 row)

power(a dp, b dp) or power(a numeric, b numeric)
a의 b 거듭제곱을 반환합니다.

SELECT power(9.0, 3.0);

결과:

        power
--------------------
 729.00000000000000
(1 row)

radians(dp)
도(degree)를 라디안으로 변환합니다.

SELECT radians(45.0);

결과:

      radians      
-------------------
 0.785398163397448
(1 row)

round(dp or numeric)
가장 가까운 정수로 반올림합니다.
```
SELECT round(42.4);
```
결과:
```
 round
-------
    42
(1 row)
```
round(v numeric, s int)
v 인자를 소수점 이하 s자리로 반올림합니다.
```
SELECT round(42.4382, 2);
```
결과:
```
 round
-------
 42.44
(1 row)
```
scale(numeric)
인자의 소수 자릿수(scale)를 반환합니다.
```
SELECT scale(8.41);
```
결과:
```
 scale
-------
     2
(1 row)
```
sign(dp or numeric)
인자의 부호(-1, 0, 1)를 반환합니다.
```
SELECT sign(-8.4);
```
결과:
```
 sign
------
   -1
(1 row)
```

sqrt(dp or numeric)
인자의 제곱근을 반환합니다.

SELECT sqrt(2.0);

결과:

        sqrt
-------------------
 1.414213562373095
(1 row)

trunc(dp or numeric)
0 방향으로 버립니다.

SELECT trunc(42.8);

결과:

 trunc
-------
    42
(1 row)

trunc(v numeric, s int)
소수점 이하 s자리로 버립니다.
```
SELECT trunc(42.4382, 2);
```
결과:
```
 trunc
-------
 42.43
(1 row)
```
width_bucket(operand dp, b1 dp, b2 dp, count int) or width_bucket(operand numeric, b1 numeric, b2 numeric, count int)
b1부터 b2까지의 범위를 count개의 동일한 너비 버킷으로 나눈 히스토그램에서 operand가 할당될 버킷 번호를 반환하며, 범위를 벗어난 입력에 대해서는 0 또는 count+1을 반환합니다.
```
SELECT width_bucket(5.35, 0.024, 10.06, 5);
```
결과:
```
 width_bucket
--------------
            3
(1 row)
```
width_bucket(operand anyelement, thresholds anyarray)
버킷의 하한값을 나열한 배열이 주어졌을 때 operand가 할당될 버킷 번호를 반환하며, 첫 번째 하한값보다 작은 입력에 대해서는 0을 반환합니다. thresholds 배열은 가장 작은 값부터 오름차순으로 정렬되어 있어야 합니다.
```
SELECT width_bucket(now(), array['yesterday', 'today', 'tomorrow']::timestamptz[]);
```
결과:
```
 width_bucket
--------------
            2
(1 row)
```

문자열 함수

ascii(string)
인자의 첫 번째 문자의 ASCII 코드를 반환합니다. UTF8의 경우 해당 문자의 유니코드 코드 포인트를 반환합니다. 그 외의 멀티바이트 인코딩의 경우 인자는 ASCII 문자여야 합니다.
```
SELECT ascii('x');
```
결과:
```
 ascii
-------
   120
(1 row)
```
btrim(string text [, characters text])
string의 시작과 끝에서 characters(기본값은 공백)에 포함된 문자로만 이루어진 가장 긴 문자열을 제거합니다.
```
SELECT btrim('xyxtrimyyx', 'xyz');
```
결과:
```
 btrim
-------
  trim
(1 row)
```
chr(int)
주어진 코드에 해당하는 문자입니다. UTF8의 경우 인자는 유니코드 코드 포인트로 처리됩니다. 그 외의 멀티바이트 인코딩의 경우 인자는 ASCII 문자를 지정해야 합니다. text 데이터 타입은 NULL(0) 바이트를 저장할 수 없으므로 NULL(0) 문자는 허용되지 않습니다.
```
SELECT chr(65);
```
결과:
```
 chr
-----
   A
(1 row)
```
concat(str “any” [, str “any” [, …] ])
모든 인자의 텍스트 표현을 연결합니다. NULL 인자는 무시됩니다.
```
SELECT concat('abcde', 2, NULL, 22);
```
결과:
```
  concat
----------
 abcde222
(1 row)
```
concat_ws(sep text, str “any” [, str “any” [, …] ])
첫 번째 인자를 제외한 모든 인자를 구분자로 연결합니다. 첫 번째 인자가 구분자 문자열로 사용됩니다. NULL 인자는 무시됩니다.
```
SELECT concat_ws(',', 'abcde', 2, NULL, 22);
```
결과:
```
  concat_ws
------------
 abcde,2,22
(1 row)
```
convert(string bytea, src_encoding name, dest_encoding name)
문자열을 dest_encoding으로 변환합니다. 원본 인코딩은 src_encoding으로 지정합니다. string은 이 인코딩에서 유효해야 합니다. 변환은 CREATE CONVERSION으로 정의할 수 있습니다. 또한 미리 정의된 변환도 일부 제공됩니다. 사용 가능한 변환은 이 링크를 참조하십시오.
```
SELECT convert('text_in_utf8', 'UTF8', 'LATIN1');
```
결과:
```
          convert
----------------------------
  x746578745f696e5f75746638
(1 row)
```
convert_from(string bytea, src_encoding name)
문자열을 데이터베이스 인코딩으로 변환합니다. 원본 인코딩은 src_encoding으로 지정합니다. string은 이 인코딩에서 유효해야 합니다.
```
SELECT convert_from('text_in_utf8', 'UTF8');
```
결과:
```
 convert_from
--------------
 text_in_utf8 (A string represented by the current database encoding)
(1 row)
```

convert_to(string text, dest_encoding name)
문자열을 dest_encoding으로 변환합니다.

SELECT convert_to('some text', 'UTF8');

결과:

      convert_to
----------------------
  x736f6d652074657874
(1 row)

decode(string text, format text)
string의 텍스트 표현으로부터 바이너리 데이터를 디코딩합니다. format에 대한 옵션은 encode와 동일합니다.
```
SELECT decode('MTIzAAE=', 'base64');
```
결과:
```
    decode
--------------
  x3132330001
(1 row)
```
encode(data bytea, format text)
바이너리 데이터를 텍스트 표현으로 인코딩합니다. 지원되는 형식은 base64, hex, escape입니다. escape는 0 바이트와 상위 비트가 설정된 바이트를 8진수 시퀀스(\nnn)로 변환하고 백슬래시를 두 배로 만듭니다.
```
SELECT encode(E'123\\000\\001', 'base64');
```
결과:
```
  encode
----------
 MTIzAAE=
(1 row)
```
format(formatstr text [, formatarg “any” [, …] ])
형식 문자열에 따라 인자를 포맷합니다. 이 함수는 C 함수 sprintf와 유사합니다.
```
SELECT format('Hello %s, %1$s', 'World');
```
결과:
```
       format
--------------------
 Hello World, World
(1 row)
```
initcap(string)
각 단어의 첫 글자를 대문자로, 나머지를 소문자로 변환합니다. 단어는 영숫자가 아닌 문자로 구분된 영숫자 문자의 연속입니다.
```
SELECT initcap('hi THOMAS');
```
결과:
```
  initcap
-----------
 Hi Thomas
(1 row)
```

length(string)
string의 문자 개수를 반환합니다.

SELECT length('jose');

결과:

 length
--------
      4
(1 row)

length(string bytea, encoding name)
주어진 encoding에서 string의 문자 개수를 반환합니다. string은 이 인코딩에서 유효해야 합니다.
```
SELECT length('jose', 'UTF8');
```
결과:
```
 length
--------
      4
(1 row)
```
lpad(string text, length int [, fill text])
fill 문자(기본값은 공백)를 앞에 채워 string을 길이 length까지 채웁니다. string이 이미 length보다 길면 (오른쪽에서) 잘립니다.
```
SELECT lpad('hi', 5, 'xy');
```
결과:
```
 lpad
-------
 xyxhi
(1 row)
```
ltrim(string text [, characters text])
string의 시작에서 characters에 포함된 문자(기본값은 공백)로만 이루어진 가장 긴 문자열을 제거합니다.
```
SELECT ltrim('zzzytest', 'xyz');
```
결과:
```
 ltrim
-------
  test
(1 row)
```

md5(string)
string의 MD5 해시를 계산하여 16진수 형태로 결과를 반환합니다.

SELECT md5('abc');

결과:

                md5
----------------------------------
 900150983cd24fb0d6963f7d28e17f72
(1 row)

parse_ident(qualified_identifier text [, strictmode boolean DEFAULT true])
qualified_identifier를 식별자 배열로 분리하고, 각 식별자의 따옴표를 제거합니다. 기본적으로 마지막 식별자 뒤에 추가 문자가 있으면 오류로 간주하지만, 두 번째 매개변수가 false이면 그러한 추가 문자는 무시됩니다. (이 동작은 함수와 같은 객체의 이름을 파싱하는 데 유용합니다.) 이 함수는 길이가 초과된 식별자를 자르지 않습니다. 자르기를 원한다면 결과를 name[]로 캐스팅하면 됩니다.
```
SELECT parse_ident('"SomeSchema".someTable');
```
결과:
```
       parse_ident
------------------------
 {SomeSchema,sometable}
(1 row)
```

pg_client_encoding()
현재 클라이언트 인코딩 이름을 반환합니다.

SELECT pg_client_encoding();

결과:

 pg_client_encoding
--------------------
     SQL_ASCII
(1 row)

quote_ident(string text)
주어진 문자열을 SQL 구문 문자열에서 식별자로 사용하기에 적합하도록 따옴표로 묶어 반환합니다. 따옴표는 필요한 경우(즉, 문자열에 식별자가 아닌 문자가 포함되어 있거나 대소문자가 변환될 수 있는 경우)에만 추가됩니다. 내부에 포함된 따옴표는 적절히 두 배로 처리됩니다.
```
SELECT quote_ident('Foo bar');
```
결과:
```
 quote_ident
-------------
   "Foo bar"
(1 row)
```
quote_literal(string text)
주어진 문자열을 SQL 구문 문자열에서 문자열 리터럴로 사용하기에 적합하도록 따옴표로 묶어 반환합니다. 내부에 포함된 작은따옴표와 백슬래시는 적절히 두 배로 처리됩니다. quote_literal은 null 입력에 대해 null을 반환하므로, 인자가 null일 수 있는 경우에는 quote_nullable이 더 적합한 경우가 많습니다.
```
SELECT quote_literal(E'O\'Reilly');
```
결과:
```
 quote_literal
---------------
   'O''Reilly'
(1 row)
```
quote_literal(value anyelement)
주어진 값을 text로 강제 변환한 다음 리터럴로 따옴표 처리합니다. 내부에 포함된 작은따옴표와 백슬래시는 적절히 두 배로 처리됩니다.
```
SELECT quote_literal(42.5);
```
결과:
```
 quote_literal
---------------
        '42.5'
(1 row)
```
quote_nullable(string text)
주어진 문자열을 구문 문자열에서 문자열 리터럴로 사용하기에 적합하도록 따옴표로 묶어 반환하거나, 인자가 null이면 NULL을 반환합니다. 내부에 포함된 작은따옴표와 백슬래시는 적절히 두 배로 처리됩니다.
```
SELECT quote_nullable(NULL);
```
결과:
```
 quote_nullable
---------------
          NULL
(1 row)
```
quote_nullable(value anyelement)
주어진 값을 text로 강제 변환한 다음 리터럴로 따옴표 처리하거나, 인자가 null이면 NULL을 반환합니다. 내부에 포함된 작은따옴표와 백슬래시는 적절히 두 배로 처리됩니다.
```
SELECT quote_nullable(42.5);
```
결과:
```
 quote_nullable
----------------
         '42.5'
(1 row)
```
regexp_matches(string text, pattern text [, flags text])
string에 대해 POSIX 정규 표현식의 첫 번째 일치에서 캡처된 부분 문자열을 반환합니다.
```
SELECT regexp_matches('foobarbequebaz', '(bar)(beque)');
```
결과:
```
 regexp_matches
----------------
    {bar,beque}
(1 row)
```
regexp_replace(string text, pattern text, replacement text [, flags text])
POSIX 정규 표현식과 일치하는 부분 문자열을 치환합니다.
```
SELECT regexp_replace('Thomas', '.[mN]a.', 'M');
```
결과:
```
 regexp_replace
----------------
            ThM
(1 row)
```

regexp_split_to_array(string text, pattern text [, flags text])
POSIX 정규 표현식을 구분자로 사용하여 string을 분리합니다.

SELECT regexp_split_to_array('hello world', E'\\s+');

결과:

 regexp_split_to_array
-----------------------
         {hello,world}
(1 row)

regexp_split_to_table(string text, pattern text [, flags text])
POSIX 정규 표현식을 구분자로 사용하여 string을 분리합니다.

SELECT regexp_split_to_table('hello world', E'\\s+');

결과:

 regexp_split_to_array
-----------------------
                 hello
                 world
(2 rows)

repeat(string text, number int)
string을 지정한 number만큼 반복합니다.
```
SELECT repeat('Pg', 4);
```
결과:
```
  repeat
----------
 PgPgPgPg
(1 row)
```
replace(string text, from text, to text)
string에서 부분 문자열 from이 나타나는 모든 부분을 부분 문자열 to로 치환합니다.
```
SELECT replace('abcdefabcdef', 'cd', 'XX');
```
결과:
```
    replace
--------------
 abXXefabXXef
(1 row)
```

reverse(str)
역순으로 뒤집은 문자열을 반환합니다.

SELECT reverse('abcde');

결과:

 reverse
---------
   edcba
(1 row)

right(str text, n int)
문자열의 마지막 n개 문자를 반환합니다. n이 음수이면 처음 |n|개 문자를 제외한 나머지를 반환합니다.
```
SELECT right('abcde', 2);
```
결과:
```
 right
-------
    de
(1 row)
```
rpad(string text, length int [, fill text])
fill 문자(기본값은 공백)를 뒤에 채워 string을 길이 length까지 채웁니다. string이 이미 length보다 길면 잘립니다.
```
SELECT rpad('hi', 5, 'xy');
```
결과:
```
 rpad
-------
 hixyx
(1 row)
```
rtrim(string text [, characters text])
string의 끝에서 characters에 포함된 문자(기본값은 공백)로만 이루어진 가장 긴 문자열을 제거합니다.
```
SELECT rtrim('testxxzx', 'xyz');
```
결과:
```
 rtrim
-------
  test
(1 row)
```
split_part(string text, delimiter text, field int)
string을 delimiter로 분리하여 (1부터 세는) 주어진 필드를 반환합니다.
```
SELECT split_part('abc~@~def~@~ghi', '~@~', 2);
```
결과:
```
 split_part
------------
        def
(1 row)
```
strpos(string, substring)
지정한 substring의 위치입니다(position (substring in string)와 동일하지만 인자 순서가 반대인 점에 유의하십시오).
```
SELECT strpos('high', 'ig');
```
결과:
```
 strpos
--------
      2
(1 row)
```
substr(string, from [, count])
부분 문자열을 추출합니다(substring(string from from for count)와 동일).
```
SELECT substr('alphabet', 3, 2);
```
결과:
```
 substr
--------
     ph
(1 row)
```
to_ascii(string text [, encoding text])
string을 다른 인코딩에서 ASCII로 변환합니다(LATIN1, LATIN2, LATIN9, WIN1250 인코딩으로부터의 변환만 지원).
```
SELECT to_ascii('Karel');
```
결과:
```
 to_ascii
----------
    Karel
(1 row)
```
to_hex(number int or bigint)
number를 그에 해당하는 16진수 표현으로 변환합니다.
```
SELECT to_hex(2147483647);
```
결과:
```
  to_hex
----------
 7fffffff
(1 row)
```
translate(string text, from text, to text)
string에서 from 집합의 문자와 일치하는 모든 문자가 to 집합의 해당 문자로 치환됩니다. from이 to보다 길면 from의 초과 문자에 해당하는 문자는 제거됩니다.
```
SELECT translate('12345', '143', 'ax');
```
결과:
```
 translate
-----------
      a2x5
(1 row)
```

바이너리 문자열 함수

인자를 쉼표가 아니라 키워드로 구분하는 몇 가지 문자열 함수를 정의합니다.

octet_length(string)
바이너리 문자열의 바이트 수를 반환합니다.

SELECT octet_length(E'jo\\000se'::bytea);

결과:

 octet_length
--------------
            5
(1 row)

overlay(string placing string from int [for int])
부분 문자열을 치환합니다.

SELECT overlay(E'Th\\000omas'::bytea placing E'\\002\\003'::bytea FROM 2 for 3);

결과:

     overlay
----------------
  x5402036d6173
(1 row)

position(substring in string)
지정한 부분 문자열의 위치를 반환합니다.

SELECT position(E'\\000om'::bytea in E'Th\\000omas'::bytea);

결과:

 position
----------
        3
(1 row)

substring(string [from int] [for int])
부분 문자열을 추출합니다.

SELECT substring(E'Th\\000omas'::bytea FROM 2 for 3);

결과:

 substring
-----------
  x68006f
(1 row)

trim([both] bytes from string)
문자열의 시작과 끝에서 bytes에 나타나는 바이트로만 이루어진 가장 긴 문자열을 제거합니다.
```
SELECT trim(E'\\000\\001'::bytea FROM E'\\000Tom\\001'::bytea);
```
결과:
```
   trim
----------
  x546f6d
(1 row)
```
btrim(string bytea, bytes bytea)
string의 시작과 끝에서 bytes에 나타나는 바이트로만 이루어진 가장 긴 문자열을 제거합니다.
```
SELECT btrim(E'\\000trim\\001'::bytea, E'\\000\\001'::bytea);
```
결과:
```
    btrim
------------
 x7472696d
(1 row)
```
decode(string text, format text)
string의 텍스트 표현으로부터 바이너리 데이터를 디코딩합니다. format에 대한 옵션은 encode와 동일합니다.
```
SELECT decode(E'123\\000456', 'escape');
```
결과:
```
      decode
------------------
 x31323300343536
(1 row)
```
encode(data bytea, format text)
바이너리 데이터를 텍스트 표현으로 인코딩합니다. 지원되는 형식은 base64, hex, escape입니다. escape는 0 바이트와 상위 비트가 설정된 바이트를 8진수 시퀀스(\nnn)로 변환하고 백슬래시를 두 배로 만듭니다.
```
SELECT encode(E'123\\000456'::bytea, 'escape');
```
결과:
```
   encode
------------
 123\000456
(1 row)
```

get_bit(string, offset)
문자열에서 비트를 추출합니다.

SELECT get_bit(E'Th\\000omas'::bytea, 45);

결과:

 get_bit
---------
       1
(1 row)

get_byte(string, offset)
문자열에서 바이트를 추출합니다.

SELECT get_byte(E'Th\\000omas'::bytea, 4);

결과:

 get_byte
----------
      109
(1 row)

length(string)
바이너리 문자열의 길이를 반환합니다.

SELECT length(E'jo\\000se'::bytea);

결과:

 length
--------
      5
(1 row)

md5(string)
string의 MD5 해시를 계산하여 16진수 형태로 결과를 반환합니다.

SELECT md5(E'Th\\000omas'::bytea);

결과:

                md5
----------------------------------
 8ab2d3c9689aaf18b4958c334c82d8b1
(1 row)

set_bit(string, offset, newvalue)
문자열에서 설정된 비트를 반환합니다.

SELECT set_bit(E'Th\\000omas'::bytea, 45, 0);

결과:

      set_bit
------------------
  x5468006f6d4173
(1 row)

set_byte(string, offset, newvalue)
문자열에서 설정된 바이트를 반환합니다.

SELECT set_byte(E'Th\\000omas'::bytea, 4, 64);

결과:

     set_byte
------------------
  x5468006f406173
(1 row)

날짜 타입 포맷팅 함수

포맷팅 함수는 다양한 데이터 타입(날짜/시간, 정수, 부동소수점, numeric)을 포맷된 문자열로 변환하거나 포맷된 문자열을 특정 데이터 타입으로 변환하는 강력한 도구 집합을 제공합니다. 이 함수들은 모두 공통된 호출 규칙을 따릅니다. 첫 번째 인자는 포맷할 값이고 두 번째 인자는 출력 또는 입력 형식을 정의하는 템플릿입니다.

to_char(timestamp, text)
timestamp를 문자열로 변환합니다.

SELECT to_char(current_timestamp, 'HH12:MI:SS');

결과:

 to_char
----------
 04:56:02
(1 row)

to_char(interval, text)
interval을 문자열로 변환합니다.

SELECT to_char(interval '15h 2m 12s', 'HH24:MI:SS');

결과:

 to_char
----------
 15:02:12
(1 row)

to_char(int, text)
정수를 문자열로 변환합니다.

SELECT to_char(125, '999');

결과:

 to_char
----------
      125
(1 row)

to_char(double precision, text)
real/double precision을 문자열로 변환합니다.
```
SELECT to_char(125.8::real, '999D9');
```
결과:
```
 to_char
----------
    125.8
(1 row)
```

to_char(numeric, text)
numeric을 문자열로 변환합니다.

SELECT to_char(-125.8, '999D99S');

결과:

 to_char
----------
  125.80-
(1 row)

to_date(text, text)
문자열을 date로 변환합니다.

SELECT to_date('05 Dec 2000', 'DD Mon YYYY');

결과:

   to_date
------------
 2000-12-05
(1 row)

to_number(text, text)
문자열을 numeric으로 변환합니다.

SELECT to_number('12,454.8-', '99G999D9S');

결과:

 to_number
-----------
  -12454.8
(1 row)

to_timestamp(text, text)
문자열을 timestamp로 변환합니다.

SELECT to_timestamp('05 Dec 2000', 'DD Mon YYYY');

결과:

      to_timestamp
------------------------
 2000-12-05 00:00:00+09
(1 row)

날짜/시간 함수

아래에서 설명하는 모든 함수와 연산자 중 time 또는 timestamp 입력을 받는 것들은 실제로 두 가지 변형으로 제공됩니다. 하나는 time with time zone 또는 timestamp with time zone을 받고, 다른 하나는 time without time zone 또는 timestamp without time zone을 받습니다. 간결함을 위해 이러한 변형은 따로 표시하지 않습니다. 또한 + 및 * 연산자는 교환 법칙이 성립하는 쌍으로 제공되는데(예: date + integer와 integer + date 모두), 각 쌍 중 하나만 표시합니다.

age(timestamp, timestamp)
인자를 빼서 일 단위뿐만 아니라 연과 월을 사용하는 결과를 생성합니다.

SELECT age(timestamp '2001-04-10', timestamp '1957-06-13');

결과:

          age
-------------------------
 43 years 9 mons 27 days
(1 row)

age(timestamp)
current_date(자정 기준)에서 뺍니다.

SELECT age(timestamp '1957-06-13');

결과:

          age
-------------------------
 60 years 3 mons 15 days
(1 row)

clock_timestamp()
현재 날짜와 시간을 반환합니다(구문 실행 중에 변경됨).

SELECT clock_timestamp();

결과:

        clock_timestamp
-------------------------------
 2017-09-28 17:47:31.208076+09
(1 row)

current_date
현재 날짜를 반환합니다.

SELECT current_date;

결과:

    date
------------
 2017-09-28
(1 row)

current_time
현재 시각을 반환합니다.

SELECT current_time;

결과:

       timetz
--------------------
 17:53:23.972231+09
(1 row)

current_timestamp
현재 날짜와 시간을 반환합니다.

SELECT current_timestamp;

결과:

              now
-------------------------------
 2017-09-28 18:01:43.890977+09
(1 row)

date_part(text, timestamp)
text에 지정한 하위 필드를 반환합니다.

SELECT date_part('hour', timestamp '2001-02-16 20:38:40');

결과:

 date_part
-----------
        20
(1 row)

date_part(text, interval)
text에 지정한 하위 필드를 반환합니다.

SELECT date_part('month', interval '2 years 3 months');

결과:

 date_part
-----------
         3
(1 row)

date_trunc(text, timestamp)
지정한 정밀도로 버립니다.

SELECT date_trunc('hour', timestamp '2001-02-16 20:38:40');

결과:

      date_trunc
---------------------
 2001-02-16 20:00:00
(1 row)

date_trunc(text, interval)
지정한 정밀도로 버립니다.

SELECT date_trunc('hour', interval '2 days 3 hours 40 minutes');

결과:

    date_trunc
-----------------
 2 days 03:00:00
(1 row)

extract(field from timestamp)
지정한 필드를 추출합니다.

SELECT extract(hour FROM timestamp '2001-02-16 20:38:40');

결과:

 date_part
-----------
        20
(1 row)

extract(field from interval)
지정한 필드를 추출합니다.

SELECT extract(month FROM interval '2 years 3 months');

결과:

 date_part
-----------
         3
(1 row)

isfinite(date)
입력 인자가 유한한지(+/- 무한대가 아닌지) 검사한 결과를 반환합니다.
```
SELECT isfinite(date '2001-02-16');
```
결과:
```
 isfinite
----------
        t
(1 row)
```
isfinite(timestamp)
입력 인자가 유한한지(+/- 무한대가 아닌지) 검사한 결과를 반환합니다.
```
SELECT isfinite(timestamp '2001-02-16 21:28:30');
```
결과:
```
 isfinite
----------
        t
(1 row)
```

isfinite(interval)
입력 인자가 유한한지 검사한 결과를 반환합니다.

SELECT isfinite(interval '4 hours');

결과:

 isfinite
----------
        t
(1 row)

justify_days(interval)
30일 단위의 기간이 월로 표현되도록 interval을 조정합니다.
```
SELECT justify_days(interval '35 days');
```
결과:
```
 justify_days
--------------
 1 mon 5 days
(1 row)
```

justify_hours(interval)
24시간 단위의 기간이 일로 표현되도록 interval을 조정합니다.

SELECT justify_hours(interval '27 hours');

결과:

 justify_hours
----------------
 1 day 03:00:00
(1 row)

justify_interval(interval)
justify_days와 justify_hours를 사용하여 interval을 조정하고, 추가로 부호를 조정합니다.
```
SELECT justify_interval(interval '1 mon -1 hour');
```
결과:
```
 justify_interval
------------------
 29 days 23:00:00
(1 row)
```

localtime
현재 시각을 반환합니다.

SELECT localtime;

결과:

      time
----------------
 11:27:04.72722
(1 row)

localtimestamp
현재 날짜와 시간을 반환합니다(현재 트랜잭션의 시작 시점).

SELECT localtimestamp;

결과:

          timestamp
----------------------------
 2017-09-29 11:29:52.230028
(1 row)

make_date(year int, month int, day int)
연, 월, 일 필드로부터 date를 생성합니다.
```
SELECT make_date(2013, 7, 15);
```
결과:
```
 make_date
------------
 2013-07-15
(1 row)
```
make_interval(years int DEFAULT 0, months int DEFAULT 0, weeks int DEFAULT 0, days int DEFAULT 0, hours int DEFAULT 0, mins int DEFAULT 0, secs double precision DEFAULT 0.0)
연, 월, 주, 일, 시, 분, 초 필드로부터 interval을 생성합니다.
```
SELECT make_interval(days => 10);
```
결과:
```
 make_interval
---------------
       10 days
(1 row)
```
make_time(hour int, min int, sec double precision)
시, 분, 초 필드로부터 time을 생성합니다.
```
SELECT make_time(8, 15, 23.5);
```
결과:
```
 make_time
------------
 08:15:23.5
(1 row)
```
make_timestamp(year int, month int, day int, hour int, min int, sec double precision)
연, 월, 일, 시, 분, 초 필드로부터 timestamp를 생성합니다.
```
SELECT make_timestamp(2013, 7, 15, 8, 15, 23.5);
```
결과:
```
    make_timestamp
-----------------------
 2013-07-15 08:15:23.5
(1 row)
```
make_timestamptz(year int, month int, day int, hour int, min int, sec double precision, [ timezone text ])
연, 월, 일, 시, 분, 초 필드로부터 timestamp with time zone을 생성합니다. timezone을 지정하지 않으면 현재 time zone이 사용됩니다.
```
SELECT make_timestamptz(2013, 7, 15, 8, 15, 23.5);
```
결과:
```
      make_timestampz
--------------------------
 2013-07-15 08:15:23.5+01
(1 row)
```

now()
현재 날짜와 시간을 반환합니다(현재 트랜잭션의 시작 시점).

SELECT now();

결과:

              now              
-------------------------------
 2017-10-11 16:09:51.154262+09
(1 row)

statement_timestamp()
현재 날짜와 시간을 반환합니다.

SELECT statement_timestamp();

결과:

      statement_timestamp      
-------------------------------
 2017-10-11 16:08:59.641426+09
(1 row)

timeofday()
현재 날짜와 시간을 반환합니다.

SELECT timeofday();

결과:

              timeofday              
-------------------------------------
 Wed Oct 11 16:09:26.934061 2017 KST
(1 row)

transaction_timestamp()
현재 날짜와 시간을 반환합니다.

SELECT transaction_timestamp();

결과:

     transaction_timestamp     
-------------------------------
 2017-10-11 16:10:21.530521+09
(1 row)

to_timestamp(double precision)
Unix epoch(1970-01-01 00:00:00+00 이후 경과한 초)를 timestamp로 변환합니다.

SELECT to_timestamp(1284352323);

결과:

      to_timestamp      
------------------------
 2010-09-13 13:32:03+09
(1 row)

Enum 지원 함수

enum 타입의 경우, enum 타입의 특정 값을 하드코딩하지 않고 더 깔끔하게 프로그래밍할 수 있도록 해주는 몇 가지 함수가 있습니다.

함수 설명의 예제를 실행하려면 먼저 아래와 같이 enum 타입을 생성하십시오.

CREATE TYPE rainbow AS ENUM ('red', 'orange', 'yellow', 'green', 'blue', 'purple');

enum_first(anyenum)
입력 enum 타입의 첫 번째 값을 반환합니다.

SELECT enum_first(null::rainbow);

결과:

 enum_first 
------------
     red
(1 row)

enum_last(anyenum)
입력 enum 타입의 마지막 값을 반환합니다.

SELECT enum_last(null::rainbow);

결과:

 enum_last
-----------
  purple
(1 row)

enum_range(anyenum)
입력 enum 타입의 모든 값을 정렬된 배열로 반환합니다.

SELECT enum_range(null::rainbow);

결과:

              enum_range               
---------------------------------------
 {red,orange,yellow,green,blue,purple}
(1 row)

enum_range(anyenum, anyenum)
주어진 두 enum 값 사이의 범위를 정렬된 배열로 반환합니다. 값들은 동일한 enum 타입이어야 합니다. 첫 번째 매개변수가 null이면 결과는 enum 타입의 첫 번째 값부터 시작합니다. 두 번째 매개변수가 null이면 결과는 enum 타입의 마지막 값으로 끝납니다.

SELECT enum_range('orange'::rainbow, 'green'::rainbow);

결과:

      enum_range
-----------------------
 {orange,yellow,green}
(1 row)

SELECT enum_range(NULL, 'green'::rainbow);

결과:

        enum_range
---------------------------
 {red,orange,yellow,green}
(1 row)

SELECT enum_range('orange'::rainbow, NULL);

결과:

            enum_range
-----------------------------------
 {orange,yellow,green,blue,purple}
(1 row)

기하 함수

area(object)
면적을 반환합니다.

SELECT area(box '((0,0),(1,1))');

결과:

 area
------
    1
(1 row)

center(object)
객체의 중심 좌표를 반환합니다.

SELECT center(box '((0,0),(1,2))');

결과:

 center
--------
 (0.5,1)
(1 row)

diameter(circle)
원의 지름을 반환합니다.

SELECT diameter(circle '((0,0),2.0)');

결과:

 diameter
----------
        4
(1 row)

height(box)
box의 세로 크기를 반환합니다.

SELECT height(box '((0,0),(1,1))');

결과:

 height
--------
      1
(1 row)

isclosed(path)
입력 path가 닫힌 경로인지를 나타내는 논리값을 반환합니다.

SELECT isclosed(path '((0,0),(1,1),(2,0))');

결과:

 isclosed
----------
        t
(1 row)

isopen(path)
입력 path가 열린 경로인지를 나타내는 논리값을 반환합니다.
```
SELECT isopen(path '[(0,0),(1,1),(2,0)]');
```
결과:
```
 isopen
--------
      t
(1 row)
```

length(object)
path의 길이를 반환합니다.

SELECT length(path '((-1,0),(1,0))');

결과:

 length
--------
      4
(1 row)

npoints(path)
입력 path의 점 개수를 반환합니다.

SELECT npoints(path '[(0,0),(1,1),(2,0)]');

결과:

 npoints
---------
       3
(1 row)

npoints(polygon)
polygon의 점 개수를 반환합니다.

SELECT npoints(polygon '((1,1),(0,0))');

결과:

 npoints
---------
       2
(1 row)

pclose(path)
입력 path를 닫힌 경로로 변환합니다.

SELECT pclose(path '[(0,0),(1,1),(2,0)]');

결과:

       pclose        
---------------------
 ((0,0),(1,1),(2,0))
(1 row)

popen(path)
입력 path를 열린 경로로 변환합니다.

SELECT popen(path '((0,0),(1,1),(2,0))');

결과:

        popen        
---------------------
 [(0,0),(1,1),(2,0)]
(1 row)

radius(circle)
원의 반지름을 반환합니다.

SELECT radius(circle '((0,0),2.0)');

결과:

 radius 
--------
      2
(1 row)

width(box)
원의 반지름을 반환합니다.

SELECT width(box '((0,0),(1,1))');

결과:

 width 
-------
     1
(1 row)

box(circle)
원에 외접하는 box를 반환합니다.

SELECT box(circle '((0,0),2.0)');

결과:

                                    box                                    
---------------------------------------------------------------------------
 (1.41421356237309,1.41421356237309),(-1.41421356237309,-1.41421356237309)
(1 row)

box(point)
입력 점을 중심으로 하는 너비가 0인 box(빈 box)를 반환합니다.
```
SELECT box(point '(0,0)');
```
결과:
```
     box     
-------------
 (0,0),(0,0)
(1 row)
```

box(point, point)
두 입력 점을 꼭짓점으로 하는 box를 반환합니다.

SELECT box(point '(0,0)', point '(1,1)');

결과:

     box     
-------------
 (1,1),(0,0)
(1 row)

box(polygon)
polygon에 외접하는 box를 반환합니다.

SELECT box(polygon '((0,0),(1,1),(2,0))');

결과:

     box     
-------------
 (2,1),(0,0)
(1 row)

bound_box(box, box)
입력한 두 box를 포함하는 가장 작은 box를 반환합니다.

SELECT bound_box(box '((0,0),(1,1))', box '((3,3),(4,4))');

결과:

  bound_box  
-------------
 (4,4),(0,0)
(1 row)

circle(box)
box에 외접하는 원을 반환합니다.

SELECT circle(box '((0,0),(1,1))');

결과:

            circle             
-------------------------------
 <(0.5,0.5),0.707106781186548>
(1 row)

circle(point, double precision)
입력 원의 중심 좌표와 반지름을 사용하여 생성한 원을 반환합니다.
```
SELECT circle(point '(0,0)', 2.0);
```
결과:
```
  circle   
-----------
 <(0,0),2>
(1 row)
```

circle(polygon)
입력 좌표쌍들의 평균을 원의 중심으로 하고, 점에서 입력 좌표쌍까지의 평균 거리를 반지름으로 하는 원을 반환합니다.

SELECT circle(polygon '((0,0),(1,1),(2,0))');

결과:

                  circle                   
-------------------------------------------
 <(1,0.333333333333333),0.924950591148529>
(1 row)

line(point, point)
직선의 값을 반환합니다.

SELECT line(point '(-1,0)', point '(1,0)');

결과:

   line   
----------
 {0,-1,0}
(1 row)

lseg(box)
box의 대각선을 선분으로 반환합니다.

SELECT lseg(box '((-1,0),(1,0))');

결과:

      lseg      
----------------
 [(1,0),(-1,0)]
(1 row)

lseg(point, point)
두 입력 점을 시작점과 끝점으로 하는 선분을 반환합니다.

SELECT lseg(point '(-1,0)', point '(1,0)');

결과:

      lseg      
----------------
 [(1,0),(-1,0)]
(1 row)

path(polygon)
polygon의 경로를 반환합니다.

SELECT path(polygon '((0,0),(1,1),(2,0))');

결과:

        path         
---------------------
 ((0,0),(1,1),(2,0))
(1 row)

point(double precision, double precision)
점을 구성하는 값을 반환합니다.

SELECT point(23.4, -44.5);

결과:

    point     
--------------
 (23.4,-44.5)
(1 row)

point(box)
box의 중심을 반환합니다.

SELECT point(box '((-1,0),(1,0))');

결과:

 point 
-------
 (0,0)
(1 row)

point(circle)
원의 중심을 반환합니다.

SELECT point(circle '((0,0),2.0)');

결과:

 point 
-------
 (0,0)
(1 row)

point(lseg)
선분의 중심을 반환합니다.

SELECT point(lseg '((-1,0),(1,0))');

결과:

 point 
-------
 (0,0)
(1 row)

point(polygon)
polygon의 중심을 반환합니다.

SELECT point(polygon '((0,0),(1,1),(2,0))');

결과:

         point         
-----------------------
 (1,0.333333333333333)
(1 row)

polygon(box)
box를 4점 polygon으로 반환합니다.

SELECT polygon(box '((0,0),(1,1))');

결과:

          polygon          
---------------------------
 ((0,0),(0,1),(1,1),(1,0))
(1 row)

polygon(circle)
원을 12점 polygon으로 반환합니다.

SELECT polygon(circle '((0,0),2.0)');

결과:

                                        polygon                                           
-----------------------------------------------------------------------------------------
 ((-2,0),(-1.73205080756888,1),(-1,1.73205080756888),(-1.22464679914735e-16,2),
 (1,1.73205080756888),(1.73205080756888,1),(2,2.44929359829471e-16),
 (1.73205080756888,-0.999999999999999),(1,-1.73205080756888),(3.67394039744206e-16,-2),
 (-0.999999999999999,-1.73205080756888),(-1.73205080756888,-1))
(1 row)

polygon(npts, circle)
원을 npts개 점의 polygon으로 반환합니다.

SELECT polygon(12, circle '((0,0),2.0)');

결과:

                                        polygon                                           
-----------------------------------------------------------------------------------------
 ((-2,0),(-1.73205080756888,1),(-1,1.73205080756888),(-1.22464679914735e-16,2),
 (1,1.73205080756888),(1.73205080756888,1),(2,2.44929359829471e-16),
 (1.73205080756888,-0.999999999999999),(1,-1.73205080756888),(3.67394039744206e-16,-2),
 (-0.999999999999999,-1.73205080756888),(-1.73205080756888,-1))
(1 row)

polygon(path)
path를 polygon으로 변환합니다.

SELECT polygon(path '((0,0),(1,1),(2,0))');

결과:

       polygon       
---------------------
 ((0,0),(1,1),(2,0))
(1 row)

네트워크 주소 함수

abbrev(inet)
축약된 표시 형식을 text로 반환합니다.

SELECT abbrev(inet '10.1.0.0/16');

결과:

abbrev    
-------------
10.1.0.0/16
(1 row)

abbrev(cidr)
축약된 표시 형식을 text로 반환합니다.

SELECT abbrev(cidr '10.1.0.0/16');

결과:

abbrev  
---------
10.1/16
(1 row)

broadcast(inet)
네트워크의 브로드캐스트 주소를 반환합니다.

SELECT broadcast('192.178.1.5/24');

결과:

    broadcast     
------------------
192.178.1.255/24
(1 row)

family(inet)
주소의 패밀리를 추출합니다. IPv4는 4, IPv6는 6입니다.
```
SELECT 	family('::1');
```
결과:
```
 family 
--------
      6
(1 row)
```

host(inet)
IP 주소를 text로 추출합니다.

SELECT 	host('192.178.1.5/24');

결과:

    host     
-------------
 192.178.1.5
(1 row)

hostmask(inet)
네트워크의 호스트 마스크를 구성합니다.

SELECT hostmask('192.178.23.20/30');

결과:

 hostmask 
----------
  0.0.0.3
(1 row)

masklen(inet)
넷마스크 길이를 추출합니다.

SELECT masklen('192.178.1.5/24');

결과:

 masklen 
---------
      24
(1 row)

netmask(inet)
네트워크의 넷마스크를 구성합니다.

SELECT netmask('192.178.1.5/24');

결과:

    netmask    
---------------
 255.255.255.0
(1 row)

network(inet)
주소의 네트워크 부분을 추출합니다.

SELECT network('192.178.1.5/24');

결과:

    network     
----------------
 192.178.1.0/24
(1 row)

set_masklen(inet, int)
inet 값에 설정된 넷마스크 길이를 반환합니다.

SELECT set_masklen('192.178.1.5/24', 16);

결과:

  set_masklen   
----------------
 192.178.1.5/16
(1 row)

set_masklen(cidr, int)
cidr 값에 설정된 넷마스크 길이를 반환합니다.

SELECT set_masklen('192.178.1.0/24'::cidr, 16);

결과:

  set_masklen   
----------------
 192.178.0.0/16
(1 row)

text(inet)
IP 주소와 넷마스크 길이를 text로 반환합니다.

SELECT text(inet '192.178.1.5');

결과:

      text      
----------------
 192.178.1.5/32
(1 row)

inet_same_family(inet, inet)
주소가 동일한 패밀리 값인지를 나타내는 논리값을 반환합니다.

SELECT inet_same_family('192.178.1.5/24', '::1');

결과:

 inet_same_family 
------------------
        f
(1 row)

inet_merge(inet, inet)
입력한 모든 네트워크를 포함하는 가장 작은 네트워크를 반환합니다.

SELECT inet_merge('192.178.1.5/24', '192.178.2.5/24');

결과:

   inet_merge   
----------------
 192.178.0.0/22
(1 row)

trunc(macaddr)
마지막 3바이트를 0으로 설정합니다.

SELECT trunc(macaddr '12:34:56:78:90:ab');

결과:

       trunc       
-------------------
 12:34:56:00:00:00
(1 row)

텍스트 검색 함수

array_to_tsvector(text[])
어휘소(lexeme) 배열을 tsvector로 변환합니다.

SELECT array_to_tsvector('{fat,cat,rat}'::text[]);

결과:

 array_to_tsvector 
-------------------
 'cat' 'fat' 'rat'
(1 row)

get_current_ts_config()
기본 텍스트 검색 설정을 반환합니다.

SELECT get_current_ts_config();

결과:

 get_current_ts_config 
-----------------------
               english
(1 row)

length(tsvector)
tsvector의 어휘소 개수를 반환합니다.

SELECT length('fat:2,4 cat:3 rat:5A'::tsvector);

결과:

 length 
--------
      3
(1 row)

numnode(tsquery)
tsquery의 어휘소 개수와 연산자 개수의 합을 반환합니다.

SELECT numnode('(fat & rat) | cat'::tsquery);

결과:

 numnode 
---------
       5
(1 row)

plainto_tsquery([ config regconfig , ] query text)
문장 부호를 무시하고 tsquery를 생성합니다.

SELECT plainto_tsquery('english', 'The Fat Rats');

결과:

 plainto_tsquery 
-----------------
  'fat' & 'rat'
(1 row)

phraseto_tsquery([ config regconfig , ] query text)
문장 부호를 무시하고 구(phrase)를 검색하는 tsquery를 생성합니다.
```
SELECT phraseto_tsquery('english', 'The Fat Rats');
```
결과:
```
 phraseto_tsquery 
------------------
 'fat' <-> 'rat'
(1 row)
```

querytree(query tsquery)
tsquery에서 인덱싱 가능한 부분을 반환합니다.

SELECT querytree('foo & ! bar'::tsquery);

결과:

 querytree 
-----------
   'foo'
(1 row)

setweight(vector tsvector, weight “char”)
vector의 각 요소에 weight를 할당합니다.

SELECT setweight('fat:2,4 cat:3 rat:5B'::tsvector, 'A');

결과:

          setweight           
-------------------------------
 'cat':3A 'fat':2A,4A 'rat':5A     
(1 row)

setweight(vector tsvector, weight “char”, lexemes text[])
lexemes에 나열된 vector의 요소에 weight를 할당합니다.

SELECT setweight('fat:2,4 cat:3 rat:5B'::tsvector, 'A', '{cat,rat}');

결과:

          setweight          
-----------------------------
 'cat':3A 'fat':2,4 'rat':5A
(1 row)

strip(tsvector)
tsvector에서 위치와 가중치를 제거합니다.

SELECT strip('fat:2,4 cat:3 rat:5A'::tsvector);

결과:

       strip       
-------------------
 'cat' 'fat' 'rat'    
(1 row)

to_tsquery([ config regconfig , ] query text)
단어를 정규화하여 tsquery로 변환합니다.

SELECT to_tsquery('english', 'The & Fat & Rats');

결과:

  to_tsquery   
---------------
 'fat' & 'rat'     
(1 row)

to_tsvector([ config regconfig , ] document text)
문서 텍스트를 tsvector로 축약합니다.

SELECT to_tsvector('english', 'The Fat Rats');

결과:

   to_tsvector   
-----------------
 'fat':2 'rat':3    
(1 row)

ts_delete(vector tsvector, lexeme text)
vector에서 주어진 lexeme을 제거합니다.

SELECT ts_delete('fat:2,4 cat:3 rat:5A'::tsvector, 'fat');

결과:

    ts_delete     
------------------
 'cat':3 'rat':5A     
(1 row)

ts_delete(vector tsvector, lexemes text[])
vector에서 lexemes에 포함된 어휘소가 나타나는 모든 부분을 제거합니다.
```
SELECT ts_delete('fat:2,4 cat:3 rat:5A'::tsvector, ARRAY['fat','rat']);
```
결과:
```
 ts_delete 
-----------
 'cat':3     
(1 row)
```

ts_filter(vector tsvector, weights “char”[])
vector에서 주어진 weights를 가진 요소만 선택합니다.

SELECT ts_filter('fat:2,4 cat:3b rat:5A'::tsvector, '{a,b}');

결과:

     ts_filter     
-------------------
 'cat':3B 'rat':5A     
(1 row)

ts_headline([ config regconfig, ] document text, query tsquery [, options text ])
쿼리 일치 부분을 표시합니다.
```
SELECT ts_headline('x y z', 'z'::tsquery);
```
결과:
```
 ts_headline  
--------------
 x y <b>z</b>     
(1 row)
```

ts_rank([ weights float4[], ] vector tsvector, query tsquery [, normalization integer ])
쿼리에 대해 문서의 순위를 매깁니다.

SELECT ts_rank(to_tsvector('This is an example of document'), to_tsquery('example'));

결과:

  ts_rank  
-----------
 0.0607927
(1 row)

ts_rank_cd([ weights float4[], ] vector tsvector, query tsquery [, normalization integer ])
커버 밀도(cover density)를 사용하여 쿼리에 대해 문서의 순위를 매깁니다.
```
SELECT ts_rank_cd(to_tsvector('This is an example of document'), to_tsquery('example'));
```
결과:
```
 ts_rank_cd 
------------
        0.1
(1 row)
```

ts_rewrite(query tsquery, target tsquery, substitute tsquery)
쿼리 내에서 target을 substitute로 치환합니다.

SELECT ts_rewrite('a & b'::tsquery, 'a'::tsquery, 'foo|bar'::tsquery);

결과:

       ts_rewrite        
-------------------------
 'b' & ( 'foo' | 'bar' )     
(1 row)

ts_rewrite(query tsquery, select text)
SELECT 결과의 첫 번째 열 값을 SELECT 결과의 두 번째 열 값으로 치환합니다.

create table aliases (t tsquery primary key, s tsquery);
insert into aliases values ('a', 'foo|bar');

SELECT ts_rewrite('a & b'::tsquery, 'SELECT t,s FROM aliases');

결과:

       ts_rewrite        
-------------------------
 'b' & ( 'bar' | 'foo' )     
(1 row)

tsquery_phrase(query1 tsquery, query2 tsquery)
query1 다음에 query2가 오는 것을 검색하는 쿼리를 생성합니다(<-> 연산자와 동일).
```
SELECT tsquery_phrase(to_tsquery('fat'), to_tsquery('cat'));
```
결과:
```
 tsquery_phrase  
-----------------
 'fat' <-> 'cat'     
(1 row)
```
tsquery_phrase(query1 tsquery, query2 tsquery, distance integer)
query1 다음에 거리 distance만큼 떨어져 query2가 오는 것을 검색하는 쿼리를 생성합니다.
```
SELECT tsquery_phrase(to_tsquery('fat'), to_tsquery('cat'), 10);
```
결과:
```
  tsquery_phrase  
------------------
 'fat' <10> 'cat'     
(1 row)
```

tsvector_to_array(tsvector)
tsvector를 어휘소 배열로 변환합니다.

SELECT tsvector_to_array('fat:2,4 cat:3 rat:5A'::tsvector);

결과:

 tsvector_to_array 
-------------------
   {cat,fat,rat}     
(1 row)

tsvector_update_trigger()
tsvector 열을 자동으로 갱신하는 함수를 트리거합니다.

CREATE TRIGGER tsvectorupdate BEFORE INSERT OR UPDATE ON messages 
FOR EACH ROW EXECUTE PROCEDURE
tsvector_update_trigger(tsv, 'pg_catalog.english', title, body);

INSERT INTO messages VALUES ('title here', 'the body text is here');

SELECT * FROM messages;

결과:

   title    |         body          |            tsv             
------------+-----------------------+----------------------------
 title here | the body text is here | 'bodi':4 'text':5 'titl':1   
(1 row)

tsvector_update_trigger_column()
tsvector 열을 자동으로 갱신하는 함수를 트리거합니다.
```
CREATE TRIGGER ... tsvector_update_trigger_column(tsv, configcol, title, body);
```

unnest(tsvector, OUT lexeme text, OUT positions smallint[], OUT weights text)
tsvector를 행 집합으로 확장합니다.

SELECT unnest('fat:2,4 cat:3 rat:5A'::tsvector);

결과:

        unnest         
-----------------------
 (cat,{3},{D})
 (fat,"{2,4}","{D,D}")
 (rat,{5},{A})    
(3 row)

ts_debug([ config regconfig, ] document text, OUT alias text, OUT description text, OUT token text, OUT dictionaries regdictionary[], OUT dictionary regdictionary, OUT lexemes text[])
설정을 테스트합니다.

SELECT ts_debug('english', 'The Brightest supernovaes');

결과:

                                     ts_debug                                      
-----------------------------------------------------------------------------------
 (asciiword,"Word, all ASCII",The,{english_stem},english_stem,{})
 (blank,"Space symbols"," ",{},,)
 (asciiword,"Word, all ASCII",Brightest,{english_stem},english_stem,{brightest})
 (blank,"Space symbols"," ",{},,)
 (asciiword,"Word, all ASCII",supernovaes,{english_stem},english_stem,{supernova})
(5 row)

ts_lexize(dict regdictionary, token text)
사전을 테스트합니다.

SELECT ts_lexize('english_stem', 'stars');

결과:

 ts_lexize 
-----------
  {star}
(1 row)

ts_parse(parser_name text, document text, OUT tokid integer, OUT token text)
파서를 테스트합니다.

SELECT ts_parse('default', 'foo - bar');

결과:

 ts_parse  
-----------
 (1,foo)
 (12," ")
 (12,"- ")
 (1,bar)
(4 row)

ts_parse(parser_oid oid, document text, OUT tokid integer, OUT token text)
oid로 파서를 테스트합니다.

SELECT ts_parse(3722, 'foo - bar');

결과:

 ts_parse  
-----------
 (1,foo)
 (12," ")
 (12,"- ")
 (1,bar)
(4 row)

ts_token_type(parser_name text, OUT tokid integer, OUT alias text, OUT description text)
파서가 정의한 토큰 타입을 가져옵니다.

SELECT ts_token_type('default');

결과:

         ts_token_type                         
---------------------------------
 (1,asciiword,"Word, all ASCII")
 ...
(23 row)     

ts_token_type(parser_oid oid, OUT tokid integer, OUT alias text, OUT description text)
파서가 정의한 토큰 타입을 가져옵니다.

SELECT ts_token_type(3722);

결과:

         ts_token_type                         
---------------------------------
 (1,asciiword,"Word, all ASCII")
 ...
(23 row)     

ts_stat(sqlquery text, [ weights text, ] OUT word text, OUT ndoc integer, OUT nentry integer)
tsvector 열의 통계를 반환합니다.
```
SELECT ts_stat('SELECT vector FROM apod');
```
결과:
```
  ts_stat 
------------    
(foo,10,15)
...
(4 row)
```

JSON 함수

to_json(anyelement), to_jsonb(anyelement)
값을 json 또는 jsonb로 반환합니다. 배열과 복합 타입은 배열과 객체로 변환됩니다. 그렇지 않은 경우 해당 타입에서 json으로의 캐스팅이 있으면 캐스팅 함수를 사용하여 변환을 수행하거나 스칼라 값을 생성합니다. 숫자, 불리언, null 값을 제외한 모든 스칼라 타입의 경우, 유효한 json 또는 jsonb 값이 되도록 텍스트 표현이 사용됩니다.
```
SELECT to_json('Fred said "Hi."'::text);
```
결과:
```
       to_json
---------------------
 "Fred said "Hi.\""
(1 row)
```

array_to_json(anyarray [, pretty_bool])
배열을 JSON 배열로 반환합니다. pretty_bool이 true이면 차원-1 요소 사이에 줄바꿈이 추가됩니다.

SELECT array_to_json('{{1,5},{99,100}}'::int[]);

결과:

  array_to_json   
------------------
 [[1,5],[99,100]]
(1 row)
           
SELECT array_to_json('{{1,5},{99,100}}'::int[], true);

결과:

 array_to_json 
---------------
 [[1,5],      +
  [99,100]]  
(1 row)

row_to_json(record [, pretty_bool])
행을 JSON 객체로 반환합니다. pretty_bool이 true이면 레벨-1 요소 사이에 줄바꿈이 추가됩니다.
```
SELECT row_to_json(row(1,'foo'));
```
결과:
```
     row_to_json     
---------------------
 {"f1":1,"f2":"foo"}
(1 row)
```
json_build_array(VARIADIC “any”), jsonb_build_array(VARIADIC “any”)
가변 인자 목록으로부터 서로 다른 타입이 섞일 수 있는 JSON 배열을 만듭니다.
```
SELECT json_build_array(1,2,'3',4,5);
```
결과:
```
 json_build_array  
-------------------
 [1, 2, "3", 4, 5]
(1 row)
```
json_build_object(VARIADIC “any”), jsonb_build_object(VARIADIC “any”)
가변 인자 목록으로부터 JSON 객체를 만듭니다. 관례상 인자 목록은 키와 값이 번갈아 나열됩니다.
```
SELECT json_build_object('foo',1,'bar',2);
```
결과:
```
   json_build_object    
------------------------
 {"foo" : 1, "bar" : 2}
(1 row)
```
json_object(text[]), jsonb_object(text[])
text 배열로부터 JSON 객체를 만듭니다. 배열은 짝수 개의 멤버를 가진 정확히 1차원이어야 하며(이 경우 키/값 쌍이 번갈아 나열된 것으로 간주됨), 또는 각 내부 배열이 정확히 2개의 요소를 가진 2차원이어야 합니다(이 경우 키/값 쌍으로 간주됨).
```
SELECT json_object('{a, 1, b, "def", c, 3.5}');
SELECT json_object('{{a, 1},{b, "def"},{c, 3.5}}');
```
결과:
```
              json_object              
---------------------------------------
 {"a" : "1", "b" : "def", "c" : "3.5"}
(1 row)
```
json_object(keys text[], values text[]), jsonb_object(keys text[], values text[])
이 형태의 json_object는 별도의 두 배열에서 키와 값을 쌍으로 가져옵니다. 그 외 모든 면에서는 단일 인자 형태와 동일합니다.
```
SELECT json_object('{a, b}', '{1,2}');
```
결과:
```
      json_object       
------------------------
 {"a" : "1", "b" : "2"}
(1 row)
```

json_array_length(json), jsonb_array_length(jsonb)
최상위 JSON 배열의 요소 개수를 반환합니다.

SELECT json_array_length('[1,2,3,{"f1":1,"f2":[5,6]},4]');

결과:

 json_array_length 
-------------------
                 5
(1 row)

json_each(json), jsonb_each(jsonb)
최상위 JSON 객체를 키/값 쌍 집합으로 확장합니다.

SELECT * FROM json_each('{"a":"foo", "b":"bar"}');

결과:

 key | value 
-----+-------
 a   | "foo"
 b   | "bar"
(2 row)

json_each_text(json), jsonb_each_text(jsonb)
최상위 JSON 객체를 키/값 쌍 집합으로 확장합니다. 반환되는 값은 text 타입입니다.
```
SELECT * FROM json_each_text('{"a":"foo", "b":"bar"}');
```
결과:
```
 key | value 
-----+-------
 a   | foo
 b   | bar
(2 row)
```
json_extract_path(from_json json, VARIADIC path_elems text[]), jsonb_extract_path(from_json jsonb, VARIADIC path_elems text[])
path_elems가 가리키는 JSON 값을 반환합니다(#> 연산자와 동일).
```
SELECT * FROM json_extract_path('{"f2":{"f3":1},"f4":{"f5":99,"f6":"foo"}}','f4');
```
결과:
```
  json_extract_path   
----------------------
 {"f5":99,"f6":"foo"}
(1 row)
```
json_extract_path_text(from_json json, VARIADIC path_elems text[]), jsonb_extract_path_text(from_json jsonb, VARIADIC path_elems text[])
path_elems가 가리키는 JSON 값을 text로 반환합니다(#>> 연산자와 동일).
```
SELECT json_extract_path_text('{"f2":{"f3":1},"f4":{"f5":99,"f6":"foo"}}','f4', 'f6');
```
결과:
```
 json_extract_path_text 
------------------------
         foo
(1 row)
```

json_object_keys(json), jsonb_object_keys(jsonb)
최상위 JSON 객체의 키 집합을 반환합니다.

SELECT json_object_keys('{"f1":"abc","f2":{"f3":"a", "f4":"b"}}');

결과:

 json_object_keys 
------------------
       f1
       f2
(2 row)

json_populate_record(base anyelement, from_json json), jsonb_populate_record(base anyelement, from_json jsonb)
from_json의 객체를 base가 정의한 record 타입과 열이 일치하는 행으로 확장합니다.
```
CREATE TABLE myrowtype (a int, b int);

SELECT * FROM json_populate_record(null::myrowtype, '{"a":1,"b":2}');
```
결과:
```
 a | b 
---+---
 1 | 2
(1 row)
```
json_populate_recordset(base anyelement, from_json json), jsonb_populate_recordset(base anyelement, from_json jsonb)
from_json의 최상위 객체 배열을 base가 정의한 record 타입과 열이 일치하는 행 집합으로 확장합니다.
```
SELECT * FROM json_populate_recordset(null::myrowtype, '[{"a":1,"b":2},{"a":3,"b":4}]');
```
결과:
```
 a | b 
---+---
 1 | 2
 3 | 4
(2 row)
```

json_array_elements(json), jsonb_array_elements(jsonb)
JSON 배열을 JSON 값 집합으로 확장합니다.

SELECT * FROM json_array_elements('[1,true, [2,false]]');

결과:

   value   
-----------
     1
   true
[2,false]]
(3 row)

json_array_elements_text(json), jsonb_array_elements_text(jsonb)
JSON 배열을 text 값 집합으로 확장합니다.
```
SELECT * FROM json_array_elements_text('["foo", "bar"]');
```
결과:
```
 value 
-------
  foo
  bar
(2 row)
```
json_typeof(json), jsonb_typeof(jsonb)
최상위 JSON 값의 타입을 텍스트 문자열로 반환합니다. 가능한 타입은 object, array, string, number, boolean, null입니다.
```
SELECT json_typeof('-123.4');
```
결과:
```
 json_typeof 
-------------
    number
(1 row)
```
json_to_record(json), jsonb_to_record(jsonb)
JSON 객체로부터 임의의 record를 만듭니다. record를 반환하는 모든 함수와 마찬가지로, 호출자는 AS 절로 record의 구조를 명시적으로 정의해야 합니다.
```
SELECT * FROM json_to_record('{"a":1,"b":[1,2,3],"c":"bar"}') as x(a int, b text, d text);
```
결과:
```
 a |    b    | d 
---+---------+---
 1 | [1,2,3] | 
(1 row)
```
json_to_recordset(json), jsonb_to_recordset(jsonb)
객체로 이루어진 JSON 배열로부터 임의의 record 집합을 만듭니다. record를 반환하는 모든 함수와 마찬가지로, 호출자는 AS 절로 record의 구조를 명시적으로 정의해야 합니다.
```
SELECT * FROM json_to_recordset('[{"a":1,"b":"foo"},{"a":"2","c":"bar"}]') 
as x(a int, b text);
```
결과:
```
 a |  b  
---+-----
 1 | foo
 2 |  
(2 row)
```
json_strip_nulls(from_json json), jsonb_strip_nulls(from_json jsonb)
null 값을 가진 모든 객체 필드가 생략된 from_json을 반환합니다. 그 외의 null 값은 변경되지 않습니다.
```
SELECT json_strip_nulls('[{"f1":1,"f2":null},2,null,3]');
```
결과:
```
  json_strip_nulls   
---------------------
 [{"f1":1},2,null,3]  
(1 row)
```

jsonb_set(target jsonb, path text[], new_value jsonb[, create_missing boolean])
path로 지정된 부분이 new_value로 치환되거나, create_missing이 true(기본값은 true)이고
path로 지정된 항목이 존재하지 않으면 new_value가 추가된 target을 반환합니다. path 지향 연산자와 마찬가지로, path에 나타나는 음의 정수는 JSON 배열의 끝에서부터 셉니다.

SELECT jsonb_set('[{"f1":1,"f2":null},2,null,3]', '{0,f1}','[2,3,4]', false);

결과:

                  jsonb_set                  
---------------------------------------------
 [{"f1": [2, 3, 4], "f2": null}, 2, null, 3]
(1 row)
                                      
SELECT jsonb_set('[{"f1":1,"f2":null},2]', '{0,f3}','[2,3,4]');

결과:

                  jsonb_set                  
---------------------------------------------
 [{"f1": 1, "f2": null, "f3": [2, 3, 4]}, 2]
(1 row)                                          

jsonb_insert(target jsonb, path text[], new_value jsonb, [insert_after boolean])
new_value가 삽입된 target을 반환합니다. path로 지정된 target 부분이 JSONB 배열 안에 있으면, new_value는 target 앞에 삽입되거나 insert_after가 true(기본값은 false)이면 뒤에 삽입됩니다. path로 지정된 target 부분이 JSONB 객체 안에 있으면, target이 존재하지 않는 경우에만 new_value가 삽입됩니다. path 지향 연산자와 마찬가지로, path에 나타나는 음의 정수는 JSON 배열의 끝에서부터 셉니다.
```
SELECT jsonb_insert('{"a": [0,1,2]}', '{a, 1}', '"new_value"');
```
결과:
```
         jsonb_insert          
-------------------------------
 {"a": [0, "new_value", 1, 2]}
(1 row)
                                      
SELECT jsonb_insert('{"a": [0,1,2]}', '{a, 1}', '"new_value"', true);
```
결과:
```
         jsonb_insert          
-------------------------------
 {"a": [0, 1, "new_value", 2]}
(1 row)                                          
```

jsonb_pretty(from_json jsonb)
from_json을 들여쓰기된 JSON 텍스트로 반환합니다.

SELECT jsonb_pretty('[{"f1":1,"f2":null},2,null,3]');

결과:

    jsonb_pretty    
--------------------
 [                 +
     {             +
         "f1": 1,  +
         "f2": null+
     },            +
     2,            +
     null,         +
     3             +
 ]
(1 row)

시퀀스 조작 함수

이 절에서는 시퀀스를 다루는 함수를 설명합니다. 시퀀스는 CREATE SEQUENCE로 생성할 수 있습니다.

CREATE SEQUENCE serial increment by 1 start 101;

nextval(regclass)
시퀀스를 진행시키고 새 값을 반환합니다.

SELECT nextval('serial');

결과:

 nextval 
---------
     101 
(1 row)      

currval(regclass)
지정한 시퀀스에 대해 nextval로 가장 최근에 얻은 값을 반환합니다.
```
SELECT currval('serial');
```
결과:
```
 currval 
---------
     101 
(1 row)      
```
lastval()
임의의 시퀀스에 대해 nextval로 가장 최근에 얻은 값을 반환합니다.
```
SELECT lastval();
```
결과:
```
 lastval 
---------
     101 
(1 row)      
```

setval(regclass, bigint)
시퀀스의 현재 값을 설정합니다.

SELECT setval('serial', 101);

결과:

 setval 
--------
    101
(1 row)      

setval(regclass, bigint, boolean)
시퀀스의 현재 값과 is_called 플래그를 설정합니다.

-- true
SELECT setval('serial', 101, true);

결과:

 setval 
--------
    101
(1 row)

SELECT nextval('serial');

결과:

 nextval 
---------
     102
(1 row)

-- false
SELECT setval('serial', 101, false);

결과:

 setval 
--------
    101
(1 row)

SELECT nextval('serial');

결과:

 nextval 
---------
     101
(1 row)

배열 함수

array_append(anyarray, anyelement)
anyelement를 배열의 끝에 추가합니다.

SELECT array_append(ARRAY[1,2], 3);

결과:

 array_append 
--------------
   {1,2,3}
(1 row)      

array_cat(anyarray, anyarray)
두 배열을 연결합니다.

SELECT array_cat(ARRAY[1,2,3], ARRAY[4,5]);

결과:

  array_cat  
-------------
 {1,2,3,4,5}
(1 row)      

array_ndims(anyarray)
배열의 차원 수를 반환합니다.

SELECT array_ndims(ARRAY[[1,2,3], [4,5,6]]);

결과:

 array_ndims 
-------------
           2
(1 row)      

array_dims(anyarray)
배열의 차원에 대한 text 표현을 반환합니다.

SELECT array_dims(ARRAY[[1,2,3], [4,5,6]]);

결과:

 array_dims 
------------
 [1:2][1:3]
(1 row)      

array_fill(anyelement, int[], [, int[]])
선택적으로 제공된 값과 차원으로 초기화된 배열을 반환합니다.
```
SELECT array_fill(7, ARRAY[3], ARRAY[2]);
```
결과:
```
  array_fill   
---------------
 [2:4]={7,7,7}
(1 row)      
```

array_length(anyarray, int)
요청한 배열 차원의 길이를 반환합니다.

SELECT array_length(array[1,2,3], 1);

결과:

 array_length 
--------------
            3
(1 row)      

array_lower(anyarray, int)
요청한 배열 차원의 하한을 반환합니다.

SELECT array_lower('[0:2]={1,2,3}'::int[], 1);

결과:

 array_lower 
-------------
          0
(1 row)      

array_position(anyarray, anyelement [, int])
세 번째 인자가 가리키는 요소 또는 첫 번째 요소부터 시작하여, 배열에서 두 번째 인자가 처음 나타나는 위치의 인덱스를 반환합니다(배열은 1차원이어야 함).
```
SELECT array_position(ARRAY['sun','mon','tue','wed','thu','fri','sat'], 'mon');
```
결과:
```
 array_position 
----------------
              2
(1 row)      
```
array_positions(anyarray, anyelement)
첫 번째 인자로 주어진 배열에서 두 번째 인자가 나타나는 모든 위치의 인덱스로 이루어진 배열을 반환합니다(배열은 1차원이어야 함).
```
SELECT array_positions(ARRAY['A','A','B','A'], 'A');
```
결과:
```
 array_positions 
-----------------
     {1,2,4}
(1 row)      
```

array_prepend(anyelement, anyarray)
anyelement를 배열의 맨 앞에 추가합니다.

SELECT array_prepend(1, ARRAY[2,3]);

결과:

 array_prepend 
---------------
    {1,2,3}
(1 row)      

array_remove(anyarray, anyelement)
배열에서 주어진 값과 같은 모든 요소를 제거합니다.

SELECT array_remove(ARRAY[1,2,3,2], 2);

결과:

 array_remove 
--------------
     {1,3}
(1 row)      

array_replace(anyarray, anyelement, anyelement)
주어진 값과 같은 각 배열 요소를 새 값으로 치환합니다.
```
SELECT array_replace(ARRAY[1,2,5,4], 5, 3);
```
결과:
```
 array_replace 
---------------
   {1,2,3,4}
(1 row)      
```

array_to_string(anyarray, text [, text])
지정한 구분자와 선택적인 null 문자열을 사용하여 배열 요소를 연결합니다.

SELECT array_to_string(ARRAY[1, 2, 3, NULL, 5], ',', '*');

결과:

 array_to_string 
-----------------
    1,2,3,*,5
(1 row)      

array_upper(anyarray, int)
요청한 배열 차원의 상한을 반환합니다.

SELECT array_upper(ARRAY[1,8,3,7], 1);

결과:

 array_upper 
-------------
           4
(1 row)      

cardinality(anyarray)
배열의 전체 요소 개수를 반환하며, 배열이 비어 있으면 0을 반환합니다.
```
SELECT cardinality(ARRAY[[1,2],[3,4]]);
```
결과:
```
 cardinality 
-------------
           4
(1 row)      
```
string_to_array(text, text [, text])
제공된 구분자와 선택적인 null 문자열을 사용하여 문자열을 배열 요소로 분리합니다.
```
SELECT string_to_array('xx~^~yy~^~zz', '~^~', 'yy');
```
결과:
```
 string_to_array 
-----------------
   {xx,NULL,zz}
(1 row)      
```

unnest(anyarray)
배열을 행 집합으로 확장합니다.

SELECT unnest(ARRAY[1,2]);

결과:

 unnest 
--------
    1
    2
(2 row)      

unnest(anyarray, anyarray [, …])
여러 배열(타입이 서로 다를 수 있음)을 행 집합으로 확장합니다. 이것은 FROM 절에서만 허용됩니다.

SELECT * FROM unnest(ARRAY[1,2],ARRAY['foo','bar','baz']);

결과:

 unnest | unnest 
--------+--------
      1 | foo
      2 | bar
        | baz    

(1 row)      

범위 함수 및 연산자

lower(anyrange)
입력 numeric 범위의 하한을 반환합니다.

SELECT * FROM lower(numrange(1.1,2.2));

결과:

 lower 
-------
   1.1
(1 row)

upper(anyrange)
입력 numeric 범위의 상한을 반환합니다.

SELECT * FROM upper(numrange(1.1,2.2));

결과:

 upper 
-------
   2.2
(1 row)

isempty(anyrange)
입력한 숫자 범위가 비어 있는지를 나타내는 boolean 값을 반환합니다.
```
SELECT * FROM isempty(numrange(1.1,2.2));
```
결과:
```
 isempty 
---------
 f
(1 row)
```
lower_inc(anyrange)
입력한 숫자 범위의 하한이 존재하는지를 반환합니다.
```
SELECT * FROM lower_inc(numrange(1.1,2.2));
```
결과:
```
 lower_inc 
-----------
 t
(1 row)
```
upper_inc(anyrange)
입력 숫자 범위의 상한이 존재하는지를 나타내는 논리값을 반환합니다.
```
SELECT * FROM upper_inc(numrange(1.1,2.2));
```
결과:
```
 lower_inc 
-----------
 f
(1 row)
```
lower_inf(anyrange)
입력한 숫자 범위의 하한이 무한한지를 나타내는 논리값을 반환합니다.
```
SELECT * FROM lower_inf('(,)'::daterange);
```
결과:
```
 lower_inf 
-----------
 t
(1 row)
```
upper_inf(anyrange)
입력한 숫자 범위의 상한이 무한한지를 나타내는 논리값을 반환합니다.
```
SELECT * FROM upper_inf('(,)'::daterange);
```
결과:
```
 upper_inf 
-----------
 t
(1 row)
```

range_merge(anyrange, anyrange)
주어진 두 범위를 모두 포함하는 가장 작은 범위를 반환합니다.

SELECT * FROM range_merge('[1,2)'::int4range, '[3,4)'::int4range);

결과:

 range_merge 
-------------
 [1,4)
(1 row)

집계 함수

array_agg(expression)
null을 포함한 입력 값들을 배열로 연결하여 반환합니다.

인수 타입: any non-array type
반환 타입: array of the argument type
array_agg(expression)
입력 배열들을 한 차원 더 높은 배열로 연결하여 반환합니다(참고: 입력은 모두 동일한 차원을 가져야 하며, 비어 있거나 NULL일 수 없음).

인수 타입: any array type
반환 타입: same as argument data type
avg(expression)
모든 입력 값의 평균(산술 평균)을 반환합니다.

인수 타입: smallint, int, bigint, real, double precision, numeric, or interval
반환 타입: numeric for any integer-type argument, double precision for a floating-point argument, otherwise the same as the argument data type
bit_and(expression)
null이 아닌 모든 입력 값의 비트 AND를 반환하며, 해당 값이 없으면 null을 반환합니다.

인수 타입: smallint, int, bigint, or bit
반환 타입: same as argument data type
bit_or(expression)
null이 아닌 모든 입력 값의 비트 OR를 반환하며, 해당 값이 없으면 null을 반환합니다.

인수 타입: smallint, int, bigint, or bit
반환 타입: same as argument data type
bool_and(expression)
모든 입력 값이 true이면 true를, 그렇지 않으면 false를 반환합니다.

인수 타입: bool
반환 타입: bool
bool_or(expression)
적어도 하나의 입력 값이 true이면 true를, 그렇지 않으면 false를 반환합니다.

인수 타입: bool
반환 타입: bool
count(anything)
입력 행의 개수를 반환합니다.

인수 타입: any
반환 타입: bigint
count(expression)
expression 값이 null이 아닌 입력 행의 개수를 반환합니다.

인수 타입: any
반환 타입: bigint
every(expression)
bool_and와 동일합니다.

인수 타입: bool
반환 타입: bool
json_agg(expression)
값들을 JSON 배열로 집계합니다.

인수 타입: any
반환 타입: json
jsonb_agg(expression)
값들을 JSON 배열로 집계합니다.

인수 타입: any
반환 타입: jsonb
json_object_agg(name, value)
이름/값 쌍을 JSON 객체로 집계합니다.

인수 타입: (any, any)
반환 타입: json
jsonb_object_agg(name, value)
이름/값 쌍을 JSON 객체로 집계합니다.

인수 타입: (any, any)
반환 타입: jsonb
max(expression)
모든 입력 값에 걸쳐 expression의 최대값을 반환합니다.

인수 타입: any numeric, string, date/time, network, or enum type, or arrays of these types
반환 타입: same as argument type
min(expression)
모든 입력 값에 걸쳐 expression의 최소값을 반환합니다.

인수 타입: any numeric, string, date/time, network, or enum type, or arrays of these types
반환 타입: same as argument type
string_agg(expression, delimiter)
입력 값들을 구분자로 구분하여 하나의 문자열로 연결하여 반환합니다.

인수 타입: (text, text) or (bytea, bytea)
반환 타입: same as argument types
sum(expression)
모든 입력 값에 걸쳐 expression의 합을 반환합니다.

인수 타입: smallint, int, bigint, real, double precision, numeric, interval, or money
반환 타입: bigint for smallint or int arguments, numeric for bigint arguments, otherwise the same as the argument data type
xmlagg(expression)
XML 값들을 연결하여 반환합니다.

인수 타입: xml
반환 타입: xml
corr(Y, X)
입력한 두 숫자의 상관 계수를 반환합니다.

인수 타입: double precision
반환 타입: double precision
covar_pop(Y, X)
입력한 두 숫자의 모집단 공분산을 반환합니다.

인수 타입: double precision
반환 타입: double precision
covar_samp(Y, X)
입력한 두 숫자의 표본 공분산을 반환합니다.

인수 타입: double precision
반환 타입: double precision
regr_avgx(Y, X)
독립 변수 X의 평균(sum(X)/N)을 반환합니다.

인수 타입: double precision
반환 타입: double precision
regr_avgy(Y, X)
종속 변수 Y의 평균(sum(Y)/N)을 반환합니다.

인수 타입: double precision
반환 타입: double precision
regr_count(Y, X)
두 표현식이 모두 null이 아닌 입력 행의 개수를 반환합니다.

인수 타입: double precision
반환 타입: bigint
regr_intercept(Y, X)
(X, Y) 쌍으로 결정되는 최소제곱 적합 일차 방정식의 y절편을 반환합니다.

인수 타입: double precision
반환 타입: double precision
regr_r2(Y, X)
입력한 두 숫자의 상관 계수의 제곱을 반환합니다.

인수 타입: double precision
반환 타입: double precision
regr_slope(Y, X)
(X, Y) 쌍으로 결정되는 최소제곱 적합 일차 방정식의 기울기를 반환합니다.

인수 타입: double precision
반환 타입: double precision
regr_sxx(Y, X)
sum(X^2) - sum(X)^2/N(독립 변수의 “제곱합”)을 반환합니다.

인수 타입: double precision
반환 타입: double precision
regr_sxy(Y, X)
sum(X*Y) - sum(X) * sum(Y)/N(독립 변수와 종속 변수의 곱의 “곱합”)을 반환합니다.

인수 타입: double precision
반환 타입: double precision
regr_syy(Y, X)
sum(Y^2) - sum(Y)^2/N(종속 변수의 “제곱합”)을 반환합니다.

인수 타입: double precision
반환 타입: double precision
stddev(expression)
stddev_samp에 대한 과거 별칭을 반환합니다.

인수 타입: smallint, int, bigint, real, double precision, or numeric
반환 타입: double precision for floating-point arguments, otherwise numeric
stddev_pop(expression)
입력 값들의 모집단 표준편차를 반환합니다.

인수 타입: smallint, int, bigint, real, double precision, or numeric
반환 타입: double precision for floating-point arguments, otherwise numeric
stddev_samp(expression)
입력 값들의 표본 표준편차를 반환합니다.

인수 타입: smallint, int, bigint, real, double precision, or numeric
반환 타입: double precision for floating-point arguments, otherwise numeric
variance(expression)
var_samp에 대한 과거 별칭을 반환합니다.

인수 타입: smallint, int, bigint, real, double precision, or numeric
반환 타입: double precision for floating-point arguments, otherwise numeric
var_pop(expression)
입력 값들의 모집단 분산(모집단 표준편차의 제곱)을 반환합니다.

인수 타입: smallint, int, bigint, real, double precision, or numeric
반환 타입: double precision for floating-point arguments, otherwise numeric
var_samp(expression)
입력 값들의 표본 분산(표본 표준편차의 제곱)을 반환합니다.

인수 타입: smallint, int, bigint, real, double precision, or numeric
반환 타입: double precision for floating-point arguments, otherwise numeric
mode() WITHIN GROUP (ORDER BY sort_expression)
가장 빈번하게 나타나는 입력 값을 반환합니다(빈도가 동일한 결과가 여러 개이면 그중 하나를 임의로 선택).

인수 타입: any sortable type
반환 타입: same as sort expression
percentile_cont(fraction) WITHIN GROUP (ORDER BY sort_expression)
순서에서 지정한 분수에 해당하는 값을 반환하며, 필요한 경우 인접한 입력 항목 사이를 보간합니다.

인수 타입: double precision or interval
반환 타입: same as sort expression
percentile_cont(fractions) WITHIN GROUP (ORDER BY sort_expression)
fractions 매개변수의 형태와 일치하는 결과 배열을 반환하며, null이 아닌 각 요소는 해당 백분위에 대응하는 값으로 치환됩니다.

인수 타입: double precision or interval
반환 타입: array of sort expression's type
percentile_disc(fraction) WITHIN GROUP (ORDER BY sort_expression)
순서에서의 위치가 지정한 분수와 같거나 그 이상인 첫 번째 입력 값을 반환합니다.

인수 타입: any sortable type
반환 타입: same as sort expression
percentile_disc(fractions) WITHIN GROUP (ORDER BY sort_expression)
fractions 매개변수의 형태와 일치하는 결과 배열을 반환하며, null이 아닌 각 요소는 해당 백분위에 대응하는 입력 값으로 치환됩니다.

인수 타입: any sortable type
반환 타입: array of sort expression's type
rank(args) WITHIN GROUP (ORDER BY sorted_args)
인자의 순위를 반환하며, 중복 행에 대해서는 간격을 둡니다.

인수 타입: VARIADIC "any"
반환 타입: bigint
dense_rank(args) WITHIN GROUP (ORDER BY sorted_args)
인자의 순위를 반환하며, 중복 행에 대해서는 간격을 두지 않습니다.

인수 타입: VARIADIC "any"
반환 타입: bigint
percent_rank(args) WITHIN GROUP (ORDER BY sorted_args)
인자의 상대 순위를 반환하며, 범위는 0에서 1까지입니다.

인수 타입: VARIADIC "any"
반환 타입: double precision
cume_dist(args) WITHIN GROUP (ORDER BY sorted_args)
인자의 상대 순위를 반환하며, 범위는 1/N에서 1까지입니다.

인수 타입: VARIADIC "any"
반환 타입: double precision
GROUPING(args…)
현재 그룹화 집합에 포함되지 않은 인자를 나타내는 정수 비트 마스크를 반환합니다.

반환 타입: integer

윈도우 함수

row_number()
파티션 내에서 현재 행의 번호를 1부터 세어 반환합니다.

반환 타입: bigint
rank()
현재 행의 순위를 간격을 두고 반환합니다. 첫 번째 동순위 행의 row_number와 동일합니다.

반환 타입: bigint
dense_rank()
현재 행의 순위를 간격 없이 반환합니다. 이 함수는 동순위 그룹을 셉니다.

반환 타입: bigint
percent_rank()
현재 행의 상대 순위를 반환합니다: (rank - 1)/(파티션 전체 행 수 - 1).

반환 타입: double precision
cume_dist()
누적 분포를 반환합니다: (현재 행보다 앞서거나 동순위인 파티션 행 수)/파티션 전체 행 수.

반환 타입: double precision
ntile(num_buckets integer)
1부터 인자 값까지의 정수를 반환하여 파티션을 가능한 한 균등하게 나눕니다.

반환 타입: integer
lag(value anyelement [, offset integer [, default anyelement ]])
파티션 내에서 현재 행보다 offset 행만큼 앞에 있는 행에서 평가된 값을 반환합니다. 해당 행이 없으면 대신 default(value와 동일한 타입이어야 함)를 반환합니다. offset과 default는 모두 현재 행을 기준으로 평가됩니다. 생략하면 offset은 1, default는 null이 기본값입니다.

반환 타입: same type as value
lead(value anyelement [, offset integer [, default anyelement ]])
파티션 내에서 현재 행보다 offset 행만큼 뒤에 있는 행에서 평가된 값을 반환합니다. 해당 행이 없으면 대신 default(value와 동일한 타입이어야 함)를 반환합니다. offset과 default는 모두 현재 행을 기준으로 평가됩니다. 생략하면 offset은 1, default는 null이 기본값입니다.

반환 타입: same type as value
first_value(value any)
윈도우 프레임의 첫 번째 행에서 평가된 값을 반환합니다.

반환 타입: same type as value
last_value(value any)
윈도우 프레임의 마지막 행에서 평가된 값을 반환합니다.

반환 타입: same type as value
nth_value(value any, nth integer)
윈도우 프레임의 n번째 행(1부터 세는)에서 평가된 값을 반환하며, 해당 행이 없으면 null을 반환합니다.

반환 타입: same type as value

시스템 정보 함수

current_catalog
현재 데이터베이스의 이름입니다(SQL 표준에서는 “catalog”라고 함).
```
SELECT current_catalog;
```
결과:
```
 current_database 
------------------
       test
(1 row)
```

current_database()
현재 데이터베이스의 이름을 반환합니다.

SELECT current_database();

결과:

 current_database 
------------------
       test
(1 row)

current_query()
클라이언트가 제출한 대로 현재 실행 중인 쿼리의 텍스트를 반환합니다(둘 이상의 구문을 포함할 수 있음).
```
SELECT current_query();
```
결과:
```
      current_query      
-------------------------
 SELECT current_query();
(1 row)
```

current_role
current_user와 동일한 값을 반환합니다.

SELECT current_role;

결과:

 current_user 
--------------
    agens
(1 row)    

current_schema[()]
현재 스키마의 이름을 반환합니다.

SELECT current_schema();

결과:

 current_schema 
----------------
     public
(1 row)

current_schemas(boolean)
검색 경로에 있는 스키마의 이름을 반환하며, 선택적으로 암시적 스키마를 포함합니다.
```
SELECT current_schemas(true);
```
결과:
```
   current_schemas   
---------------------
 {pg_catalog,public}
(1 row)
```
current_user
현재 실행 컨텍스트의 사용자 이름을 반환합니다.
```
SELECT current_user;
```
결과:
```
 current_user 
--------------
    agens
(1 row)
```

inet_client_addr()
원격 연결의 주소를 반환합니다.

SELECT inet_client_addr();

결과:

 inet_client_addr
------------------
       ::1
(1 row)

inet_client_port()
원격 연결의 포트를 반환합니다.

SELECT inet_client_port();

결과:

 inet_client_port 
------------------
      64427        
(1 row)

inet_server_addr()
로컬 연결의 주소를 반환합니다.

SELECT inet_server_addr();

결과:

 inet_server_addr 
------------------
       ::1
(1 row)

inet_server_port()
로컬 연결의 포트를 반환합니다.

SELECT inet_server_port();

결과:

 inet_server_port 
------------------
       5432
(1 row)

pg_backend_pid()
현재 세션에 연결된 서버 프로세스의 프로세스 ID를 반환합니다.
```
SELECT pg_backend_pid();
```
결과:
```
 pg_backend_pid 
----------------
          61675
(1 row)
```
pg_blocking_pids(int)
지정한 서버 프로세스 ID를 차단하고 있는 프로세스 ID를 반환합니다.
```
SELECT pg_blocking_pids(61675);
```
결과:
```
 pg_blocking_pids 
------------------
        {}
(1 row)
```

pg_conf_load_time()
설정 로드 시간을 반환합니다.

SELECT pg_conf_load_time();

결과:

      pg_conf_load_time       
------------------------------
 2017-10-18 13:36:51.99984+09
(1 row)

pg_my_temp_schema()
세션의 임시 스키마 OID를 반환하며, 없으면 0을 반환합니다.

SELECT pg_my_temp_schema();

결과:

 pg_my_temp_schema 
-------------------
                 0
(1 row)

pg_is_other_temp_schema(oid)
스키마가 다른 세션의 임시 스키마인지를 반환합니다.

SELECT pg_is_other_temp_schema(61675);

결과:

 pg_is_other_temp_schema 
-------------------------
           f
(1 row)

pg_listening_channels()
세션이 현재 리스닝하고 있는 채널 이름을 반환합니다.
```
SELECT pg_listening_channels();
```
결과:
```
 pg_listening_channels 
----------------------- 
(0 row) 
```

pg_notification_queue_usage()
비동기 알림 큐가 현재 점유하고 있는 비율(0-1)을 반환합니다.

SELECT pg_notification_queue_usage();

결과:

 pg_notification_queue_usage 
-----------------------------
                           0
(1 row)

pg_postmaster_start_time()
서버 시작 시간을 반환합니다.

SELECT pg_postmaster_start_time();

결과:

   pg_postmaster_start_time    
-------------------------------
 2017-10-18 13:36:52.019037+09
(1 row)

pg_trigger_depth()
현재 PostgreSQL 트리거의 중첩 레벨을 반환합니다(트리거 내부에서 직접 또는 간접적으로 호출되지 않은 경우 0).
```
SELECT pg_trigger_depth();
```
결과:
```
 pg_trigger_depth 
------------------
                0
(1 row)
```

session_user
세션 사용자 이름을 반환합니다.

SELECT session_user;

결과:

 session_user 
--------------
     agens
(1 row)

user
current_user와 동일한 값을 반환합니다.

SELECT user;

결과:

 current_user 
--------------
     agens
(1 row)

version()
AgensGraph의 버전 정보를 반환합니다.

SELECT version();

결과:

                                version    
-------------------------------------------------------------------------------
 PostgreSQL 9.6.2 on x86_64-pc-linux-gnu, compiled by gcc (GCC) 4.4.7 20120313 
 (Red Hat 4.4.7-17), 64-bit
(1 row)

has_any_column_privilege(user, table, privilege)
사용자가 table의 모든 열에 대해 다른 사용자와 동일한 권한을 가지고 있는지를 나타내는 boolean 값을 반환합니다.
```
SELECT has_any_column_privilege('agens', 'myschema.mytable', 'SELECT');     

Result:
 has_any_column_privilege 
--------------------------
            t
(1 row)
```

has_any_column_privilege(table, privilege)
현재 사용자가 table의 모든 열에 대한 권한을 가지고 있는지를 반환합니다.

SELECT has_any_column_privilege('myschema.mytable', 'SELECT');

결과:

 has_any_column_privilege 
--------------------------
            t       
(1 row)

has_column_privilege(user, table, column, privilege)
사용자가 table의 열에 대한 권한을 가지고 있는지를 반환합니다.

SELECT has_column_privilege('agens', 'myschema.mytable', 'col1', 'SELECT');

결과:

 has_column_privilege 
----------------------
          t
(1 row)

has_column_privilege(table, column, privilege)
현재 사용자가 table의 열에 대한 권한을 가지고 있는지를 반환합니다.

SELECT has_column_privilege('myschema.mytable', 'col1', 'SELECT');

결과:

 has_column_privilege 
----------------------
          t
(1 row)

has_database_privilege(user, database, privilege)
사용자가 database에 대한 권한을 가지고 있는지를 반환합니다.

SELECT has_database_privilege('agens', 'test', 'connect');

결과:

 has_database_privilege 
------------------------
           t
(1 row)

has_database_privilege(database, privilege)
현재 사용자가 database에 대한 권한을 가지고 있는지를 반환합니다.

SELECT has_database_privilege('test', 'connect');

결과:

 has_database_privilege 
------------------------
           t
(1 row)

has_foreign_data_wrapper_privilege(user, fdw, privilege)
사용자가 foreign-data wrapper에 대한 권한을 가지고 있는지를 반환합니다.

CREATE EXTENSION postgres_fdw;

SELECT has_foreign_data_wrapper_privilege('agens', 'postgres_fdw', 'usage');

결과:

 has_foreign_data_wrapper_privilege 
------------------------------------
                 t
(1 row)

has_foreign_data_wrapper_privilege(fdw, privilege)
현재 사용자가 foreign-data wrapper에 대한 권한을 가지고 있는지를 반환합니다.

SELECT has_foreign_data_wrapper_privilege('postgres_fdw', 'usage');

결과:

 has_foreign_data_wrapper_privilege 
------------------------------------
                 t
(1 row)

has_function_privilege(user, function, privilege))
사용자가 function에 대한 권한을 가지고 있는지를 반환합니다.

SELECT has_function_privilege('agens', 'getfoo()', 'execute');

결과:

 has_function_privilege 
------------------------
           t
(1 row)

has_function_privilege(function, privilege)
현재 사용자가 function에 대한 권한을 가지고 있는지를 반환합니다.

SELECT has_function_privilege('getfoo()', 'execute');

결과:

 has_function_privilege 
------------------------
           t
(1 row)

has_language_privilege(user, language, privilege)
사용자가 language에 대한 권한을 가지고 있는지를 반환합니다.

SELECT has_language_privilege('agens', 'c', 'usage');

결과:

 has_language_privilege 
------------------------
           t
(1 row)

has_language_privilege(language, privilege)
현재 사용자가 language에 대한 권한을 가지고 있는지를 반환합니다.

SELECT has_language_privilege('c', 'usage');

결과:

 has_language_privilege 
------------------------
           t
(1 row)     

has_schema_privilege(user, schema, privilege)
사용자가 schema에 대한 권한을 가지고 있는지를 반환합니다.

SELECT has_schema_privilege('agens', 'myschema', 'usage');

결과:

 has_schema_privilege 
----------------------
          t
(1 row)

has_schema_privilege(schema, privilege)
현재 사용자가 schema에 대한 권한을 가지고 있는지를 반환합니다.

SELECT has_schema_privilege('myschema', 'usage');

결과:

 has_schema_privilege 
----------------------
          t
(1 row)

has_sequence_privilege(user, sequence, privilege)
사용자가 sequence에 대한 권한을 가지고 있는지를 반환합니다.

 SELECT has_sequence_privilege('agens', 'serial', 'usage');

결과:

  has_sequence_privilege 
 ------------------------
            t
(1 row)

has_sequence_privilege(sequence, privilege)
사용자가 sequence에 대한 권한을 가지고 있는지를 반환합니다.

SELECT has_sequence_privilege('serial', 'usage');

결과:

  has_sequence_privilege 
 ------------------------
            t
(1 row)

has_server_privilege(user, server, privilege)
사용자가 server에 대한 권한을 가지고 있는지를 반환합니다.

CREATE SERVER app_database_server
FOREIGN DATA WRAPPER postgres_fdw
OPTIONS (host '127.0.0.1', dbname 'agens');

SELECT has_server_privilege('agens', 'app_database_server', 'usage');

결과:

 has_server_privilege 
----------------------
          t
(1 row)

has_server_privilege(server, privilege)
현재 사용자가 server에 대한 권한을 가지고 있는지를 반환합니다.

SELECT has_server_privilege('app_database_server', 'usage');

결과:

 has_server_privilege 
----------------------
          t
(1 row)

has_table_privilege(user, table, privilege)
사용자가 table에 대한 권한을 가지고 있는지를 반환합니다.

SELECT has_table_privilege('agens', 'myschema.mytable', 'SELECT');

결과:

 has_table_privilege 
---------------------
          t
(1 row)

has_table_privilege(table, privilege)
현재 사용자가 table에 대한 권한을 가지고 있는지를 반환합니다.

SELECT has_table_privilege('myschema.mytable', 'SELECT');

결과:

 has_table_privilege 
---------------------
          t
(1 row)

has_tablespace_privilege(user, tablespace, privilege)
사용자가 tablespace에 대한 권한을 가지고 있는지를 반환합니다.

SELECT has_tablespace_privilege('agens', 'pg_default', 'create');

결과:

 has_tablespace_privilege 
--------------------------
             t
(1 row)

has_tablespace_privilege(tablespace, privilege)
현재 사용자가 tablespace에 대한 권한을 가지고 있는지를 반환합니다.

SELECT has_tablespace_privilege('pg_default', 'create');

결과:

 has_tablespace_privilege 
--------------------------
             t
(1 row)

has_type_privilege(user, type, privilege)
사용자가 type에 대한 권한을 가지고 있는지를 반환합니다.

SELECT has_type_privilege('agens', 'rainbow', 'usage');

결과:

 has_type_privilege 
--------------------
         t
(1 row)

has_type_privilege(type, privilege)
현재 사용자가 type에 대한 권한을 가지고 있는지를 반환합니다.

SELECT has_type_privilege('rainbow', 'usage');

결과:

 has_type_privilege 
--------------------
         t
(1 row)

pg_has_role(user, role, privilege)
사용자가 role에 대한 권한을 가지고 있는지를 반환합니다.
```
SELECT pg_has_role('agens', 'agens', 'usage');
```
결과:
```
 pg_has_role 
-------------
      t
(1 row)
```
pg_has_role(role, privilege)
현재 사용자가 role에 대한 권한을 가지고 있는지를 반환합니다.
```
SELECT pg_has_role('agens', 'usage');
```
결과:
```
 pg_has_role 
-------------
      t
(1 row)
```
row_security_active(table)
현재 사용자가 table에 대해 행 수준 보안이 활성화되어 있는지를 반환합니다.
```
SELECT row_security_active('myschema.mytable');
```
결과:
```
 row_security_active 
---------------------
         f
(1 row)
```

pg_collation_is_visible(collation_oid)
collation이 검색 경로에서 보이는지를 반환합니다.

SELECT pg_collation_is_visible(100);

결과:

 pg_collation_is_visible 
-------------------------
            t
(1 row) 

pg_conversion_is_visible(conversion_oid)
conversion이 검색 경로에서 보이는지를 반환합니다.

SELECT pg_conversion_is_visible(12830);

결과:

 pg_conversion_is_visible  
--------------------------
            t
(1 row) 

pg_function_is_visible(function_oid)
function이 검색 경로에서 보이는지를 반환합니다.

SELECT pg_function_is_visible(16716);

결과:

 pg_function_is_visible 
------------------------
            t 
(1 row) 

pg_opclass_is_visible(opclass_oid)
opclass가 검색 경로에서 보이는지를 반환합니다.

SELECT pg_opclass_is_visible(10007);

결과:

 pg_opclass_is_visible 
-----------------------
            t
(1 row) 

pg_operator_is_visible(operator_oid)
operator가 검색 경로에서 보이는지를 반환합니다.

SELECT pg_operator_is_visible(15);

결과:

 pg_operator_is_visible 
------------------------
            t
(1 row) 

pg_opfamily_is_visible(opclass_oid)
opfamily가 검색 경로에서 보이는지를 반환합니다.

SELECT pg_opfamily_is_visible(421);

결과:

 pg_opfamily_is_visible 
------------------------
            t
(1 row) 

pg_table_is_visible(table_oid)
table이 검색 경로에서 보이는지를 반환합니다.

SELECT pg_table_is_visible(16553);

결과:

 pg_table_is_visible 
---------------------
          t
(1 row) 

pg_ts_config_is_visible(config_oid)
텍스트 검색 설정이 검색 경로에서 보이는지를 반환합니다.

SELECT pg_ts_config_is_visible(3748);

결과:

 pg_ts_config_is_visible 
-------------------------
            t
(1 row) 

pg_ts_dict_is_visible(dict_oid)
텍스트 검색 사전이 검색 경로에서 보이는지를 반환합니다.

SELECT pg_ts_dict_is_visible(3765);

결과:

 pg_ts_dict_is_visible 
-----------------------
           t
(1 row) 

pg_ts_parser_is_visible(parser_oid)
텍스트 검색 파서가 검색 경로에서 보이는지를 반환합니다.

SELECT pg_ts_parser_is_visible(3722);

결과:

 pg_ts_parser_is_visible 
-------------------------
             t
(1 row) 

pg_ts_template_is_visible(template_oid)
텍스트 검색 템플릿이 검색 경로에서 보이는지를 반환합니다.

SELECT pg_ts_template_is_visible(3727);

결과:

 pg_ts_template_is_visible 
---------------------------
             t
(1 row) 

pg_type_is_visible(type_oid)
type 또는 domain이 검색 경로에서 보이는지를 반환합니다.

SELECT pg_type_is_visible(16);

결과:

 pg_type_is_visible 
--------------------
          t
(1 row) 

format_type(type_oid, typemod) 데이터 타입의 이름을 가져옵니다.
```
SELECT format_type(16, 1);
```
결과:
```
 format_type 
-------------
   boolean
(1 row) 
```
pg_get_constraintdef(constraint_oid) 제약 조건의 정의를 가져옵니다.
```
SELECT pg_get_constraintdef(13096);
```
결과:
```
 pg_get_constraintdef 
----------------------
 CHECK ((VALUE >= 0))
(1 row) 
```

pg_get_constraintdef(constraint_oid, pretty_bool)
제약 조건의 정의를 가져옵니다.

SELECT pg_get_constraintdef(13096, true);

결과:

 pg_get_constraintdef 
----------------------
 CHECK ((VALUE >= 0))
(1 row) 

pg_get_functiondef(func_oid)
함수의 정의를 가져옵니다.

SELECT pg_get_functiondef(16716);

결과:

             pg_get_functiondef             
--------------------------------------------
 CREATE OR REPLACE FUNCTION public.getfoo()+
 ...
(1 row) 

pg_get_function_arguments(func_oid)
함수 정의의 인자 목록을 가져옵니다(기본값 포함).

SELECT pg_get_function_arguments(16739);

결과:

     pg_get_function_arguments      
------------------------------------
 double precision, double precision
(1 row) 

pg_get_function_identity_arguments(func_oid)
함수를 식별하기 위한 인자 목록을 가져옵니다(기본값 제외).

SELECT pg_get_function_identity_arguments(16739);

결과:

 pg_get_function_identity_arguments 
------------------------------------
 double precision, double precision
(1 row) 

pg_get_function_result(func_oid)
함수의 RETURNS 절을 가져옵니다.

SELECT pg_get_function_result(16739);

결과:

 pg_get_function_result 
------------------------
       float8_range
(1 row) 

pg_get_indexdef(index_oid) 인덱스에 대한 CREATE INDEX 명령을 가져옵니다.

SELECT pg_get_indexdef(828);

결과:

                                 pg_get_indexdef                                  
----------------------------------------------------------------------------------
 CREATE UNIQUE INDEX pg_default_acl_oid_index ON pg_default_acl USING btree (oid)
(1 row) 

pg_get_indexdef(index_oid, column_no, pretty_bool)
인덱스에 대한 CREATE INDEX 명령을 가져오거나, column_no가 0이 아니면 하나의 인덱스 열에 대한 정의만 가져옵니다.
```
SELECT pg_get_indexdef(828, 1, true);
```
결과:
```
 pg_get_indexdef 
-----------------
       oid
(1 row) 
```

pg_get_keywords()
SQL 키워드 목록과 해당 분류를 가져옵니다.

SELECT pg_get_keywords();

결과:

      pg_get_keywords                         
---------------------------
   (abort,U,unreserved)
  (absolute,U,unreserved)
 ...
(434 row) 

pg_get_ruledef(rule_oid)
rule에 대한 CREATE RULE 명령을 가져옵니다.

SELECT pg_get_ruledef(11732);

결과:

            pg_get_ruledef                                        
---------------------------------------
 CREATE RULE "_RETURN" AS  
 ...
(1 row) 

pg_get_ruledef(rule_oid, pretty_bool)
rule에 대한 CREATE RULE 명령을 가져옵니다.

SELECT pg_get_ruledef(11732, true);

결과:

            pg_get_ruledef                                        
---------------------------------------
 CREATE RULE "_RETURN" AS  
 ...
(1 row) 

pg_get_serial_sequence(table_name, column_name)
serial, smallserial, bigserial 열을 사용하는 시퀀스의 이름을 반환합니다.

SELECT pg_get_serial_sequence('serial_t', 'col1');

결과:

  pg_get_serial_sequence  
--------------------------
 public.serial_t_col1_seq
(1 row) 

pg_get_triggerdef(trigger_oid)
트리거에 대한 CREATE [ CONSTRAINT ] TRIGGER 명령을 가져옵니다.

SELECT pg_get_triggerdef(16887);

결과:

                          pg_get_triggerdef   
-------------------------------------------------------------------------
 CREATE TRIGGER tsvectorupdate BEFORE INSERT OR UPDATE ON messages 
 FOR EACH ROW EXECUTE PROCEDURE   
 tsvector_update_trigger_column('tsv', 'configcol', 'title', 'body')
(1 row) 

pg_get_triggerdef(trigger_oid, pretty_bool)
트리거에 대한 CREATE [ CONSTRAINT ] TRIGGER 명령을 가져옵니다.

SELECT pg_get_triggerdef(16887, true);

결과:

                          pg_get_triggerdef   
-------------------------------------------------------------------------
 CREATE TRIGGER tsvectorupdate BEFORE INSERT OR UPDATE ON messages 
 FOR EACH ROW EXECUTE PROCEDURE   
 tsvector_update_trigger_column('tsv', 'configcol', 'title', 'body')
(1 row) 

pg_get_userbyid(role_oid)
주어진 OID를 가진 롤 이름을 가져옵니다.

SELECT pg_get_userbyid(13096);

결과:

 pg_get_userbyid 
-----------------
      agens
(1 row) 

pg_get_viewdef(view_oid)
view 또는 mview에 대한 기반 SELECT 명령을 가져옵니다.

SELECT pg_get_viewdef(17046);

결과:

          pg_get_viewdef           
-----------------------------------
  SELECT pg_class.relname,        +
     pg_class.relnamespace,       +
     ...
    FROM pg_class;
(1 row) 

pg_get_viewdef(view_oid, pretty_bool)
view 또는 mview에 대한 기반 SELECT 명령을 가져옵니다.

SELECT pg_get_viewdef(17046, true);

결과:

          pg_get_viewdef           
-----------------------------------
  SELECT pg_class.relname,        +
     pg_class.relnamespace,       +
     ...
    FROM pg_class;
(1 row) 

pg_get_viewdef(view_oid, wrap_column_int)
view 또는 mview에 대한 기반 SELECT 명령을 가져오며, 필드가 있는 줄을 지정한 열 수에 맞춰 줄바꿈합니다.

SELECT pg_get_viewdef(17046,50);

결과:

                   pg_get_viewdef                    
-----------------------------------------------------
  SELECT pg_class.relname, pg_class.relnamespace,   +
     pg_class.reltype, pg_class.reloftype,          +
     pg_class.relowner, pg_class.relam,             +
     pg_class.relfilenode, pg_class.reltablespace,  +
     pg_class.relpages, pg_class.reltuples,         +
     pg_class.relallvisible, pg_class.reltoastrelid,+
     pg_class.relhasindex, pg_class.relisshared,    +
     pg_class.relpersistence, pg_class.relkind,     +
     pg_class.relnatts, pg_class.relchecks,         +
     pg_class.relhasoids, pg_class.relhaspkey,      +
     pg_class.relhasrules, pg_class.relhastriggers, +
     pg_class.relhassubclass,                       +
     pg_class.relrowsecurity,                       +
     pg_class.relforcerowsecurity,                  +
     pg_class.relispopulated, pg_class.relreplident,+
     pg_class.relfrozenxid, pg_class.relminmxid,    +
     pg_class.relacl, pg_class.reloptions           +
    FROM pg_class;
(1 row) 

pg_index_column_has_property(index_oid, column_no, prop_name)
인덱스 열이 지정한 속성을 가지고 있는지 테스트합니다.

SELECT pg_index_column_has_property(17134, 1, 'orderable');

결과:

 pg_index_column_has_property 
------------------------------
             t
(1 row)

pg_index_has_property(index_oid, prop_name)
인덱스가 지정한 속성을 가지고 있는지 테스트합니다.

SELECT pg_index_has_property(17134, 'clusterable');

결과:

 pg_index_has_property 
-----------------------
          t
(1 row)

pg_indexam_has_property(am_oid, prop_name)
인덱스 접근 방법이 지정한 속성을 가지고 있는지 테스트합니다.

SELECT pg_indexam_has_property(403, 'can_order');

결과:

 pg_indexam_has_property 
-------------------------
          t
(1 row)

pg_options_to_table(reloptions)
스토리지 옵션 집합의 이름/값 쌍을 가져옵니다.

SELECT pg_options_to_table(reloptions) FROM pg_class; 

Result:
   pg_options_to_table   
-------------------------
 (security_barrier,true)
(1 row) 

pg_tablespace_databases(tablespace_oid)
테이블스페이스에 객체가 있는 데이터베이스 OID 집합을 가져옵니다.

SELECT pg_tablespace_databases(1663);

결과:

 pg_tablespace_databases 
-------------------------
                       1
                   13372
                   13373
                   16384
                   16482
(5 row) 

pg_tablespace_location(tablespace_oid)
이 테이블스페이스가 위치한 파일 시스템 경로를 가져옵니다.

SELECT pg_tablespace_location(1663);

결과:

      pg_tablespace_location         
----------------------------------
 /home/agens/AgensGraph/db_cluster
(1 row) 

pg_typeof(any)
임의의 값의 데이터 타입을 가져옵니다.

SELECT pg_typeof(1);

결과:

 pg_typeof 
-----------
  integer
(1 row) 

collation for (any)
인자의 collation을 가져옵니다.

SELECT collation for ('foo' COLLATE "de_DE");

결과:

 pg_collation_for 
------------------
     "de_DE"
(1 row) 

pg_describe_object(catalog_id, object_id, object_sub_id)
데이터베이스 객체의 설명을 가져옵니다.

SELECT pg_describe_object(1255, 16716, 0);

결과:

 pg_describe_object 
--------------------
  function 16716
(1 row) 

pg_identify_object(catalog_id oid, object_id oid, object_sub_id integer)
데이터베이스 객체의 식별 정보를 가져옵니다.

SELECT pg_identify_object(1255, 16716, 0);

결과:

          pg_identify_object          
--------------------------------------
 (function,public,,"public.getfoo()")
(1 row) 

pg_identify_object_as_address(catalog_id oid, object_id oid, object_sub_id integer)
데이터베이스 객체 주소의 외부 표현을 가져옵니다.

SELECT pg_identify_object_as_address(1255, 16716, 0);

결과:

  pg_identify_object_as_address  
---------------------------------
 (function,"{public,getfoo}",{})
(1 row) 

pg_get_object_address(type text, name text[], args text[])
데이터베이스 객체의 외부 표현으로부터 해당 객체의 주소를 가져옵니다.
```
SELECT pg_get_object_address('type', '{public.comp}', '{}');
```
결과:
```
 pg_get_object_address 
-----------------------
     (1247,17063,0)
(1 row) 
```

col_description(table_oid, column_number)
테이블 열에 대한 주석을 가져옵니다.

SELECT col_description(17064, 1);

결과:

 col_description 
-----------------
   code_number
(1 row) 

obj_description(object_oid, catalog_name)
데이터베이스 객체에 대한 주석을 가져옵니다.

SELECT obj_description(16887, 'pg_trigger');

결과:

  obj_description   
--------------------
 comment on trigger
(1 row) 

obj_description(object_oid)
데이터베이스 객체에 대한 주석을 가져옵니다(더 이상 사용되지 않음).
```
SELECT obj_description(16887);
```
결과:
```
  obj_description   
--------------------
 comment on trigger
(1 row) 
```
shobj_description(object_oid, catalog_name)
공유 데이터베이스 객체에 대한 주석을 가져옵니다.
```
SELECT shobj_description(1262,'pg_database');
```
결과:
```
 shobj_description 
-------------------
 
(1 row)
```
txid_current()
현재 트랜잭션 ID를 가져오며, 현재 트랜잭션에 ID가 없으면 새로 할당합니다.
```
SELECT txid_current();
```
결과:
```
 txid_current 
--------------
         2061
(1 row) 
```

txid_current_snapshot()
현재 스냅샷을 가져옵니다.

SELECT txid_current_snapshot();

결과:

 txid_current_snapshot 
-----------------------
      2062:2062:
(1 row) 

txid_snapshot_xip(txid_snapshot)
스냅샷에서 진행 중인 트랜잭션 ID를 가져옵니다.
```
SELECT txid_snapshot_xip('2095:2095:');
```
결과:
```
 txid_snapshot_xip 
-------------------

(1 row)
```

txid_snapshot_xmax(txid_snapshot)
스냅샷의 xmax를 가져옵니다.

SELECT txid_snapshot_xmax('2094:2095:');

결과:

 txid_snapshot_xmax 
--------------------
               2095
(1 row)

txid_snapshot_xmin(txid_snapshot)
스냅샷의 xmin을 가져옵니다.

SELECT txid_snapshot_xmin('2094:2095:');

결과:

 txid_snapshot_xmin 
--------------------
               2094
(1 row)

txid_visible_in_snapshot(bigint, txid_snapshot)
트랜잭션 ID가 스냅샷에서 보이는지를 반환합니다(하위 트랜잭션 ID에는 사용하지 마십시오).
```
SELECT txid_visible_in_snapshot(2099, '2100:2100:');
```
결과:
```
 txid_visible_in_snapshot 
--------------------------
            t
(1 row)
```
pg_xact_commit_timestamp(xid)
트랜잭션의 커밋 타임스탬프를 가져옵니다(track_commit_timestamp 매개변수가 on으로 설정되어 있어야 함).
```
SELECT pg_xact_commit_timestamp('2097'::xid);
```
결과:
```
   pg_xact_commit_timestamp    
-------------------------------
 2017-10-18 13:38:09.738211+09
(1 row)
```
pg_last_committed_xact()
가장 최근에 커밋된 트랜잭션의 트랜잭션 ID와 커밋 타임스탬프를 가져옵니다(track_commit_timestamp 매개변수가 on으로 설정되어 있어야 함).
```
SELECT pg_last_committed_xact();
```
결과:
```
         pg_last_committed_xact         
----------------------------------------
 (2097,"2017-10-18 13:38:09.738211+09")
(1 row)
```

pg_control_checkpoint()
현재 체크포인트 상태에 대한 정보를 반환합니다.

SELECT pg_control_checkpoint();

결과:

                     pg_control_checkpoint                                            
-------------------------------------------------------------------
 (0/1D4B0D0,0/1D4B038,0/1D4B0D0,000000010000000000000001,
 1,1,t,0:2063,24576,1,0,1751,1,0,1,1,0,0,"2017-10-16 16:26:21+09")
(1 row) 

pg_control_system()
현재 컨트롤 파일 상태에 대한 정보를 반환합니다.

SELECT pg_control_system();

결과:

                      pg_control_system                       
--------------------------------------------------------------
 (960,201608131,6469891178207434037,"2017-10-16 16:26:21+09")
(1 row) 

pg_control_init()
클러스터 초기화 상태에 대한 정보를 반환합니다.

SELECT pg_control_init();

결과:

                    pg_control_init                    
-------------------------------------------------------
 (8,8192,131072,8192,16777216,64,32,1996,2048,t,t,t,0)
(1 row) 

pg_control_recovery()
복구 상태에 대한 정보를 반환합니다.

SELECT pg_control_recovery();

결과:

 pg_control_recovery 
---------------------
  (0/0,0,0/0,0/0,f)
(1 row) 

시스템 관리 함수

current_setting(setting_name [, missing_ok ])
설정의 현재 값을 가져옵니다.

SELECT current_setting('datestyle');

결과:

 current_setting 
-----------------
 ISO, YMD
(1 row)      

set_config(setting_name, new_value, is_local)
매개변수를 설정하고 새 값을 반환합니다.

SELECT set_config('log_statement_stats', 'off', false);

결과:

 set_config 
------------
    off
(1 row)      

pg_cancel_backend(pid int)
백엔드의 현재 쿼리를 취소합니다. 호출하는 롤이 해당 백엔드의 롤의 멤버이거나 호출하는 롤에 pg_signal_backend가 부여된 경우에도 허용됩니다. 단, superuser 백엔드는 superuser만 취소할 수 있습니다.
```
SELECT pg_cancel_backend(30819);
Error: Cancel operation by user request.        
```
pg_reload_conf()
서버 프로세스가 설정 파일을 다시 로드하도록 합니다.
```
SELECT pg_reload_conf();
```
결과:
```
 pg_reload_conf 
----------------
       t
(1 row) 
```
pg_rotate_logfile()
로그 파일 관리자에게 즉시 새 로그 파일로 전환하도록 신호를 보냅니다(내장 로그 수집기가 실행 중일 때만 동작함).
```
SELECT pg_rotate_logfile();

 pg_rotate_logfile 
-------------------
         f
(1 row) 
```

pg_terminate_backend(pid int)
백엔드를 종료합니다. 호출하는 롤이 해당 백엔드의 롤의 멤버이거나 호출하는 롤에 pg_signal_backend가 부여된 경우에도 허용됩니다. 단, superuser 백엔드는 superuser만 종료할 수 있습니다.

SELECT pg_terminate_backend(30819);

결과:

Fatal error: Connection is terminated by an administrator request.
             The server suddenly closed the connection.
             This type of processing means the server was abruptly terminated
             while or before processing the client's request.
             The server connection has been lost. Attempt to reconnect: Success.

pg_create_restore_point(name text)
복원을 수행하기 위한 명명된 지점을 생성합니다(기본적으로 superuser로 제한되지만, 다른 사용자에게 함수를 실행할 EXECUTE 권한을 부여할 수 있음).
```
SELECT pg_create_restore_point( 'important_moment' );
```
결과:
```
 pg_create_restore_point 
-------------------------
       0/1D72DC0
(1 row)
```

pg_current_xlog_flush_location()
트랜잭션 로그 플러시 위치를 반환합니다.

SELECT pg_current_xlog_flush_location();

결과:

 pg_current_xlog_flush_location 
---------------------------------
            0/1D72ED8
(1 row)

pg_current_xlog_insert_location()
현재 트랜잭션 로그 삽입 위치를 반환합니다.

SELECT pg_current_xlog_insert_location();

결과:

 pg_current_xlog_insert_location 
---------------------------------
            0/1D72ED8
(1 row)

pg_current_xlog_location()
현재 트랜잭션 로그 쓰기 위치를 반환합니다.

SELECT pg_current_xlog_location();

결과:

 pg_current_xlog_location 
--------------------------
         0/1D72ED8
(1 row)

pg_start_backup(label text [, fast boolean [, exclusive boolean ]])
온라인 백업을 수행할 준비를 합니다(기본적으로 superuser로 제한되지만, 다른 사용자에게 함수를 실행할 EXECUTE 권한을 부여할 수 있음).
```
SELECT pg_start_backup('my_backup', true, false);
```
결과:
```
 pg_start_backup 
-----------------
     0/2000028
(1 row)
```

pg_stop_backup()
배타적 온라인 백업 수행을 완료합니다(기본적으로 superuser로 제한되지만, 다른 사용자에게 함수를 실행할 EXECUTE 권한을 부여할 수 있음).

SELECT pg_stop_backup();

결과:

NOTICE: The pg_stop_backup operation is finished. 
        All necessary WAL pieces have been archived.    
 pg_stop_backup    
----------------
 (0/50000F8,,)
(1 row) 

pg_stop_backup(exclusive boolean)
배타적 또는 비배타적 온라인 백업 수행을 완료합니다(기본적으로 superuser로 제한되지만, 다른 사용자에게 함수를 실행할 EXECUTE 권한을 부여할 수 있음).

SELECT pg_stop_backup(false);

결과:

NOTICE:  WAL archiving is not enabled; you must ensure that all required WAL 
         segments are copied through other means to complete the backup

                              pg_stop_backup                               
---------------------------------------------------------------------------
 (0/3000088,"START WAL LOCATION: 0/2000028 (file 000000010000000000000002)+
 CHECKPOINT LOCATION: 0/2000060                                           +
 BACKUP METHOD: streamed                                                  +
 BACKUP FROM: master                                                      +
 START TIME: 2017-10-17 10:00:18 KST                                      +
 LABEL: my_backup                                                         +
 ","17060 /home/agens/AgensGraph/db_cluster/data                          +
 ")
(1 row) 

pg_is_in_backup()
온라인 배타적 백업이 아직 진행 중이면 true를 반환합니다.
```
SELECT pg_is_in_backup();
```
결과:
```
 pg_is_in_backup 
-----------------
        t
(1 row) 
```

pg_backup_start_time()
진행 중인 온라인 배타적 백업의 시작 시간을 가져옵니다.

SELECT pg_backup_start_time();

결과:

  pg_backup_start_time  
------------------------
 2017-10-17 10:29:26+09
(1 row) 

pg_switch_xlog()
새 트랜잭션 로그 파일로 강제 전환합니다(기본적으로 superuser로 제한되지만, 다른 사용자에게 함수를 실행할 EXECUTE 권한을 부여할 수 있음).
```
SELECT pg_switch_xlog();
```
결과:
```
 pg_switch_xlog 
----------------
    0/9000120
(1 row) 
```

pg_xlogfile_name(location pg_lsn)
트랜잭션 로그 위치 문자열을 파일 이름으로 변환합니다.

SELECT pg_xlogfile_name('0/9000028');

결과:

     pg_xlogfile_name     
--------------------------
 000000010000000000000009
(1 row) 

pg_xlogfile_name_offset(location pg_lsn)
트랜잭션 로그 위치 문자열을 파일 이름과 파일 내 10진수 바이트 오프셋으로 변환합니다.

SELECT pg_xlogfile_name_offset('0/9000028');

결과:

    pg_xlogfile_name_offset    
-------------------------------
 (000000010000000000000009,40)
(1 row) 

pg_xlog_location_diff(location pg_lsn, location pg_lsn)
두 트랜잭션 로그 위치 사이의 차이를 계산합니다.
```
SELECT pg_xlog_location_diff('0/9000120', '0/9000028');
```
결과:
```
 pg_xlog_location_diff 
-----------------------
(1 row) 
```
pg_is_in_recovery() 복구가 아직 진행 중이면 true를 반환합니다.
```
SELECT pg_is_in_recovery();
```
결과:
```
 pg_is_in_recovery 
-------------------
        t                 
(1 row) 
```
pg_last_xlog_receive_location()
스트리밍 복제에 의해 수신되어 디스크에 동기화된 마지막 트랜잭션 로그 위치를 가져옵니다. 스트리밍 복제가 진행 중인 동안에는 단조 증가합니다. 복구가 완료되면 복구 중에 수신되어 디스크에 동기화된 마지막 WAL 레코드의 값으로 고정됩니다. 스트리밍 복제가 비활성화되어 있거나 아직 시작되지 않은 경우 이 함수는 NULL을 반환합니다.
```
SELECT pg_last_xlog_receive_location();
```
결과:
```
 pg_last_xlog_receive_location 
-------------------------------

(1 row) 
```
pg_last_xlog_replay_location()
복구 중에 재생된 마지막 트랜잭션 로그 위치를 가져옵니다. 복구가 아직 진행 중이면 단조 증가합니다. 복구가 완료되면 이 값은 해당 복구 중에 적용된 마지막 WAL 레코드의 값으로 고정됩니다. 서버가 복구 없이 정상적으로 시작된 경우 이 함수는 NULL을 반환합니다.
```
SELECT pg_last_xlog_replay_location();
```
결과:
```
 pg_last_xlog_replay_location 
------------------------------

(1 row) 
```
pg_last_xact_replay_timestamp()
복구 중에 재생된 마지막 트랜잭션의 타임스탬프를 가져옵니다. 이는 해당 트랜잭션의 커밋 또는 중단 WAL 레코드가 주(primary) 서버에서 생성된 시간입니다. 복구 중에 재생된 트랜잭션이 없으면 이 함수는 NULL을 반환합니다. 그렇지 않고 복구가 아직 진행 중이면 단조 증가합니다. 복구가 완료되면 이 값은 해당 복구 중에 적용된 마지막 트랜잭션의 값으로 고정됩니다. 서버가 복구 없이 정상적으로 시작된 경우 이 함수는 NULL을 반환합니다.
```
SELECT pg_last_xact_replay_timestamp();
```
결과:
```
 pg_last_xact_replay_timestamp 
-------------------------------
 
(1 row) 
```

pg_export_snapshot()
현재 스냅샷을 저장하고 그 식별자를 반환합니다.

SELECT pg_export_snapshot();

결과:

 pg_export_snapshot 
--------------------
     00000816-1
(1 row)

pg_create_physical_replication_slot(slot_name name [, immediately_reserve boolean ])
slot_name이라는 이름의 새 물리적 복제 슬롯을 생성합니다. 선택적인 두 번째 매개변수가 true이면 이 복제 슬롯의 LSN을 즉시 예약하도록 지정합니다. 그렇지 않으면 스트리밍 복제 클라이언트의 첫 연결 시 LSN이 예약됩니다. 물리적 슬롯에서 변경 사항을 스트리밍하는 것은 스트리밍 복제 프로토콜로만 가능합니다(자세한 기술 정보는 이 링크를 참조). 이 함수는 복제 프로토콜 명령 CREATE_REPLICATION_SLOT ... PHYSICAL에 해당합니다.
```
SELECT pg_create_physical_replication_slot('test_slot', 'true');
```
결과:
```
 pg_create_physical_replication_slot 
-------------------------------------
        (test_slot,0/D000220)
(1 row)
```
pg_drop_replication_slot(slot_name name)
slot_name이라는 이름의 물리적 또는 논리적 복제 슬롯을 삭제합니다. 복제 프로토콜 명령
DROP_REPLICATION_SLOT과 동일합니다.
```
SELECT pg_drop_replication_slot('test_slot');
```
결과:
```
 pg_drop_replication_slot 
--------------------------

(1 row)
```
pg_create_logical_replication_slot(slot_name name, plugin name)
출력 plugin 플러그인을 사용하여 slot_name이라는 이름의 새 논리적(디코딩) 복제 슬롯을 생성합니다. 이 함수를 호출하는 것은 복제 프로토콜 명령 CREATE_REPLICATION_SLOT ... LOGICAL과 동일한 효과를 가집니다.
```
SELECT pg_create_logical_replication_slot('test_slot', 'test_decoding');
```
결과:
```
 pg_create_logical_replication_slot 
------------------------------------
       (test_slot,0/D000338)
(1 row)
```
pg_logical_slot_get_changes(slot_name name, upto_lsn pg_lsn, upto_nchanges int, VARIADIC options text[])
변경 사항이 마지막으로 소비된 지점부터 시작하여 slot_name 슬롯의 변경 사항을 반환합니다. upto_lsn과 upto_nchanges가 NULL이면 논리적 디코딩은 WAL의 끝까지 계속됩니다. upto_lsn이 NULL이 아니면 디코딩은 지정한 LSN 이전에 커밋되는 트랜잭션만 포함합니다.
upto_nchanges가 NULL이 아니면 디코딩에 의해 생성되는 행 수가 지정한 값을 초과할 때 디코딩이 중지됩니다. 단, 이 제한은 각 새 트랜잭션 커밋을 디코딩할 때 생성된 행을 추가한 후에만 확인되므로 실제로 반환되는 행 수는 더 많을 수 있습니다.
```
SELECT pg_logical_slot_get_changes('regression_slot',null, null);
```
결과:
```
  pg_logical_slot_get_changes   
--------------------------------
 (0/F000190,2079,"BEGIN 2079")
 (0/F028360,2079,"COMMIT 2079")
(2 row) 
```

pg_logical_slot_peek_changes(slot_name name, upto_lsn pg_lsn, upto_nchanges int, VARIADIC options text[])
pg_logical_slot_get_changes() 함수와 똑같이 동작하지만, 변경 사항이 소비되지 않는 점이 다릅니다.

SELECT pg_logical_slot_peek_changes('regression_slot',null, null);

결과:

                        pg_logical_slot_peek_changes                        
----------------------------------------------------------------------------
 (0/F028398,2080,"BEGIN 2080")
 (0/F028468,2080,"table public.data: INSERT: id[integer]:1 data[text]:'3'")
 (0/F028568,2080,"COMMIT 2080")
(3 row) 

pg_logical_slot_get_binary_changes(slot_name name, upto_lsn pg_lsn, upto_nchanges int, VARIADIC options text[])
pg_logical_slot_get_changes() 함수와 똑같이 동작하지만, 변경 사항이 bytea로 반환되는 점이 다릅니다.

SELECT pg_logical_slot_get_binary_changes('regression_slot',null, null);

결과:

               pg_logical_slot_get_binary_changes
--------------------------------------------------------------------
 (0/F028398,2080,"\\x424547494e2032303830")
 (0/F028468,2080,"\\x7461626c65207075626c69632e646174613a20494e5345
 52543a2069645b696e74656765725d3a3120646174615b746578745d3a273327")
 (0/F028568,2080,"\\x434f4d4d49542032303830")
(3 row) 

pg_logical_slot_peek_binary_changes(slot_name name, upto_lsn pg_lsn, upto_nchanges int, VARIADIC options text[])
pg_logical_slot_get_changes() 함수와 똑같이 동작하지만, 변경 사항이 bytea로 반환되고 변경 사항이 소비되지 않는 점이 다릅니다.

SELECT pg_logical_slot_peek_binary_changes('regression_slot',null, null);

결과:

               pg_logical_slot_peek_binary_changes
--------------------------------------------------------------------
 (0/F028398,2080,"\\x424547494e2032303830")
 (0/F028468,2080,"\\x7461626c65207075626c69632e646174613a20494e5345
 52543a2069645b696e74656765725d3a3120646174615b746578745d3a273327")
 (0/F028568,2080,"\\x434f4d4d49542032303830")
(3 row) 

pg_replication_origin_create(node_name text)
주어진 외부 이름으로 복제 오리진을 생성하고, 거기에 할당된 내부 id를 반환합니다.

SELECT pg_replication_origin_create('test_decoding: regression_slot');

결과:

 pg_replication_origin_create 
------------------------------
                            1
(1 row) 

pg_replication_origin_drop(node_name text)
이전에 생성된 복제 오리진을 관련된 모든 재생 진행 상황을 포함하여 삭제합니다.
```
SELECT pg_replication_origin_drop('test_decoding: temp');
```
결과:
```
 pg_replication_origin_drop 
----------------------------
 
(1 row)
```
pg_replication_origin_oid(node_name text)
이름으로 복제 오리진을 조회하여 내부 id를 반환합니다. 해당하는 복제 오리진을 찾지 못하면 오류가 발생합니다.
```
SELECT pg_replication_origin_oid('test_decoding: temp');
```
결과:
```
 pg_replication_origin_oid 
---------------------------
                         2
(1 row)
```
pg_replication_origin_session_setup(node_name text)
현재 세션을 주어진 오리진에서 재생하는 것으로 표시하여 재생 진행 상황을 추적할 수 있게 합니다.
되돌리려면 pg_replication_origin_session_reset을 사용하십시오. 이전에 설정된 오리진이 없는 경우에만 사용할 수 있습니다.
```
SELECT pg_replication_origin_session_setup('test_decoding: regression_slot');
```
결과:
```
 pg_replication_origin_session_setup 
-------------------------------------
 
(1 row)
```

pg_replication_origin_session_reset()
pg_replication_origin_session_setup()의 설정을 취소합니다.

SELECT pg_replication_origin_session_reset();

결과:

 pg_replication_origin_session_reset 
-------------------------------------
 
(1 row)

pg_replication_origin_session_is_setup()
현재 세션에 복제 오리진이 설정되어 있는지를 반환합니다.

SELECT pg_replication_origin_session_is_setup();

결과:

 pg_replication_origin_session_is_setup 
----------------------------------------
                  t
(1 row)

pg_replication_origin_session_progress(flush bool)
현재 세션에 설정된 복제 오리진의 재생 위치를 반환합니다. 매개변수 flush는 해당 로컬 트랜잭션이 디스크에 플러시되었음을 보장할지 여부를 결정합니다.
```
SELECT pg_replication_origin_session_progress(false);
```
결과:
```
 pg_replication_origin_session_progress 
----------------------------------------
              0/AABBCCDD
(1 row)
```
pg_replication_origin_xact_setup(origin_lsn pg_lsn, origin_timestamp timestamptz)
현재 트랜잭션을 주어진 LSN과 타임스탬프에 커밋된 트랜잭션을 재생하는 것으로 처리합니다. pg_replication_origin_session_setup()을 사용하여 복제 오리진이 이전에 설정된 경우에만 호출할 수 있습니다.
```
SELECT pg_replication_origin_xact_setup('0/AABBCCDD', '2017-01-01 00:00');
```
결과:
```
 pg_replication_origin_xact_setup 
----------------------------------

(1 row)
```

pg_replication_origin_xact_reset()
pg_replication_origin_xact_setup()의 설정을 취소합니다.

SELECT pg_replication_origin_xact_reset();

결과:

 pg_replication_origin_xact_reset 
----------------------------------

(1 row)

pg_replication_origin_advance(node_name text, pos pg_lsn)
주어진 노드의 복제 진행 상황을 주어진 위치로 설정합니다. 이는 주로 초기 위치를 설정하거나 설정 변경 등 이후의 새 위치를 설정하는 데 유용합니다. 이 함수를 부주의하게 사용하면 데이터가 일관성 없이 복제될 수 있음에 유의하십시오.
```
SELECT pg_replication_origin_advance('test_decoding: regression_slot', '0/1');
```
결과:
```
 pg_replication_origin_advance 
-------------------------------
 
(1 row)
```
pg_replication_origin_progress(node_name text, flush bool)
주어진 복제 오리진의 재생 위치를 반환합니다. 매개변수 flush는 해당 로컬 트랜잭션이 디스크에 플러시되었음을 보장할지 여부를 결정합니다.
```
SELECT pg_replication_origin_progress('test_decoding: temp', true);
```
결과:
```
 pg_replication_origin_progress 
--------------------------------
           0/AABBCCDD
(1 row)           
```
pg_logical_emit_message(transactional bool, prefix text, content text) 텍스트 논리적 디코딩 메시지를 발행합니다. 이는 WAL을 통해 논리적 디코딩 플러그인에 일반 메시지를 전달하는 데 사용할 수 있습니다. 매개변수 transactional은 메시지가 현재 트랜잭션의 일부가 되어야 할지, 아니면 즉시 기록되어 논리적 디코딩이 레코드를 읽는 즉시 디코딩되어야 할지를 지정합니다. prefix는 논리적 디코딩 플러그인이 관심 있는 메시지를 쉽게 인식하는 데 사용하는 텍스트 prefix입니다. content는 메시지의 텍스트입니다.
```
SELECT pg_logical_emit_message(false, 'test', 'this message will not be decoded');
```
결과:
```
 pg_logical_emit_message 
-------------------------
        0/F05E1D0
(1 row)           
```
pg_logical_emit_message(transactional bool, prefix text, content bytea)
바이너리 논리적 디코딩 메시지를 발행합니다. 이는 WAL을 통해 논리적 디코딩 플러그인에 일반 메시지를 전달하는 데 사용할 수 있습니다. 매개변수 transactional은 메시지가 현재 트랜잭션의 일부가 되어야 할지, 아니면 즉시 기록되어 논리적 디코딩이 레코드를 읽는 즉시 디코딩되어야 할지를 지정합니다. prefix는 논리적 디코딩 플러그인이 관심 있는 메시지를 쉽게 인식하는 데 사용하는 텍스트 prefix입니다. content는 메시지의 바이너리 콘텐츠입니다.
```
SELECT pg_logical_emit_message(false, 'test', '0/F05E1D0');
```
결과:
```
 pg_logical_emit_message 
-------------------------
        0/F05E2C8
(1 row)           
```

pg_column_size(any)
특정 값을 저장하는 데 사용되는 바이트 수를 반환합니다.

SELECT pg_column_size('SELECT fooid FROM foo');

결과:

 pg_column_size 
----------------
             22
(1 row)

pg_database_size(oid) 지정한 OID를 가진 데이터베이스가 사용하는 디스크 공간을 반환합니다.
```
SELECT pg_database_size(16482);
```
결과:
```
 pg_database_size 
------------------
          9721508
(1 row)
```
pg_database_size(name)
지정한 이름을 가진 데이터베이스가 사용하는 디스크 공간을 반환합니다.
```
SELECT pg_database_size('test');
```
결과:
```
 pg_database_size 
------------------
          9721508
(1 row)
```
pg_indexes_size(regclass) 지정한 테이블에 연결된 인덱스가 사용하는 전체 디스크 공간을 반환합니다.
```
SELECT pg_indexes_size(2830);
```
결과:
```
 pg_indexes_size 
-----------------
            8192
(1 row)
```
pg_relation_size(relation regclass, fork text)
지정한 테이블 또는 인덱스의 지정한 포크(‘main’, ‘fsm’, ‘vm’, ‘init’)가 사용하는 디스크 공간을 반환합니다.
```
SELECT  pg_relation_size(16881, 'main');
```
결과:
```
 pg_relation_size 
------------------
                0
(1 row)
```

pg_relation_size(relation regclass)
pg_relation_size(..., 'main')의 단축 형태입니다.

SELECT  pg_relation_size(16881);

결과:

 pg_relation_size 
------------------
                0
(1 row)

pg_size_bytes(text)
크기 단위가 포함된 사람이 읽기 쉬운 형식의 크기를 바이트로 변환합니다.
```
SELECT pg_size_bytes('100');
```
결과:
```
 pg_size_bytes 
---------------
           100
(1 row)
```
pg_size_pretty(bigint)
64비트 정수로 표현된 바이트 단위 크기를 크기 단위가 포함된 사람이 읽기 쉬운 형식으로 변환합니다.
```
SELECT pg_size_pretty(10::bigint);
```
결과:
```
 pg_size_pretty 
----------------
       10 bytes
(1 row)
```
pg_size_pretty(numeric)
numeric 값으로 표현된 바이트 단위 크기를 크기 단위가 포함된 사람이 읽기 쉬운 형식으로 변환합니다.
```
SELECT pg_size_pretty(10::numeric);
```
결과:
```
 pg_size_pretty 
----------------
       10 bytes
(1 row)
```
pg_table_size(regclass)
지정한 테이블이 사용하는 디스크 공간을 인덱스를 제외하고 반환합니다(단, TOAST, 여유 공간 맵, 가시성 맵은 포함).
```
SELECT pg_table_size('myschema.mytable');
```
결과:
```
 pg_table_size 
---------------
          8192
(1 row)
```
pg_tablespace_size(oid)
지정한 OID를 가진 테이블스페이스가 사용하는 디스크 공간을 반환합니다.
```
SELECT pg_tablespace_size(1663);
```
결과:
```
 pg_tablespace_size 
--------------------
           40859636
(1 row)
```
pg_tablespace_size(name)
지정한 이름을 가진 테이블스페이스가 사용하는 디스크 공간을 반환합니다.
```
SELECT pg_tablespace_size('pg_default');
```
결과:
```
 pg_tablespace_size 
--------------------
           40859636
(1 row)
```
pg_total_relation_size(regclass)
지정한 테이블이 사용하는 전체 디스크 공간을 모든 인덱스와 TOAST 데이터를 포함하여 반환합니다.
```
SELECT  pg_total_relation_size(16881);
```
결과:
```
 pg_total_relation_size 
------------------------
                   8192
(1 row)
```

pg_relation_filenode(relation regclass)
지정한 릴레이션의 filenode 번호를 반환합니다.

SELECT pg_relation_filenode('pg_database');

결과:

 pg_relation_filenode 
----------------------
                 1262
(1 row)

pg_relation_filepath(relation regclass)
지정한 릴레이션의 파일 경로 이름을 반환합니다.

SELECT pg_relation_filepath('pg_database');

결과:

 pg_relation_filepath 
----------------------
          global/1262
(1 row)

pg_filenode_relation(tablespace oid, filenode oid)
주어진 테이블스페이스와 filenode에 연관된 릴레이션을 찾습니다.
```
SELECT pg_filenode_relation(1663, 16485);
```
결과:
```
 pg_filenode_relation 
----------------------
  test.ag_label_seq
(1 row)
```

brin_summarize_new_values(index regclass)
아직 요약되지 않은 페이지 범위를 요약합니다.

SELECT brin_summarize_new_values('brinidx');

결과:

 brin_summarize_new_values 
---------------------------
                         0
(1 row)

gin_clean_pending_list(index regclass)
GIN 보류 목록 항목을 메인 인덱스 구조로 이동합니다.

SELECT gin_clean_pending_list('gin_test_idx');

결과:

 gin_clean_pending_list 
------------------------
                      0
(1 row)

pg_ls_dir(dirname text [, missing_ok boolean, include_dot_dirs boolean])
디렉터리의 내용을 나열합니다.

SELECT pg_ls_dir('.');

결과:

      pg_ls_dir       
----------------------
 pg_xlog
 global
 ...
(28 row)

pg_read_file(filename text [, offset bigint, length bigint [, missing_ok boolean] ])
텍스트 파일의 내용을 반환합니다.
```
SELECT pg_read_file('test.sql');
```
결과:
```
 pg_read_file 
--------------
 test        +
(1 row)
```
pg_read_binary_file(filename text [, offset bigint, length bigint [, missing_ok boolean] ])
파일의 내용을 반환합니다.
```
SELECT pg_read_binary_file('test');
```
결과:
```
 pg_read_binary_file 
---------------------
     x6161610a       
(1 row)
```

pg_stat_file(filename text[, missing_ok boolean])
파일에 대한 정보를 반환합니다.

SELECT pg_stat_file('test');

결과:

                                   pg_stat_file                                    
-----------------------------------------------------------------------------------
 (4,"2017-10-18 11:05:09+09","2017-10-18 11:04:55+09","2017-10-18 11:04:55+09",,f)
(1 row)

pg_advisory_lock(key bigint)
배타적 세션 수준 advisory lock을 획득합니다.

SELECT pg_advisory_lock(1);
SELECT locktype, classid, objid, mode FROM pg_locks where objid=1;

결과:

 locktype | classid | objid |     mode      
----------+---------+-------+---------------
 advisory |       0 |     1 | ExclusiveLock
(1 row)

pg_advisory_lock(key1 int, key2 int)
배타적 세션 수준 advisory lock을 획득합니다.

SELECT pg_advisory_lock(1,2);
SELECT locktype, classid, objid, mode FROM pg_locks where objid=2;

결과:

 locktype | classid | objid |     mode      
----------+---------+-------+---------------
 advisory |       1 |     2 | ExclusiveLock
(1 row)

pg_advisory_lock_shared(key bigint)
공유 세션 수준 advisory lock을 획득합니다.

SELECT pg_advisory_lock_shared(10);
SELECT locktype, classid, objid, mode FROM pg_locks where objid=10;

결과:

 locktype | classid | objid |   mode    
----------+---------+-------+-----------
 advisory |       0 |    10 | ShareLock
(1 row)

pg_advisory_lock_shared(key1 int, key2 int)
공유 세션 수준 advisory lock을 획득합니다.

SELECT pg_advisory_lock_shared(10,20);
SELECT locktype, classid, objid, mode FROM pg_locks where objid=20;

결과:

 locktype | classid | objid |   mode    
----------+---------+-------+-----------
 advisory |      10 |    20 | ShareLock
(1 row)

pg_advisory_unlock(key bigint)
배타적 세션 수준 advisory lock을 해제합니다.

SELECT pg_advisory_unlock(1);

결과:

 pg_advisory_unlock 
--------------------
         t
(1 row)

pg_advisory_unlock(key1 int, key2 int)
배타적 세션 수준 advisory lock을 해제합니다.

SELECT pg_advisory_unlock(1,2);

결과:

 pg_advisory_unlock 
--------------------
         t
(1 row)

pg_advisory_unlock_all()
현재 세션이 보유한 모든 세션 수준 advisory lock을 해제합니다.
```
SELECT pg_advisory_unlock_all();
```
결과:
```
 pg_advisory_unlock_all 
------------------------
 
(1 row)
```

pg_advisory_unlock_shared(key bigint)
공유 세션 수준 advisory lock을 해제합니다.

SELECT pg_advisory_unlock_shared(10);

결과:

 pg_advisory_unlock_shared 
---------------------------
             t
(1 row)

pg_advisory_unlock_shared(key1 int, key2 int)
공유 세션 수준 advisory lock을 해제합니다.

SELECT pg_advisory_unlock_shared(10,20);

결과:

 pg_advisory_unlock_shared 
---------------------------
             t
(1 row)

pg_advisory_xact_lock(key bigint)
배타적 트랜잭션 수준 advisory lock을 획득합니다.

SELECT pg_advisory_xact_lock(1);

결과:

 pg_advisory_xact_lock 
------------------------
           
(1 row)

pg_advisory_xact_lock(key1 int, key2 int)
배타적 트랜잭션 수준 advisory lock을 획득합니다.

SELECT pg_advisory_xact_lock(1,2);

결과:

 pg_advisory_xact_lock 
------------------------
           
(1 row)

pg_advisory_xact_lock_shared(key bigint)
공유 트랜잭션 수준 advisory lock을 획득합니다.

SELECT pg_advisory_xact_lock_shared(10);

결과:

 pg_advisory_xact_lock_shared 
------------------------------
           
(1 row)

pg_advisory_xact_lock_shared(key1 int, key2 int)
공유 트랜잭션 수준 advisory lock을 획득합니다.

SELECT pg_advisory_xact_lock_shared(10,20);

결과:

 pg_advisory_xact_lock_shared 
------------------------------
           
(1 row)

pg_try_advisory_lock(key bigint)
사용 가능하면 배타적 세션 수준 advisory lock을 획득합니다.

SELECT pg_try_advisory_lock(100);

결과:

 pg_try_advisory_lock 
----------------------
          t
(1 row)

pg_try_advisory_lock(key1 int, key2 int)
사용 가능하면 배타적 세션 수준 advisory lock을 획득합니다.
```
SELECT pg_try_advisory_lock(100,200);
```
결과:
```
 pg_try_advisory_lock 
----------------------
          t
(1 row)
```

pg_try_advisory_lock_shared(key bigint)
사용 가능하면 공유 세션 수준 advisory lock을 획득합니다.

SELECT pg_try_advisory_lock_shared(1000);

결과:

 pg_try_advisory_lock_shared 
-----------------------------
              t
(1 row)

pg_try_advisory_lock_shared(key1 int, key2 int)
사용 가능하면 공유 세션 수준 advisory lock을 획득합니다.

SELECT pg_try_advisory_lock_shared(1000,2000);

결과:

 pg_try_advisory_lock_shared 
-----------------------------
              t
(1 row)

pg_try_advisory_xact_lock(key bigint)
사용 가능하면 배타적 트랜잭션 수준 advisory lock을 획득합니다.

SELECT pg_try_advisory_xact_lock(1000);

결과:

 pg_try_advisory_xact_lock 
---------------------------
             t
(1 row)

pg_try_advisory_xact_lock(key1 int, key2 int)
사용 가능하면 배타적 트랜잭션 수준 advisory lock을 획득합니다.

SELECT pg_try_advisory_xact_lock(1000,2000);

결과:

 pg_try_advisory_xact_lock 
---------------------------
             t
(1 row)

pg_try_advisory_xact_lock_shared(key bigint)
사용 가능하면 공유 트랜잭션 수준 advisory lock을 획득합니다.

SELECT pg_try_advisory_xact_lock_shared(10000);

결과:

 pg_try_advisory_xact_lock_shared 
----------------------------------
                t
(1 row)

pg_try_advisory_xact_lock_shared(key1 int, key2 int)
사용 가능하면 공유 트랜잭션 수준 advisory lock을 획득합니다.

SELECT pg_try_advisory_xact_lock_shared(10000,20000);

결과:

 pg_try_advisory_xact_lock_shared 
----------------------------------
                t
(1 row)

사용자 정의 함수

AgensGraph에서는 필요한 함수를 생성하여 사용할 수 있습니다.

AgensGraph는 SQL과 Cypher 쿼리 구문을 동시에 사용할 수 있으므로 이를 활용하여 함수를 쉽게 생성할 수 있으며, 생성된 함수는 \df 명령으로 확인할 수 있습니다. 생성된 함수는 SELECT 또는 RETURN 구문을 사용하여 호출할 수도 있습니다.

사용자 정의 함수의 생성 및 문법에 대한 자세한 내용은 PostgreSQL 문서를 참조하십시오.

사용자 정의 함수

CREATE FUNCTION func_name (integer, integer) RETURNS integer
    AS 'SELECT $1 + $2;'
    LANGUAGE SQL
    IMMUTABLE
    RETURNS NULL ON NULL INPUT;
    
SELECT func_name (1, 1);

결과:

 add 
-----
   2
(1 row)  

RETURN func_name (1, 1);

결과:

 add 
-----
   2
(1 row) 

DROP FUNCTION func_name (integer, integer);