* (MULTIPLICATION)
구문
expr1 * expr2
설명
expr1과 expr2의 곱하기 연산 결과를 반환한다.
곱하기 연산의 종류와 결과 타입은 다음 표와 같다. 자세한 내용은 타입간 변환을 참조한다.
expr1 (expr2) | expr2 (expr1) | 결과 타입 |
|---|---|---|
NATIVE INTEGER 계열
| NATIVE INTEGER 계열
| NATIVE_BIGINT |
NUMBER | NUMBER | NUMBER |
NATIVE DOUBLE 계열
| NATIVE DOUBLE 계열
| NATIVE_DOUBLE |
expr1 (expr2) | expr2 (expr1) | 결과 타입 |
|---|---|---|
INTERVAL YEAR TO MONTH | 숫자형 타입 | INTERVAL YEAR TO MONTH (결과 타입은 interval type 이다.) |
INTERVAL DAY TO SECOND | 숫자형 타입 | INTERVAL DAY TO SECOND (결과 타입은 interval type 이다.) |
자세한 내용은 표에 표기된 INTERVAL 타입이 포함하는 INTERVAL 세부타입 을 참조한다. | ||
INTERVAL YEAR TO MONTH | INTERVAL DAY TO SECOND |
|---|---|
|
|
사용 예
gSQL> SELECT INTERVAL'1-2'YEAR TO MONTH * 2 AS RESULT FROM DUAL;
RESULT
----------
+000002-04
1 row selected.
gSQL> SELECT INTERVAL'1 01:02:03.400000'DAY TO SECOND * 2 AS RESULT
FROM DUAL;
RESULT
-----------------------
+000002 02:04:06.800000
1 row selected.+ (ADDITION)
구문
expr1 + expr2
설명
expr1과 expr2의 더하기 연산 결과를 반환한다.
더하기 연산의 종류와 결과 타입은 다음 표와 같다. 자세한 내용은 타입간 변환을 참조한다.
expr1 (expr2) | expr2 (expr1) | 결과 타입 |
|---|---|---|
NATIVE INTEGER 계열
| NATIVE INTEGER 계열
| NATIVE_BIGINT |
NUMBER | NUMBER | NUMBER |
NATIVE DOUBLE 계열
| NATIVE DOUBLE 계열
| NATIVE_DOUBLE |
expr1 (expr2) | expr2 (expr1) | 결과 타입 |
|---|---|---|
DATE | NUMERIC | DATE |
DATE | INTERVAL YEAR TO MONTH | DATE |
DATE | INTERVAL DAY | DATE |
DATE | INTERVAL DAY TO SECOND | TIMESTAMP |
TIME | NUMERIC | TIME |
TIME | INTERVAL YEAR TO MONTH | TIME |
TIME | INTERVAL DAY TO SECOND | TIME |
TIME WITH TIME ZONE | NUMERIC | TIME WITH TIME ZONE |
TIME WITH TIME ZONE | INTERVAL YEAR TO MONTH | TIME WITH TIME ZONE |
TIME WITH TIME ZONE | INTERVAL DAY TO SECOND | TIME WITH TIME ZONE |
TIMESTAMP | NUMERIC | TIMESTAMP |
TIMESTAMP | INTERVAL YEAR TO MONTH | TIMESTAMP |
TIMESTAMP | INTERVAL DAY TO SECOND | TIMESTAMP |
TIMESTAMP WITH TIME ZONE | NUMERIC | TIMESTAMP WITH TIME ZONE |
TIMESTAMP WITH TIME ZONE | INTERVAL YEAR TO MONTH | TIMESTAMP WITH TIME ZONE |
TIMESTAMP WITH TIME ZONE | INTERVAL DAY TO SECOND | TIMESTAMP WITH TIME ZONE |
INTERVAL YEAR TO MONTH | INTERVAL YEAR TO MONTH | INTERVAL YEAR TO MONTH (expr1과 expr2의 interval 범위를 모두 포함할 수 있는 타입으로 결정된다.) |
INTERVAL DAY TO SECOND | INTERVAL DAY TO SECOND | INTERVAL DAY TO SECOND (expr1과 expr2의 interval 범위를 모두 포함할 수 있는 타입으로 결정된다.) |
자세한 내용은 표에 표기된 INTERVAL 타입이 포함하는 INTERVAL 세부타입 을 참조한다. | ||
사용 예
gSQL> SELECT TO_DATE( '2012-05-05', 'YYYY-MM-DD' ) + 5 AS RESULT FROM DUAL;
RESULT
----------
2012-05-10
1 row selected.
gSQL> SELECT
TO_DATE( '2012-05-05', 'YYYY-MM-DD' ) + INTERVAL'01-01'YEAR TO MONTH
AS RESULT
FROM DUAL;
RESULT
----------
2013-06-05
1 row selected.
gSQL> SELECT
INTERVAL'01-01'YEAR TO MONTH + INTERVAL'02-10'YEAR TO MONTH
AS RESULT
FROM DUAL;
RESULT
----------
+000003-11
1 row selected.+ (POSITIVE)
구문
+ expr
설명
expr에 + 부호를 표시한다.
사용 예
gSQL> SELECT +3 AS RESULT1, +(-3) AS RESULT2 FROM DUAL;
RESULT1 RESULT2
------- -------
3 -3
1 row selected.- (NEGATIVE)
구문
- expr
설명
expr에 - 부호를 표시한다.
사용 예
gSQL> SELECT -3 AS RESULT1, -(-3) AS RESULT2 FROM DUAL;
RESULT1 RESULT2
------- -------
-3 3
1 row selected.- (SUBTRACTION)
구문
expr1 - expr2
설명
expr1과 expr2의 뺄셈 연산 결과를 반환한다.
뺄셈 연산의 종류와 결과 타입은 다음 표와 같다. 자세한 내용은 타입간 변환을 참조한다.
expr1 | expr2 | 결과 타입 |
|---|---|---|
NATIVE INTEGER 계열
| NATIVE INTEGER 계열
| NATIVE_BIGINT |
NUMBER | NUMBER | NUMBER |
NATIVE DOUBLE 계열
| NATIVE DOUBLE 계열
| NATIVE_DOUBLE |
expr1 | expr2 | 결과 타입 |
|---|---|---|
DATE | DATE | NUMBER |
DATE | 숫자 타입 | DATE |
DATE | INTERVAL YEAR TO MONTH | DATE |
DATE | INTERVAL DAY | DATE |
DATE | INTERVAL DAY TO SECOND | TIMESTAMP |
TIME | TIME | INTERVAL DAY TO SECOND |
TIME | 숫자 타입 | TIME |
TIME | INTERVAL YEAR TO MONTH | TIME |
TIME | INTERVAL DAY TO SECOND | TIME |
TIME WITH TIME ZONE | 숫자 타입 | TIME WITH TIME ZONE |
TIME WITH TIME ZONE | INTERVAL YEAR TO MONTH | TIME WITH TIME ZONE |
TIME WITH TIME ZONE | INTERVAL DAY TO SECOND | TIME WITH TIME ZONE |
TIMESTAMP | TIMESTAMP | INTERVAL DAY TO SECOND |
TIMESTAMP | 숫자 타입 | TIMESTAMP |
TIMESTAMP | INTERVAL YEAR TO MONTH | TIMESTAMP |
TIMESTAMP | INTERVAL DAY TO SECOND | TIMESTAMP |
TIMESTAMP WITH TIME ZONE | TIMESTAMP WITH TIME ZONE | INTERVAL DAY TO SECOND |
TIMESTAMP WITH TIME ZONE | 숫자 타입 | TIMESTAMP WITH TIME ZONE |
TIMESTAMP WITH TIME ZONE | INTERVAL YEAR TO MONTH | TIMESTAMP WITH TIME ZONE |
TIMESTAMP WITH TIME ZONE | INTERVAL DAY TO SECOND | TIMESTAMP WITH TIME ZONE |
INTERVAL YEAR TO MONTH | INTERVAL YEAR TO MONTH | INTERVAL YEAR TO MONTH (expr1과 expr2의 interval 범위를 모두 포함할 수 있는 타입으로 결정된다.) |
INTERVAL DAY TO SECOND | INTERVAL DAY TO SECOND | INTERVAL DAY TO SECOND (expr1과 expr2의 interval 범위를 모두 포함할 수 있는 타입으로 결정된다.) |
자세한 내용은 표에 표기된 INTERVAL 타입이 포함하는 INTERVAL 세부타입 을 참조한다. | ||
사용 예
gSQL> SELECT
TO_DATE( '2012-05-05' ) - TO_DATE( '2012-05-01' ) AS RESULT
FROM DUAL;
RESULT
------
4
1 row selected.
gSQL> SELECT TO_DATE( '2012-05-05' ) - 3 AS RESULT FROM DUAL;
RESULT
----------
2012-05-02
1 row selected.
gSQL> SELECT
TO_DATE( '2012-05-05' ) - INTERVAL'01-02'YEAR TO MONTH AS RESULT
FROM DUAL;
RESULT
----------
2011-03-05
1 row selected.
gSQL> SELECT
INTERVAL'05-01'YEAR TO MONTH - INTERVAL'02-01'YEAR TO MONTH
AS RESULT
FROM DUAL;
RESULT
----------
+000003-00
1 row selected.
gSQL> SELECT INTERVAL'15 23:59:59.999999'DAY TO SECOND
- INTERVAL'10 23:59:59.999999'DAY TO SECOND AS RESULT
FROM DUAL;
RESULT
-----------------------
+000005 00:00:00.000000
1 row selected./ (DIVISION)
구문
expr1 / expr2
설명
expr1과 expr2의 나누기 연산 결과를 반환한다.
나누기 연산의 종류와 결과 타입은 다음 표와 같다. 자세한 내용은 타입간 변환을 참조한다.
expr1 | expr2 | 결과 타입 |
|---|---|---|
NATIVE INTEGER 계열
| NATIVE INTEGER 계열
| NATIVE_DOUBLE |
NUMBER | NUMBER | NUMBER |
NATIVE_DOUBLE | NATIVE_DOUBLE | NATIVE_DOUBLE |
expr1 | expr2 | 결과 타입 |
|---|---|---|
INTERVAL YEAR TO MONTH | 숫자 타입 | INTERVAL YEAR TO MONTH (결과 타입은 interval type 이다.) |
INTERVAL DAY TO SECOND | 숫자 타입 | INTERVAL DAY TO SECOND (결과 타입은 interval type 이다.) |
자세한 내용은 표에 표기된 INTERVAL 타입이 포함하는 INTERVAL 세부타입 을 참조한다. | ||
사용 예
gSQL> SELECT INTERVAL'20-10'YEAR TO MONTH / 2 AS RESULT FROM DUAL;
RESULT
----------
+000010-05
1 row selected.
gSQL> SELECT INTERVAL'02 02:04:06.800000'DAY TO SECOND / 2 AS RESULT
FROM DUAL;
RESULT
-----------------------
+000001 01:02:03.400000
1 row selected.|| (CONCATENATE)
구문
str1 || str2
설명
CONCATENATE는 str1과 str2를 연결한 문자열을 반환한다.
str1과 str2 중 하나가 null인 경우 null이 아닌 나머지 str이 반환되고, str1과 str2가 모두 null인 경우 NULL이 반환된다.
인자로는 character string 타입 또는 binary string 타입으로 변환될 수 있는 타입이 올 수 있다. 자세한 내용은 타입간 변환을 참조한다.
CONCAT, CONCATENATE의 alias 이다.
결과 타입은 다음 표와 같다.
Data type | CHAR | VARCHAR | LONG VARCHAR |
|---|---|---|---|
CHAR | CHAR | VARCHAR | LONG VARCHAR |
VARCHAR | VARCHAR | VARCHAR | LONG VARCHAR |
LONG VARCHAR | LONG VARCHAR | LONG VARCHAR | LONG VARCHAR |
Data type | BINARY | VARBINARY | LONG VARBINARY |
BINARY | BINARY | VARBINARY | LONG VARBINARY |
VARBINARY | VARBINARY | VARBINARY | LONG VARBINARY |
LONG VARBINARY | LONG VARBINARY | LONG VARBINARY | LONG VARBINARY |
사용 예
gSQL> SELECT 'DATA' || 'BASE' AS RESULT1,
'DATA' || NULL AS RESULT2,
NULL || NULL AS RESULT3
FROM DUAL;
RESULT1 RESULT2 RESULT3
-------- ------- -------
DATABASE DATA null
1 row selected.ABS
구문
ABS( num )
설명
ABS는 num의 절대값을 반환한다. 인자 num에는 숫자 타입 또는 숫자로 변환될 수 있는 타입이 올 수 있다. num이 NULL이면 NULL을 반환한다.
사용 예
gSQL> SELECT ABS(-1) AS RESULT1, ABS(1) AS RESULT2 FROM DUAL;
RESULT1 RESULT2
------- -------
1 1
1 row selected.ACOS
구문
ACOS( num )
설명
ACOS 함수는 num의 arc cosine 값을 반환한다. 인자 num은 -1 이상 1 이하의 값이어야 한다. num이 NULL이면 NULL을 반환한다. 0 ~ pi 사이의 라디안 값을 반환한다.
사용 예
gSQL> SELECT ACOS( 1 ) FROM DUAL;
ACOS( 1 )
---------
0
1 row selected.ADDDATE
구문
ADDDATE( date, INTERVAL expr unit ) ADDDATE( expr, days )
설명
ADDDATE는 입력받은 첫 번째 인자에 두 번째 인자를 더하기 연산하여 그 결과를 반환한다. 첫 번째 인자에는 DATE, TIMESTAMP, TIMESTAMP WITH TIME ZONE 타입이 올 수 있고, 두 번째 인자에는 INTERVAL 또는 숫자 타입이 올 수 있다. 입력 인자의 값이 하나라도 NULL이면 결과값도 NULL이다.
결과 타입은 (DATETIME/INTERVAL) + 연산과 동일하다.
사용 예
gSQL> SELECT ADDDATE( TO_DATE( '2012-12-12', 'YYYY-MM-DD' ), 1 ) AS RESULT
FROM DUAL;
RESULT
----------
2012-12-13
1 row selected.
gSQL> SELECT ADDDATE( TO_DATE( '2012-11-11', 'YYYY-MM-DD' ),
INTERVAL'01-01'YEAR TO MONTH ) AS RESULT
FROM DUAL;
RESULT
----------
2013-12-11
1 row selected.ADDTIME
구문
ADDTIME( expr1, expr2 )
설명
ADDTIME은 입력받은 expr2를 expr1에 더하여 그 결과를 반환한다.
expr1에는 TIME, TIME WITH TIME ZONE, TIMESTAMP, TIMESTAMP WITH TIME ZONE TYPE이 올 수 있고, expr2에는 INTERVAL DAY TO SECOND TYPE이 올 수 있다. expr1이나 expr2가 NULL이면 결과값은 NULL이다.
결과 타입은 (DATETIME/INTERVAL) + 연산과 동일하다.
사용 예
gSQL> SELECT
ADDTIME( TO_TIMESTAMP( '2001-05-05 06:00:00',
'YYYY-MM-DD HH24:MI:SS' ),
INTERVAL'0 00:06:06.666666'DAY TO SECOND ) AS RESULT
FROM DUAL;
RESULT
--------------------------
2001-05-05 06:06:06.666666
1 row selected.ADD_MONTHS
구문
ADD_MONTHS( date, number )
설명
ADD_MONTHS는 date에 number 숫자만큼의 달을 더한 값을 반환한다. 만약 ADD_MONTHS 연산 후에 날짜가 그 달의 마지막 날보다 큰 경우에는 마지막 날짜로 조정한다.
인자 date에는 DATE, TIMESTAMP, TIMESTAMP WITH TIME ZONE 타입이 올 수 있으며 인자 number에는 숫자타입이 올 수 있다. 입력 인자의 값이 하나라도 NULL이면 결과값도 NULL이다.
결과 타입은 입력 인자 date 타입과 관계없이 항상 DATE 타입이다.
사용 예
gSQL> SELECT
ADD_MONTHS( TO_DATE( '2001-07-31', 'YYYY-MM-DD' ), 1 ) AS RESULT1,
ADD_MONTHS( TO_DATE( '2001-07-31', 'YYYY-MM-DD' ), 2 ) AS RESULT2
FROM DUAL;
RESULT1 RESULT2
---------- ----------
2001-08-31 2001-09-30
1 row selected.ASCII
구문
ASCII( char )
설명
char의 첫 번째 문자에 대한 database character set code를 십진수로 반환한다.
char에는 CHARACTER, CHARACTER VARYING, CHARACTER LONG VARYING과 같은 문자 타입 또는 문자 타입으로 변환될 수 있는 타입이 올 수 있고, 반환되는 타입은 NUMBER 이다. char가 NULL이면 NULL을 반환한다.
사용 예
gSQL> SELECT ASCII( 'G' ) AS RESULT FROM DUAL;
RESULT
------
71
1 row selected.ASIN
구문
ASIN( num )
설명
ASIN 함수는 num의 arc sin 값을 반환한다.
인자 num은 -1 이상 1 이하의 값이어야 한다. num이 NULL이면 NULL을 반환한다.
-pi/2 ~ pi/2 사이의 라디안 값을 반환한다.
사용 예
gSQL> SELECT ASIN( 0 ) FROM DUAL;
ASIN( 0 )
---------
0
1 row selected.ATAN
구문
ATAN( num )
설명
ATAN 함수는 num의 arc tangent 값을 반환한다.
num 값 범위의 제한은 없으며, -pi/2 ~ pi/2 사이의 라디안 값을 반환한다. num이 NULL이면 NULL을 반환한다.
사용 예
gSQL> SELECT ATAN(0.5) FROM DUAL;
ATAN(0.5)
----------------
.463647609000806
1 row selected.ATAN2
구문
ATAN2( num1, num2 )
설명
ATAN2 함수는 num1과 num2의 arc tangent 값을 반환한다.
인자 num1 값 범위의 제한은 없으며 -pi ~ pi 사이의 라디안 값을 반환한다. num1 또는 num2 중 하나라도 NULL이면 NULL을 반환한다.
사용 예
gSQL> SELECT ATAN2(1,2) FROM DUAL;
ATAN2(1,2)
----------------
.463647609000806
1 row selected.AVG
구문
AVG( [ ALL | DISTINCT ] num )
설명
Aggregation 함수로써 expr 들의 평균값을 얻는데 사용된다.
ALL을 명시한 경우, 모든 값들에 대한 aggregation을 수행한다. DISTINCT를 명시한 경우, 중복 제거한 값들에 대한 aggregation을 수행한다. ALL이나 DISTINCT를 명시하지 않은 경우, ALL을 명시한 것과 동일하게 처리한다.
사용 예
gSQL> SELECT AVG(c1) FROM t1;
AVG(C1)
-------
2
1 row selected.BITAND
구문
BITAND( num1, num2 )
설명
num1과 num2의 비트에 대한 AND 연산 결과를 반환한다.
입력 인자에는 NATIVE_SMALLINT, NATIVE_INTEGER, NATIVE_BIGINT 또는 NATIVE_BIGINT로 변환될 수 있는 타입이 올 수 있다. NATIVE_BIGINT 타입으로 변환할 때 소수점은 TRUNCATE 된다. 입력 인자의 값이 하나라도 NULL이면 결과값도 NULL이다.
결과 타입은 NATIVE_BIGINT이다.
사용 예
gSQL> SELECT BITAND(2, 4) FROM DUAL;
BITAND(2, 4)
------------
0
1 row selected.BITNOT
구문
BITNOT( num )
설명
num의 비트에 대해 NOT 연산한 결과를 반환한다.
입력 인자에는 NATIVE_SMALLINT, NATIVE_INTEGER, NATIVE_BIGINT 또는 NATIVE_BIGINT로 변환될 수 있는 타입이 올 수 있다. NATIVE_BIGINT 타입으로 변환할 때 소수점은 TRUNCATE 된다. 입력 인자가 NULL이면 결과값도 NULL이다.
결과 타입은 다음과 같다. • 입력 인자가 NATIVE_SMALLINT인 경우, NATIVE_SMALLINT • 입력 인자가 NATIVE_INTEGER인 경우, NATIVE_INTEGER • 입력 인자가 NATIVE_BIGINT인 경우, NATIVE_BIGINT
사용 예
gSQL> SELECT BITNOT( 5 ) AS RESULT FROM DUAL;
RESULT
------
-6
1 row selected.BITOR
구문
BITOR( num1, num2 )
설명
num1과 num2의 비트에 대해 OR 연산한 결과를 반환한다.
입력 인자에는 NATIVE_SMALLINT, NATIVE_INTEGER, NATIVE_BIGINT 또는 NATIVE_BIGINT로 변환될 수 있는 타입이 올 수 있다. NATIVE_BIGINT 타입으로 변환할 때 소수점은 TRUNCATE 된다. 입력 인자의 값이 하나라도 NULL이면 결과는 NULL이다.
결과 타입은 NATIVE_BIGINT이다.
사용 예
gSQL> SELECT BITOR( 2, 4 ) FROM DUAL;
BITOR( 2, 4 )
-------------
6
1 row selected.BITXOR
구문
BITXOR( num1, num2 )
설명
num1과 num2의 비트에 대해 XOR 연산한 결과를 반환한다.
입력 인자에는 NATIVE_SMALLINT, NATIVE_INTEGER, NATIVE_BIGINT 또는 NATIVE_BIGINT로 변환될 수 있는 타입이 올 수 있다. NATIVE_BIGINT 타입으로 변환할 때 소수점은 TRUNCATE 된다. 입력 인자의 값이 하나라도 NULL이면 결과는 NULL이다.
결과 타입은 NATIVE_BIGINT이다.
사용 예
gSQL> SELECT BITXOR( 5, 3 ) FROM DUAL;
BITXOR( 5, 3 )
-------------
6
1 row selected.BIT_LENGTH
구문
BIT_LENGTH( str )
설명
BIT_LENGTH는 str의 비트 수를 반환한다. str이 NULL이면 NULL을 반환한다.
사용 예
gSQL> SELECT BIT_LENGTH( 'LIKE' ) AS RESULT FROM DUAL;
RESULT
---------------
32
1 row selected.BYTE_LENGTH
구문
BYTE_LENGTH( str )
설명
OCTET_LENGTH의 alias이다. 자세한 내용은 OCTET_LENGTH, LENGTHB를 참조한다.
사용 예
Multi byte character set (예: UTF8): 1 byte character
gSQL> SELECT BYTE_LENGTH( 'OCTET_LENGTH' ) AS RESULT_1BYTE_CHARACTERS
FROM DUAL;
RESULT_1BYTE_CHARACTERS
-----------------------
12
1 row selected.Multi byte character set (예: UTF8): 2 byte character
gSQL> SELECT BYTE_LENGTH( 'αβ' ) AS RESULT_2BYTE_CHARACTERS FROM DUAL;
RESULT_2BYTE_CHARACTERS
-----------------------
4
1 row selected.CASE2
구문
CASE2( condition1, result1
[, condition2, result2
, ...
, conditionN, resultN ]
[, default ] )설명
CASE2는 기술된 순서대로 condition을 평가한다. 비교 결과가 FALSE이면 TRUE가 나올 때까지 평가한다. 비교 결과가 TRUE이면 대응되는 result를 반환하고, 이후는 평가하지 않는다. 비교 결과가 모두 FALSE인 경우에는 default를 반환하고, default가 생략된 경우에는 NULL을 반환한다.
result에 여러 type이 오는 경우, 결과 타입 조합 규칙에 따라 result type이 결정된다.
CASE2는 CASE로 동일하게 표현할 수 있다.
CASE2( condition1, res1, condition2, res2 )
CASE WHEN condition1 THEN res1
WHEN condition2 THEN res2
ELSE NULL
ENDCASE2( condition1, res1, condition2, res2, default )
CASE WHEN condition1 THEN res1
WHEN condition2 THEN res2
ELSE default
END사용 예
gSQL> SELECT I1,
CASE2( I1 = 1, 'ONE', I1 = 2, 'TWO' ) AS CASE2_RESULT1,
CASE2( I1 = 1, 'ONE', I1 = 2, 'TWO', 'NUMBER' ) AS CASE2_RESULT2
FROM T1;
I1 CASE2_RESULT1 CASE2_RESULT2
-- ------------- -------------
1 ONE ONE
2 TWO TWO
3 null NUMBER
3 rows selected.CBRT
구문
CBRT( num )
설명
num의 세제곱근을 반환한다. num이 NULL이면 결과값도 NULL이 반환된다.
사용 예
gSQL> SELECT CBRT( 27 ) FROM DUAL;
CBRT( 27 )
----------
3
1 row selected.CEIL
구문
CEIL( num ) CEILING( num )
설명
CEIL 함수는 num 보다 크거나 같은 가장 작은 정수를 반환한다. num이 NULL이면 NULL을 반환한다.
사용 예
gSQL> SELECT CEIL( 3.5 ) AS RESULT1, CEIL( -3.5 ) AS RESULT2 FROM DUAL;
RESULT1 RESULT2
------- -------
4 -3
1 row selected.CHAR_LENGTH
구문
CHAR_LENGTH( str ) CHARACTER_LENGTH( str )
설명
CHAR_LENGTH는 str에 대해 character set에 따른 문자수를 반환한다.
str에는 CHARACTER, CHARACTER VARYING, CHARACTER LONG VARYING과 같은 문자 타입 또는 문자 타입으로 변환될 수 있는 타입이 올 수 있고, 반환되는 타입은 NATIVE_BIGINT 이다.
str의 타입이 CHARACTER 타입이면 공백문자 (trailing blank)를 포함하여 계산한다. str이 NULL이면 NULL이 반환된다.
LENGTH의 alias이다.
사용 예
Multi byte character set: (예:UTF8)
gSQL> SELECT CHAR_LENGTH( 'αβ-SUMMER' ) AS RESULT FROM DUAL;
RESULT
---------------
9
1 row selected.CHR
구문
CHR( num )
설명
num에 대응하는 database character set code 내의 charater를 반환한다.
num은 숫자 타입이다. num이 NULL이면 NULL을 반환한다. 결과 타입은 VARCHAR 이다.
사용 예
gSQL> SELECT CHR(71) FROM DUAL; CHR(71) ------- G 1 row selected.
CLOCK_DATE
구문
CLOCK_DATE()
설명
함수가 호출될 때마다 현재 날짜 (DATE type) 값을 얻는다.
현재 날짜를 얻는 함수들 간에는 다음과 같은 차이가 있다. • TRANSACTION_DATE(): 트랜잭션 내의 모든 날짜값이 동일하다. • STATEMENT_DATE(): 하나의 SQL 문장 내에서 모든 날짜 값이 동일하다. • CLOCK_DATE(): 함수가 호출될 때마다 현재 날짜 값을 얻는다.
사용 예
Row 마다 다른 값을 가질 수 있다.
gSQL> SELECT CLOCK_DATE() FROM t1; CLOCK_DATE() ------------ 2013-12-12 2013-12-12 2013-12-13 3 rows selected.
CLOCK_LOCALTIME
구문
CLOCK_LOCALTIME()
설명
함수가 호출될 때마다 TIME ZONE이 없는 현재 시간 (TIME WITHOUT TIME ZONE type) 값을 얻는다.
현재 시간을 얻는 함수들 간에는 다음과 같은 차이가 있다. • TRANSACTION_LOCALTIME(): 트랜잭션 내의 모든 시간값이 동일하다. • STATEMENT_LOCALTIME(): 하나의 SQL 문장 내에서 모든 시간값이 동일하다. • CLOCK_LOCALTIME(): 함수가 호출될 때마다 현재 시간값을 얻는다.
사용 예
Row 마다 시간값이 다를 수 있다.
gSQL> SELECT CLOCK_LOCALTIME() FROM t1; CLOCK_LOCALTIME() ----------------- 14:42:05.470757 14:42:05.470759 14:42:05.470759 3 rows selected.
CLOCK_LOCALTIMESTAMP
구문
CLOCK_LOCALTIMESTAMP()
설명
함수가 호출될 때마다 TIME ZONE이 없는 현재 TIMESTAMP (TIMESTAMP WITHOUT TIME ZONE type) 값을 얻는다.
현재 TIMESTAMP를 얻는 함수들 간에는 다음과 같은 차이가 있다. • TRANSACTION_LOCALTIMESTAMP(): 트랜잭션 내의 모든 TIMESTAMP 값이 동일하다. • STATEMENT_LOCALTIMESTAMP(): 하나의 SQL 문장 내에서 모든 TIMESTAMP 값이 동일하다. • CLOCK_LOCALTIMESTAMP(): 함수가 호출될 때마다 현재 TIMESTAMP 값을 얻는다.
사용 예
Row 마다 값이 다를 수 있다.
gSQL> SELECT CLOCK_LOCALTIMESTAMP() FROM t1; CLOCK_LOCALTIMESTAMP() -------------------------- 2013-12-12 14:46:17.309206 2013-12-12 14:46:17.309209 2013-12-12 14:46:17.309209
CLOCK_TIME
구문
CLOCK_TIME()
설명
함수가 호출될 때마다 TIME ZONE이 있는 현재 시간 (TIME WITH TIME ZONE type) 값을 얻는다.
현재 시간을 얻는 함수들 간에는 다음과 같은 차이가 있다. • TRANSACTION_TIME(): 트랜잭션 내의 모든 시간값이 동일하다. • STATEMENT_TIME(): 하나의 SQL 문장 내에서 모든 시간값이 동일하다. • CLOCK_TIME(): 함수가 호출될 때마다 현재 시간값을 얻는다.
사용 예
Row 마다 시간값이 다를 수 있다.
gSQL> SELECT CLOCK_TIME() FROM t1; CLOCK_TIME() ---------------------- 14:48:21.052324 +09:00 14:48:21.052326 +09:00 14:48:21.052327 +09:00 3 rows selected.
CLOCK_TIMESTAMP
구문
CLOCK_TIMESTAMP()
설명
함수가 호출될 때마다 TIME ZONE이 있는 현재 TIMESTAMP (TIMESTAMP WITH TIME ZONE type) 값을 얻는다.
현재 TIMESTAMP를 얻는 함수들 간에는 다음과 같은 차이가 있다. • TRANSACTION_TIMESTAMP(): 트랜잭션 내의 모든 TIMESTAMP 값이 동일하다. • STATEMENT_TIMESTAMP(): 하나의 SQL 문장 내에서 모든 TIMESTAMP 값이 동일하다. • CLOCK_TIMESTAMP(): 함수가 호출될 때마다 현재 TIMESTAMP 값을 얻는다.
사용 예
Row 마다 값이 다를 수 있다.
gSQL> SELECT CLOCK_TIMESTAMP() FROM t1; CLOCK_TIMESTAMP() --------------------------------- 2013-12-12 14:49:45.051709 +09:00 2013-12-12 14:49:45.051714 +09:00 2013-12-12 14:49:45.051714 +09:00 3 rows selected.
COALESCE
구문
COALESCE( expr1, ..., exprN )
설명
expr list들 중에 null이 아닌 첫 번째 expr을 반환한다. expr list들이 모두 null인 경우에는 null을 반환한다. expr은 두 개 이상이어야 한다.
expr list에 여러 type들이 오는 경우에는 결과 타입 조합 규칙에 따라 result type이 결정된다.
COALESCE는 CASE를 사용해서 동일하게 표현할 수 있다.
N/A
COALESCE( expr1, expr2 )
CASE WHEN expr1 IS NOT NULL THEN expr1
ELSE expr2
ENDN/A
COALESCE( expr1, expr2, ..., exprN )
CASE WHEN expr1 IS NOT NULL THEN expr1
ELSE COALESCE( expr2, ..., exprN )
END사용 예
gSQL> SELECT COALESCE( NULL, 1, 2 ) FROM DUAL;
COALESCE( NULL, 1, 2 )
----------------------
1
1 row selected.
gSQL> SELECT COALESCE( NULL, NULL, NULL ) FROM DUAL;
COALESCE( NULL, NULL, NULL )
----------------------------
null
1 row selected.CONCAT
구문
CONCAT( str1, str2, ... )
설명
|| ( CONCATENATE )의 alias 이다. CONCAT 함수의 argument로써 2 ~ 254 개까지 설정할 수 있다. 자세한 내용은 || (CONCATENATE), CONCATENATE를 참조한다.
사용 예
gSQL> SELECT CONCAT( 'DATA', 'BASE' ) AS RESULT FROM DUAL; RESULT -------- DATABASE 1 row selected.
CONCATENATE
구문
CONCATENATE( str1, str2, ... )
설명
|| ( CONCATENATE ) 의 alias 이다. CONCATENATE 함수의 argument로 2 ~ 254 개까지 설정할 수 있다. 자세한 내용은 CONCAT, || (CONCATENATE)를 참조한다.
사용 예
gSQL> SELECT CONCATENATE( 'DATA', 'BASE' ) AS RESULT FROM DUAL; RESULT -------- DATABASE 1 row selected.
COS
구문
COS(num)
설명
num의 COSINE 값을 반환한다. 인자값 num이 NULL이면 결과값도 NULL이다.
사용 예
gSQL> SELECT COS( 0 ) FROM DUAL;
COS( 0 )
--------
1
1 row selected.COT
구문
COT(num)
설명
num의 COTANGENT 값을 반환한다. 인자값 num이 NULL이면 결과값도 NULL이다.
사용 예
gSQL> SELECT COT( 1 ) FROM DUAL;
COT( 1 )
----------------
.642092615934331
1 row selected.COUNT
구문
COUNT( [ ALL | DISTINCT ] expr )
설명
Aggregation 함수로써 expr이 NULL 값이 아닌 row의 개수를 얻는다.
ALL을 명시한 경우, 모든 값들에 대한 aggregation을 수행한다. DISTINCT을 명시한 경우, 중복 제거한 값들에 대한 aggregation을 수행한다. ALL이나 DISTINCT를 명시하지 않은 경우, ALL을 명시한 것과 동일하게 처리한다.
사용 예
gSQL> SELECT COUNT(c1) FROM t1;
COUNT(C1)
---------
3
1 row selected.COUNT(*)
구문
COUNT(*)
설명
Aggregation 함수로써 row의 개수를 얻는다. 별도의 expression을 지정하지 않으므로 값의 NULL 여부와 무관하다.
사용 예
gSQL> SELECT COUNT(*) FROM t1;
COUNT(*)
--------
4
1 row selected.CURRENT_CATALOG
구문
CURRENT_CATALOG [()]
설명
catalog name (database 이름)을 얻는다.
사용 예
gSQL> SELECT CURRENT_CATALOG FROM dual; CURRENT_CATALOG --------------- TEST_DB 1 row selected.
CURRENT_DATE
구문
CURRENT_DATE [()] STATEMENT_DATE()
설명
현재 날짜 (DATE type) 값을 얻는다.
CURRENT_DATE는 SQL 표준 함수이다.
현재 날짜를 얻는 함수들 간에는 다음과 같은 차이가 있다. • TRANSACTION_DATE(): 트랜잭션 내의 모든 날짜값이 동일하다. • CURRENT_DATE, STATEMENT_DATE(): 하나의 SQL 문장 내에서 모든 날짜 값이 동일하다. • CLOCK_DATE(): 함수가 호출될 때마다 현재 날짜 값을 얻는다.
사용 예
gSQL> SELECT CURRENT_DATE FROM t1; CURRENT_DATE ------------ 2013-12-12 2013-12-12 2013-12-12 3 rows selected.
CURRENT_SCHEMA
구문
CURRENT_SCHEMA [()]
설명
사용자의 현재 SCHEMA를 얻는다.
사용 예
gSQL> SELECT CURRENT_SCHEMA FROM dual; CURRENT_SCHEMA -------------- PUBLIC 1 row selected.
CURRENT_TIME
구문
CURRENT_TIME [()] STATEMENT_TIME()
설명
Session 시간을 기준으로 현재 TIME WITH TIME ZONE type 값을 얻는다.
CURRENT_TIME은 SQL 표준 함수이다.
현재 날짜를 얻는 함수들 간에는 다음과 같은 차이가 있다. • TRANSACTION_TIME(): 트랜잭션 내의 모든 시간값이 동일하다. • CURRENT_TIME, STATEMENT_TIME(): 하나의 SQL 문장 내에서 모든 시간값이 동일하다. • CLOCK_TIME(): 함수가 호출될 때마다 현재 시간값을 얻는다.
사용 예
모든 row가 같은 시간값을 갖는다.
gSQL> SELECT CURRENT_TIME FROM t1; CURRENT_TIME ---------------------- 16:27:10.116396 +09:00 16:27:10.116396 +09:00 16:27:10.116396 +09:00 3 rows selected.
CURRENT_TIMESTAMP
구문
CURRENT_TIMESTAMP [()] STATEMENT_TIMESTAMP()
설명
Session 시간을 기준으로 TIMESTAMP WITH TIME ZONE type 값을 얻는다.
CURRENT_TIMESTAMP는 SQL 표준 함수이다.
현재 TIMESTAMP를 얻는 함수들 간에는 다음과 같은 차이가 있다. • TRANSACTION_TIMESTAMP(): 트랜잭션 내의 모든 TIMESTAMP 값이 동일하다. • CURRENT_TIMESTAMP, STATEMENT_TIMESTAMP(): 하나의 SQL 문장 내에서 모든 TIMESTAMP 값이 동일하다. • CLOCK_TIMESTAMP(): 함수가 호출될 때마다 현재 TIMESTAMP 값을 얻는다.
사용 예
모든 row가 같은 값을 갖는다.
gSQL> SELECT CURRENT_TIMESTAMP FROM t1; CURRENT_TIMESTAMP --------------------------------- 2013-12-12 16:34:55.649632 +09:00 2013-12-12 16:34:55.649632 +09:00 2013-12-12 16:34:55.649632 +09:00 3 rows selected.
CURRENT_USER
구문
CURRENT_USER [()]
설명
현재 사용자를 반환한다.
사용자 정보는 다음과 같은 세 가지 형태로 관리된다.
Logon user: login을 실행한 user로서 connection을 닫을 때까지 유지된다.
Session user: 최초 logon user와 동일하지만 SET SESSION AUTHORIZATION 구문을 이용해 변경할 수 있다.
Current user: 일반적으로 session user와 동일하지만 PSM, view 등을 사용할 때 접근 제어등을 위해 시스템 내부적으로 잠시 변경된다.
Session user와 current user는 unix system의 real user와 effective user의 차이와 유사한 개념이다.
사용 예
% gsql sys gliese
gSQL> SET SESSION AUTHORIZATION test;
Session set.
gSQL> SELECT
LOGON_USER() AS result1,
SESSION_USER() AS result2,
CURRENT_USER() AS result3
FROM DUAL;
RESULT1 RESULT2 RESULT3
------- ------- -------
SYS TEST TEST
1 row selected.CURRVAL
구문
seq_name.CURRVAL CURRVAL(seq_name)
설명
시퀀스 객체의 현재 값을 얻는다.
최소 한 번은 NEXTVAL(seq_name) 등으로 시퀀스 값을 설정해야 한다.
사용 예
gSQL> SELECT seq.CURRVAL FROM dual;
SEQ.CURRVAL
-----------
1
1 row selected.DATEADD
구문
DATEADD( datepart, number, date )
설명
date의 지정된 datepart에 number를 더한 값을 반환한다.
number가 소수점인 경우 반올림되지 않는다. date에는 DATE, TIMESTAMP, TIMESTAMP WITH TIME ZONE, TIME, TIME WITH TIME ZONE 타입이 올 수 있다. number 또는 date가 NULL인 경우에는 결과값도 NULL이다.
인자로 받은 date의 타입과 동일한 결과 타입이 반환된다.
datepart | 설명 |
|---|---|
YEAR | 년 |
QUARTER | 분기 |
MONTH | 월 |
DAYOFYEAR | 일 |
DAY | 요일 |
WEEK | 주 |
WEEKDAY | 평일 |
HOUR | 시 |
MINUTE | 분 |
SECOND | 초 |
MILLISECOND | 밀리세컨드 |
MICROSECOND | 마이크로세컨드 |
사용 예
gSQL> SELECT
DATEADD( YEAR, 1, TO_DATE( '2013-05-14', 'YYYY-MM-DD' ) ) AS RESULT
FROM DUAL;
RESULT
----------
2014-05-14
1 row selected.
gSQL> SELECT
DATEADD( MONTH, 13, TO_DATE('2013-05-14', 'YYYY-MM-DD') ) AS RESULT
FROM DUAL;
RESULT
----------
2014-06-14
1 row selected.
gSQL> SELECT
DATEADD( DAY, 397, TO_DATE('2013-05-14', 'YYYY-MM-DD') ) AS RESULT
FROM DUAL;
RESULT
----------
2014-06-15
1 row selected.DATEDIFF
구문
DATEDIFF( datepart, startdate, enddate )
설명
enddate에서 startdate를 뺀 값을 지정된 datepart로 반환한다.
startdate와 enddate에는 DATE, TIMESTAMP, TIMESTAMP WITH TIME ZONE, TIME TYPE이 올 수 있다. startdate 또는 enddate가 NULL이면 결과값도 NULL이다.
결과 타입은 NUMBER이다.
datepart | 설명 |
|---|---|
YEAR | 년 |
QUARTER | 분기 |
MONTH | 월 |
DAYOFYEAR | 일 |
DAY | 요일 |
HOUR | 시 |
MINUTE | 분 |
SECOND | 초 |
MILLISECOND | 밀리세컨트 |
MICROSECOND | 마이크로세컨드 |
사용 예
gSQL> SELECT
DATEDIFF( YEAR,
TO_DATE( '2013-05-14', 'YYYY-MM-DD' ),
TO_DATE( '2014-06-15', 'YYYY-MM-DD' ) ) AS RESULT
FROM DUAL;
RESULT
------
1
1 row selected.
gSQL> SELECT
DATEDIFF( MONTH,
TO_DATE( '2014-05-14', 'YYYY-MM-DD' ),
TO_DATE( '2014-06-15', 'YYYY-MM-DD' ) ) AS RESULT
FROM DUAL;
RESULT
------
1
1 row selected.
gSQL> SELECT
DATEDIFF( DAY,
TO_DATE( '2013-06-01', 'YYYY-MM-DD' ),
TO_DATE( '2013-06-15', 'YYYY-MM-DD' ) ) AS RESULT
FROM DUAL;
RESULT
------
14
1 row selected.DATE_ADD
구문
DATE_ADD( date, INTERVAL expr unit )
설명
ADDDATE ( date, INTERVAL expr unit )와 동일한 함수이다.
사용 예
gSQL> SELECT
DATE_ADD( TO_DATE( '2012-01-02', 'YYYY-MM-DD' ),
INTERVAL '2-2' YEAR TO MONTH ) AS RESULT
FROM DUAL;
RESULT
----------
2014-03-02
1 row selected.DATE_PART
구문
DATE_PART( field, datetime )
설명
DATE_PART는 EXTRACT 함수와 결과값이 같은 함수로써 입력한 datetime 타입에서 지정된 field를 찾아 반환한다.
인자 field에는 문자 literal만 올 수 있으며, YEAR, MONTH, DAY, HOUR, MINUTE, SECOND, TIMEZONE_HOUR, TIMEZONE_MINUTE를 문자 literal로 지정할 수 있다. 인자 datetime에는 DATE, TIMESTAMP, TIMESTAMP WITH TIME ZONE, TIME, TIME WITH TIME ZONE, INTERVAL 타입이 올 수 있다.
field가 datetime의 범위에 있지 않는 경우 에러를 반환한다. 또한, DATE 타입인 경우에는 field에 YEAR, MONTH, DAY 만 올 수 있고, 그 외에는 에러를 반환한다. datatime이 NULL이면 NULL을 반환한다. 반환되는 타입은 NUMBER이다.
자세한 내용은 EXTRACT를 참조한다.
사용 예
gSQL> SELECT
DATE_PART( 'DAY', TO_DATE( '2012-01-02', 'YYYY-MM-DD' ) ) AS RESULT
FROM DUAL;
RESULT
------
2
1 row selected.
gSQL> SELECT
DATE_PART( 'YEAR', INTERVAL'9-11'YEAR TO MONTH ) AS RESULT
FROM DUAL;
RESULT
------
9
1 row selected.DECODE
구문
DECODE( expr, comparison_expr1, result1
[, comparison_expr2, result2
, ...
, comparison_exprN, resultN ]
[, default ] )설명
DECODE 문에 기술된 순서대로 expr과 comparison_expr을 equal 연산으로 평가한다. 비교 결과가 FALSE이면 TRUE가 나올 때까지 평가한다. 비교 결과가 TRUE면 대응되는 result를 반환하고 이후는 평가하지 않는다.
expr과 comparison_expr이 같거나, expr과 comparison_expr이 모두 null인 경우, (null = null)에는 TRUE로 평가되어 대응되는 result를 반환한다. 평가한 결과가 모두 FALSE인 경우에는 default를 반환하고, default가 생략된 경우, NULL을 반환한다.
expr과 comparison_expr 비교
모든 expr, comparison_expr1, ..., comparison_exprN은 comparison_expr1 (첫 번째 comparison_expr)의 데이터 타입으로 변환하여 비교한다.
comparison_expr1 (첫 번째 comparison_expr)이 문자형인 경우와 숫자형인 경우, 각각 expr, comparison_expr1, ..., comparison_exprN에 기술된 타입들의 범위를 포함할 수 있는 타입이 된다.
expr, comparison_expr1, ..., comparison_exprN에 기술된 타입이 모두 CHAR 타입인 경우, VARCHAR 타입으로 비교가 수행된다.
결과 타입
결과 타입은 result1 (첫 번째 result)의 데이터 타입이 된다.
result1 (첫 번째 result)의 데이터 타입이 숫자형인 경우와 문자형인 경우는 각각 result1, ..., resultN에 기술된 타입들의 범위를 포함할 수 있는 타입이 된다.
result1 (첫 번째 result)가 CHAR 타입 또는 NULL인 경우, 결과 타입은 VARCHAR가 된다.
DECODE는 CASE를 사용해 동일하게 표현할 수 있다.
DECODE( expr, comp_expr1, res1, comp_expr2, res2 )
CASE WHEN (expr = comp_expr1) OR (expr IS NULL AND comp_expr1 IS NULL ) THEN res1
WHEN (expr = comp_expr2) OR (expr IS NULL AND comp_expr2 IS NULL ) THEN res2
ELSE NULL
ENDDECODE( expr, comp_expr1, res1, comp_expr2, res2, default )
CASE WHEN (expr = comp_expr1) OR (expr IS NULL AND comp_expr1 IS NULL ) THEN res1
WHEN (expr = comp_expr2) OR (expr IS NULL AND comp_expr2 IS NULL ) THEN res2
ELSE default
END사용 예
gSQL> SELECT I1,
DECODE( I1, 1, 'ONE',
2, 'TWO',
NULL, 'NULL VALUE',
'DEFAULT VALUE' ) AS DECODE_RESULT
FROM T1;
I1 DECODE_RESULT
---- -------------
1 ONE
2 TWO
null NULL VALUE
3 DEFAULT VALUE
4 rows selected.DEGREES
구문
DEGREES( radians )
설명
라디안 단위로 표시된 각도 radians를 도 단위로 변환한 값을 반환한다. radians가 NULL이면 NULL이 반환된다.
사용 예
gSQL> SELECT DEGREES( PI() ) AS RESULT FROM DUAL; RESULT ------ 180 1 row selected.
DIGEST
구문
DIGEST( data, type )
설명
data를 주어진 type으로 hash한 결과값을 VARBINARY 타입으로 반환한다.
data 타입을 다음 규칙에 따라 입력할 때 implicit conversion이 발생할 수 있다. • BINARY, VARBINARY 타입 data는 VARBINARY로 입력한다. • LONG VARBINARY 타입 data는 LONG VARBINARY로 입력한다. • LONG VARCHAR 타입 data는 LONG VARCHAR로 입력한다. • 그 외의 모든 타입 data는 모두 VARCHAR 타입으로 implicit conversion하여 입력한다.
DIGEST 함수가 지원하는 hash type은 다음과 같다. • 'SHA1'의 결과는 20 byte varbinary이다. • 'SHA224'의 결과는 28 byte varbinary이다. • 'SHA256'의 결과는 32 byte varbinary이다. • 'SHA384'의 결과는 48 byte varbinary 이다. • 'SHA512'의 결과는 64 byte varbinary 이다.
결과를 VARBINARY 타입으로 반환하기 때문에 결과를 hexadecimal 문자로 보려면 HEX 함수를 씌워서 사용해야 하는데 이 경우 그 길이는 원본의 두 배가 된다.
사용 예
gSQL> SELECT HEX( DIGEST( 'my password', 'SHA256' ) ) AS RESULT FROM DUAL; RESULT ---------------------------------------------------------------- BB14292D91C6D0920A5536BB41F3A50F66351B7B9D94C804DFCE8A96CA1051F2 1 row selected.
DUMP
구문
DUMP( expr )
설명
DUMP 함수는 expr의 내부 표현정보를 반환한다. 내부 표현정보는 데이터 타입, 길이 (byte length), 데이터 정보로 보여준다.
expr에는 모든 타입이 가능하다. expr이 NULL이면 NULL을 반환한다. 반환되는 타입은 CHARACTER VARYING이다.
사용 예
gSQL> SELECT DUMP( 'DUMP' ) AS RESULT FROM DUAL; RESULT --------------------------------- Type=CHAR Len=4 : Str=68,85,77,80 1 row selected.
EXP
구문
EXP( num )
설명
EXP 함수는 e (자연로그 베이스)의 num의 제곱값을 반환한다. num이 NULL이면 NULL을 반환한다.
사용 예
gSQL> SELECT EXP( 1 ) AS RESULT FROM DUAL;
RESULT
----------------
2.71828182845905
1 row selected.EXTRACT
구문
EXTRACT( <field> FROM datetime )
<field> ::=
YEAR
| MONTH
| DAY
| HOUR
| MINUTE
| SECOND
| TIMEZONE_HOUR
| TIMEZONE_MINUTE설명
EXTRACT는 입력한 datetime 타입에서 지정된 field를 찾아 반환한다.
인자 datetime에는 DATE, TIMESTAMP, TIMESTAMP WITH TIME ZONE, TIME, TIME WITH TIME ZONE, INTERVAL 타입이 올 수 있다.
field가 datetime의 범위에 있지 않는 경우에는 에러를 반환한다. 또, DATE 타입인 경우에는 field에 YEAR, MONTH, DAY만 올 수 있고, 그 외의 경우에는 에러를 반환한다. 반환되는 타입은 NUMBER이다.
EXTRACT 함수의 결과는 DATE_PART와 동일하다.
사용 예
gSQL> SELECT
EXTRACT( SECOND FROM TO_TIMESTAMP( '2012-12-13 01:23:44.5',
'YYYY-MM-DD HH24:MI:SS.FF1' ) )
AS RESULT
FROM DUAL;
RESULT
------
44.5
1 row selected.
gSQL> SELECT
EXTRACT( YEAR FROM CAST('2-3' AS INTERVAL YEAR TO MONTH) ) AS RESULT
FROM DUAL;
RESULT
------
2
1 row selected.FACTORIAL
구문
FACTORIAL( num )
설명
FACTORIAL 함수는 1 ~ num 까지의 연속된 자연수를 차례로 곱한 값을 반환한다. num이 NULL이면 NULL을 반환한다.
사용 예
gSQL> SELECT FACTORIAL( 5 ) AS RESULT FROM DUAL; RESULT ------ 120 1 row selected.
FLOOR
구문
FLOOR( num )
설명
FLOOR 함수는 num 보다 크지 않은 가장 큰 정수를 반환한다. num이 NULL이면 NULL을 반환한다.
사용 예
gSQL> SELECT FLOOR(42.8) AS RESULT1, FLOOR(-42.8) AS RESULT2 FROM DUAL;
RESULT1 RESULT2
------- -------
42 -43
1 row selected.FROM_BASE64
구문
FROM_BASE64( str )
설명
FROM_BASE64는 base64 인코딩으로 변환된 문자를 입력 받아 디코딩된 binary string을 반환한다.
입력 인자에는 CHARACTER VARYING, CHARACTER LONG VARYING과 같은 CHARACTER 문자 타입이 올 수 있고, 결과 타입은 BINARY VARYING 또는 BINARY LONG VARYING과 같은 BINARY 문자 타입이다.
str이 NULL이면 결과값도 NULL이다. str에 base64 문자 범위에 속하지 않는 문자가 포함되면, 에러를 반환한다. 디코딩 할 때 str의 newline, carriage return, tab, space는 무시된다.
자세한 내용은 TO_BASE64를 참조한다.
사용 예
gSQL> SELECT FROM_BASE64( TO_BASE64( 'abc' ) ),
FROM_BASE64( TO_BASE64( 'abcd' ) )
FROM DUAL;
FROM_BASE64( TO_BASE64( 'abc' ) ) FROM_BASE64( TO_BASE64( 'abcd' ) )
--------------------------------- ----------------------------------
616263 61626364
1 row selected.GREATEST
구문
GREATEST( expr1 [, expr2, ... exprn ] )
설명
GREATEST 함수는 인자로 받은 expr들 중에 가장 큰 값을 반환한다.
인자로 받은 expr들 중 하나라도 NULL인 경우, 결과값은 NULL이다.
결과 타입은 expr1 (첫 번째 expr)의 데이터 타입이다. expr1 (첫 번째 expr)의 데이터 타입이 숫자형인 경우와 문자형인 경우는 각각 expr1, ..., exprN의 범위를 포함할 수 있는 타입으로 결정된다. expr1, ..., exprN에 모두 CHAR 타입이 기술된 경우, 모든 expr은 VARCHAR 타입으로 비교되고, 결과 타입은 VARCHAR 타입으로 결정된다.
사용 예
gSQL> SELECT GREATEST( 100, 0, 200, 150, 1 ) AS RESULT FROM DUAL; RESULT ------ 200 1 row selected.
HEX
구문
HEX( str )
설명
인자 str을 16진수 문자로 반환한다. 인자 str에는 CHARACTER, CHARACTER VARYING, CHARACTER LONG VARYING과 같은 CHARACTER 문자 타입 또는 문자 타입으로 변환될 수 있는 타입과 BINARY, BINARY VARYING, BINARY LONG VARYING과 같은 BINARY 문자 타입이 올 수 있다. 결과 타입은 CHARACTER VARYING 또는 CHARACTER LONG VARYING과 같은 CHARACTER 문자 타입이다.
str이 NULL이면 결과값도 NULL이다.
HEX 함수의 인자로 숫자타입이 오는 경우에는 에러를 반환한다. 10진수 숫자를 16진수로 변환하고자 하는 경우에는 'X' number format을 이용한 TO_CHAR() 함수를 사용할 수 있다. 예: TO_CHAR( 255, 'XX' )
자세한 내용은 UNHEX를 참조한다.
사용 예
gSQL> SELECT HEX( 'abc' ) FROM DUAL; HEX( 'abc' ) ------------ 616263 1 row selected.
INITCAP
구문
INITCAP( str )
설명
INITCAP 함수는 주어진 문자열 str의 각 단어들의 첫 번째 문자를 대문자로 변환하고 첫 번째 문자 이후의 문자를 소문자로 변환하여 반환한다.
인자 str에는 CHARACTER, CHARACTER VARYING, CHARACTER LONG VARYING과 같은 문자 타입이 올 수 있다.
문자열의 각 단어는 white space, 알파벳 또는 숫자가 아닌 문자로 구분한다. str이 NULL이면 결과값도 NULL이다.
인자로 받는 str의 타입과 동일한 타입이 반환된다.
사용 예
gSQL> SELECT INITCAP( 'hi GLIESE' ) AS RESULT FROM DUAL; RESULT --------- Hi Gliese 1 row selected.
INSTR
구문
INSTR( str, substr [, position [, occurrence ] ] )
설명
INSTR 함수는 str의 position부터 시작해서 occurrence 번째의 substr을 찾아 그 위치를 반환한다.
인자 str, substr에는 CHARACTER, CHARACTER VARYING, CHARACTER LONG VARYING과 같은 CHARACTER 문자 타입과 BINARY, BINARY VARYING, BINARY LONG VARYING과 같은 BINARY 문자 타입이 올 수 있다.
인자 position, occurrence에는 숫자 타입이 올 수 있다.
position과 occurrence가 생략된 경우, default 값은 1이다. position과 occurrence는 1부터 시작하며, character set에 따른 문자 단위로 계산된다. (byte 단위가 아님)
position은 str에서 substr 검색을 시작할 처음 위치를 의미하며, 0이 아닌 정수값이어야 한다.
양수인 경우: str의 앞부분에서부터 오른쪽으로 계속 비교해나가면서 substr을 찾을 때까지 position 위치를 검색한다.
음수인 경우: str의 뒷부분에서부터 왼쪽으로 계속 비교해나가면서 substr을 찾을 때까지 position 위치를 검색한다.
0인 경우: 결과값은 0이다.
occurrence는 str에서 substr이 반복된 횟수를 의미하며, 양의 정수이어야 한다. 입력 인자 중 하나라도 NULL이면 결과값도 NULL이다.
사용 예
gSQL> SELECT INSTR( 'ABCD ABCD ABCDABCD', 'BC' ) AS RESULT1,
INSTR( 'ABCD ABCD ABCDABCD', 'BC', 4 ) AS RESULT2
FROM DUAL;
RESULT1 RESULT2
------- -------
2 7
1 row selected.
gSQL> SELECT INSTR( 'ABCD ABCD ABCDABCD', 'BC', 5 , 3 ) AS RESULT1,
INSTR( 'ABCD ABCD ABCDABCD', 'BC', -5, 3 ) AS RESULT2
FROM DUAL;
RESULT1 RESULT2
------- -------
16 2
1 row selected.LAST_DAY
구문
LAST_DAY( date )
설명
LAST_DAY 함수는 date에 포함된 월의 마지막 날짜를 반환한다.
인자 date에는 DATE, TIMESTAMP, TIMESTAMP WITH TIME ZONE 타입이 올 수 있다. 반환되는 타입은 인자 date의 타입에 상관없이 항상 DATE이다. date가 NULL이면 NULL을 반환한다.
사용 예
gSQL> SELECT
LAST_DAY( TO_DATE( '2012-07-10', 'YYYY-MM-DD' ) ) AS RESULT FROM DUAL;
RESULT
----------
2012-07-31
1 row selected.LAST_IDENTITY_VALUE
구문
LAST_IDENTITY_VALUE()
설명
현재 session에서 identity column을 위해 자동으로 생성한 최근 값으로써 결과 타입은 NATIVE_BIGINT 이다.
자동 생성한 값이 없을 경우 null을 반환한다.
MS-SQL의 @@IDENTITY, MySQL의 LAST_INSERT_ID()와 유사한 기능으로, 다수의 테이블에 대해 DML을 수행할 경우 다음과 같이 마지막으로 변경한 테이블에 의해 값이 결정되므로 주의하여 사용하여야 한다.
gSQL> INSERT INTO t1(name) VALUES ( 'leekmo' );
1 row created.
gSQL> SELECT LAST_IDENTITY_VALUE() FROM dual;
LAST_IDENTITY_VALUE()
---------------------
12
1 row selected.
gSQL> INSERT INTO t2(name) VALUES ( 'leekmo' );
1 row created.
gSQL> SELECT LAST_IDENTITY_VALUE() FROM dual;
LAST_IDENTITY_VALUE()
---------------------
2
1 row selected.INSERT 할 때 생성된 identity column의 값을 얻으려면 다음과 같이 INSERT INTO name RETURNING .. INTO 구문을 사용한다.
gSQL> CREATE TABLE t1 ( id INTEGER GENERATED BY DEFAULT AS IDENTITY, name VARCHAR(32) ); Table created. gSQL> \var v1 integer gSQL> INSERT INTO t1(name) VALUES ( 'leekmo' ) RETURN id INTO :v1; V1 -- 1 1 row created.
사용 예
다음은 LAST_IDENTITY_VALUE() 함수를 사용하는 예이다.
gSQL> CREATE TABLE t1 ( id INTEGER GENERATED BY DEFAULT AS IDENTITY,
name VARCHAR(32) );
Table created.
gSQL> COMMIT;
Commit complete.현재 session에서 생성한 identity value가 없다.
gSQL> SELECT LAST_IDENTITY_VALUE() FROM dual;
LAST_IDENTITY_VALUE()
---------------------
null
1 row selected.identity value (1)를 자동으로 생성한다.
gSQL> INSERT INTO t1(name) VALUES ( 'leekmo' ); 1 row created.
Result: 1
gSQL> SELECT LAST_IDENTITY_VALUE() FROM dual;
LAST_IDENTITY_VALUE()
---------------------
1
1 row selected.Default 값으로 identity value (2)가 자동 생성된다.
gSQL> UPDATE t1 SET id = DEFAULT; 1 row updated.
Result: 2
gSQL> SELECT LAST_IDENTITY_VALUE() FROM dual;
LAST_IDENTITY_VALUE()
---------------------
2
1 row selected.사용자가 입력한 값으로 identity value가 자동으로 생성되지 않는다.
INSERT INTO t1 VALUES ( 100, 'jhkim' ); 1 row updated.
Result: 2
SELECT LAST_IDENTITY_VALUE() FROM dual;
LAST_IDENTITY_VALUE()
---------------------
2
1 row selected.LEAST
구문
LEAST( expr1 [, expr2, ... exprn ] )
설명
LEAST 함수는 인자로 받은 expr들 중에 가장 작은 값을 반환한다.
인자로 받은 expr들 중 하나라도 NULL인 경우, 결과값은 NULL이다.
결과 타입은 expr1 (첫 번째 expr)의 데이터 타입에 따라 결정된다. expr1 (첫 번째 expr)의 데이터 타입이 숫자형인 경우와 문자형인 경우에는 각각 expr1, ..., exprN의 범위를 포함할 수 있는 타입으로 결정된다. expr1, ..., exprN에 모두 CHAR 타입이 기술된 경우, 모든 expr은 VARCHAR 타입으로 비교되고, 결과 타입은 VARCHAR 타입이 된다.
사용 예
gSQL> SELECT LEAST( 100, 0, 200, 150, 1 ) AS RESULT FROM DUAL;
RESULT
------
0
1 row selected.LENGTH
구문
LENGTH( str )
설명
CHAR_LENGTH의 alias 이다.
사용 예
Multi byte character set: (예: UTF8)
gSQL> SELECT LENGTH( 'αβ-SUMMER' ) AS RESULT FROM DUAL;
RESULT
---------------
9
1 row selected.LENGTHB
구문
LENGTHB( str )
설명
OCTET_LENGTH의 alias이다. 자세한 내용은 OCTET_LENGTH, BYTE_LENGTH를 참조한다.
사용 예
Multi byte character set (예: UTF8): 1 byte character
gSQL> SELECT LENGTHB( 'OCTET_LENGTH' ) AS RESULT_1BYTE_CHARACTERS
FROM DUAL;
RESULT_1BYTE_CHARACTERS
-----------------------
12
1 row selected.Multi byte character set (예: UTF8): 2 byte character
gSQL> SELECT LENGTHB( 'αβ' ) AS RESULT_2BYTE_CHARACTERS FROM DUAL;
RESULT_2BYTE_CHARACTERS
-----------------------
4
1 row selected.LN
구문
LN( num )
설명
LN 함수는 num의 자연 로그 값을 반환하는 함수이다. num은 0보다 큰 값이어야 한다. num이 NULL이면 NULL을 반환한다.
사용 예
gSQL> SELECT LN( 2.71828182845905 ) AS RESULT FROM DUAL;
RESULT
------
1
1 row selected.LNNVL
구문
LNNVL( expr )
설명
Logical Not Null VaLue (LNNVL) 함수는 NOT logical operator와 유사하지만 다음 예제와 같이 입력값이 null일 경우 TRUE를 반환한다는 차이가 있다.
사용 예
gSQL> SELECT c1, c2, (c1 = c2), NOT(c1 = c2), LNNVL(c1 = c2) FROM t1; C1 C2 (C1 = C2) NOT(C1 = C2) LNNVL(C1 = C2) -- ---- --------- ------------ -------------- 1 1 TRUE FALSE FALSE 1 2 FALSE TRUE TRUE 1 null null null TRUE 3 rows selected.
LOCALTIME
구문
LOCALTIME [()] STATEMENT_LOCALTIME()
설명
Session 시간을 기준으로 현재 TIME WITHOUT TIME ZONE type 값을 얻는다.
LOCALTIME은 SQL 표준 함수이다.
현재 시간을 얻는 함수들 간에는 다음과 같은 차이가 있다. • TRANSACTION_LOCALTIME(): 트랜잭션 내의 모든 시간값이 동일하다. • LOCALTIME, STATEMENT_LOCALTIME(): 하나의 SQL 문장 내에서 모든 시간값이 동일하다. • CLOCK_LOCALTIME(): 함수가 호출될 때마다 현재 시간값을 얻는다.
사용 예
각 row의 시간값이 모두 같다.
gSQL> SELECT LOCALTIME FROM t1; LOCALTIME --------------- 16:17:08.592459 16:17:08.592459 16:17:08.592459 3 rows selected.
LOCALTIMESTAMP
구문
LOCALTIMESTAMP [()] STATEMENT_LOCALTIMESTAMP()
설명
Session 시간을 기준으로 현재 TIMESTAMP WITHOUT TIME ZONE type 값을 얻는다.
LOCALTIMESTAMP는 SQL 표준 함수이다.
현재 TIMESTAMP를 얻는 함수들 간에는 다음과 같은 차이가 있다. • TRANSACTION_LOCALTIMESTAMP(): 트랜잭션 내의 모든 TIMESTAMP 값이 동일하다. • LOCALTIMESTAMP, STATEMENT_LOCALTIMESTAMP(): 하나의 SQL 문장 내에서 모든 TIMESTAMP 값이 동일하다. • CLOCK_LOCALTIMESTAMP(): 함수가 호출될 때마다 현재 TIMESTAMP 값을 얻는다.
사용 예
모든 row가 같은 값을 갖는다.
gSQL> SELECT LOCALTIMESTAMP FROM t1; LOCALTIMESTAMP -------------------------- 2013-12-12 16:21:51.790614 2013-12-12 16:21:51.790614 2013-12-12 16:21:51.790614 3 rows selected.
LOCAL_GROUP_ID
구문
LOCAL_GROUP_ID()
설명
사용자 질의를 받아 처리하는 server에 대한 cluster group ID를 반환하는 함수이다.
Cluster system에서 유효한 정보이다.
사용 예
모든 row가 같은 값을 갖는다.
gSQL> SELECT LOCAL_GROUP_ID() FROM DUAL;
LOCAL_GROUP_ID()
----------------
1
1 row selected.LOCAL_GROUP_NAME
구문
LOCAL_GROUP_NAME()
설명
사용자 질의를 받아 처리하는 server에 대한 cluster group name을 반환하는 함수이다.
Cluster system에서 유효한 정보이다.
사용 예
모든 row가 같은 값을 갖는다.
gSQL> SELECT LOCAL_GROUP_NAME() FROM DUAL; LOCAL_GROUP_NAME() ------------------ G1 1 row selected.
LOCAL_MEMBER_ID
구문
LOCAL_MEMBER_ID()
설명
사용자 질의를 받아 처리하는 server에 대한 cluster member ID를 반환하는 함수이다.
Cluster system에서 유효한 정보이다.
사용 예
모든 row가 같은 값을 갖는다.
gSQL> SELECT LOCAL_MEMBER_ID() FROM DUAL;
LOCAL_MEMBER_ID()
-----------------
1
1 row selected.LOCAL_MEMBER_NAME
구문
LOCAL_MEMBER_NAME()
설명
사용자 질의를 받아 처리하는 server에 대한 cluster member name을 반환하는 함수이다.
Cluster system에서 유효한 정보이다.
사용 예
모든 row가 같은 값을 갖는다.
gSQL> SELECT LOCAL_MEMBER_NAME() FROM DUAL; LOCAL_MEMBER_NAME() ------------------- G1N1 1 row selected.
LOG
구문
LOG( num2 ) LOG( num1, num2 )
설명
LOG 함수는 밑이 num1인 num2의 로그값을 반환한다. num1이 생략된 경우에는 밑이 10으로 계산된 값이 반환된다.
num1은 1과 0이 아닌 양수이어야 하고, num2는 양수이어야 한다. num1 또는 num2가 NULL이면 NULL을 반환한다.
사용 예
gSQL> SELECT LOG( 100 ) AS RESULT1, LOG( 4, 16 ) AS RESULT2 FROM DUAL;
RESULT1 RESULT2
------- -------
2 2
1 row selected.LOGON_USER
구문
LOGON_USER()
설명
로그인 사용자를 반환한다.
사용자 정보는 다음과 같은 세 가지 형태로 관리된다.
Logon user: login을 실행한 user로서 connection을 닫을 때까지 유지된다.
Session user: 최초 logon user와 동일하지만 SET SESSION AUTHORIZATION 구문을 이용해 변경할 수 있다.
Current user: 일반적으로 session user와 동일하지만 PSM, view 등을 사용할 때 접근 제어등을 위해 시스템 내부적으로 잠시 변경된다.
Session user와 current user는 unix system의 real user와 effective user의 차이와 유사한 개념이다.
사용 예
% gsql test test gSQL> SELECT LOGON_USER() AS result FROM DUAL; RESULT ------ TEST 1 row selected.
LOWER
구문
LOWER( str )
설명
LOWER 함수는 str의 소문자를 반환한다.
인자 str에는 CHARACTER, CHARACTER VARYING, CHARACTER LONG VARYING과 같은 문자 타입이 올 수 있다. str이 NULL이면 결과값도 NULL이다.
인자 str과 동일한 타입이 반환된다.
사용 예
gSQL> SELECT LOWER( 'SPRING' ) AS RESULT FROM DUAL; RESULT ------ spring 1 row selected.
LPAD
구문
LPAD( str, length, [, fill] )
설명
LPAD 함수는 string의 길이가 length가 될 때까지 str의 왼쪽에 문자열 fill을 추가한 값을 반환한다.
인자 str에는 CHARACTER, CHARACTER VARYING, CHARACTER LONG VARYING과 같은 CHARACTER 문자 타입과 BINARY, BINARY VARYING, BINARY LONG VARYING과 같은 BINARY 문자 타입이 올 수 있다.
인자 length에는 숫자 타입이 올 수 있다.
length는 문자의 개수를 의미하며, 최대 범위는 결과 타입의 최대 PRECISION이다. fill이 생략된 경우, 공백 문자가 추가된다. str이 length보다 길이가 긴 경우에는 str을 length만큼 잘라서 반환한다. str, length, fill이 하나라도 NULL이면 결과값도 NULL이며, length가 0 또는 음수인 경우에도 결과값은 NULL이다.
결과 타입은 다음 표와 같다.
인자 str의 타입 | 결과 타입 |
|---|---|
CHAR 또는 VARCHAR | VARCHAR |
LONG VARCHAR | LONG VARCHAR |
BINARY 또는 VARBINARY | VARBINARY |
LONG VARBINARY | LONG VARBINARY |
사용 예
gSQL> SELECT LPAD('AA', 5) AS RESULT1,
LPAD('AA', 5, 'X' ) AS RESULT2,
LPAD('AA', 1 ) AS RESULT3
FROM DUAL;
RESULT1 RESULT2 RESULT3
------- ------- -------
AA XXXAA A
1 row selected.LTRIM
구문
LTRIM( trim_source [, trim_character ] )
설명
LTRIM 함수는 trim_source에서 trim_character를 왼쪽 방향에서 비교하여 일치하는 문자가 없을 때까지 제거한 결과를 반환한다.
인자 trim_character와 trim_source에는 CHARACTER, CHARACTER VARYING, CHARACTER LONG VARYING과 같은 CHARACTER 문자 타입과 BINARY, BINARY VARYING, BINARY LONG VARYING과 같은 BINARY 문자 타입이 올 수 있다.
trim_character, trim_source 중 하나라도 NULL이면, 결과값은 NULL이다.
trim_character가 생략된 경우에는 기본적으로 single blank space (' ')가 지정된다.결과 타입은 다음과 같다.
trim_source, trim_character 타입 | 결과 타입 |
|---|---|
CHAR 또는 VARCHAR | VARCHAR |
LONG VARCHAR | LONG VARCHAR |
BINARY 또는 VARBINARY | VARBINARY |
LONG VARBINARY | LONG VARBINARY |
사용 예
gSQL> SELECT LTRIM(' ltrim ') AS RESULT1,
LTRIM('______ltrim______','_') AS RESULT2
FROM DUAL;
RESULT1 RESULT2
----------- -----------
ltrim ltrim______
1 row selected.MAX
구문
MAX( [ ALL | DISTINCT ] expr )
설명
Aggregation 함수로써 row들의 expr 중 최대값을 얻는다.
ALL을 명시한 경우, 모든 값들에 대해 aggregation을 수행한다. DISTINCT를 명시한 경우, 중복을 제거한 값들에 대해 aggregation을 수행한다. ALL이나 DISTINCT를 명시하지 않은 경우, ALL을 명시한 것과 동일하게 처리한다.
MAX는 ALL과 DISTINCT에 영향을 받지 않고 동일한 결과를 낸다.
사용 예
gSQL> SELECT MAX(c1) FROM t1;
MAX(C1)
-------
3
1 row selected.MIN
구문
MIN( [ ALL | DISTINCT ] expr )
설명
Aggregation 함수로써 row들의 expr 중 최소값을 얻는다.
ALL을 명시한 경우, 모든 값들에 대해 aggregation을 수행한다. DISTINCT를 명시한 경우, 중복 제거한 값들에 대해 aggregation을 수행한다. ALL이나 DISTINCT를 명시하지 않은 경우, ALL을 명시한 것과 동일하게 처리한다.
MIN은 ALL과 DISTINCT에 영향을 받지 않고 동일한 결과를 낸다.
사용 예
gSQL> SELECT MIN(c1) FROM t1;
MIN(C1)
-------
1
1 row selected.MOD
구문
MOD( num1, num2 )
설명
MOD는 num1을 num2로 나눈 나머지를 반환한다. 인자 num1, num2에는 숫자타입이 올 수 있다. num2가 0이면 에러를 반환한다. 인자 num1 또는 num2가 NULL이면 NULL을 반환한다.
사용 예
gSQL> SELECT MOD(5, 4) AS RESULT1, MOD(-5, 4) AS RESULT2 FROM DUAL;
RESULT1 RESULT2
------- -------
1 -1
1 row selected.MONTHS_BETWEEN
구문
MONTHS_BETWEEN( date1, date2 )
설명
MONTHS_BETWEEN은 date2와 date1 사이의 일수를 31로 나눈 개월 수를 반환한다.
date1 또는 date2가 NULL이면 결과도 NULL이다. 인자 date1, date2에는 DATE, TIMESTAMP, TIMESTAMP WITH TIME ZONE 타입이 올 수 있다.
결과 타입은 NUMBER 이다.
date1과 date2 모두에 동일한 날짜가 포함되어 있거나 (예: 2014-01-15 와 2014-02-15) 월의 마지막 날짜가 포함되어 있는 경우 (예: 2014-08-31와 2014-09-30), 타임스탬프 구간 (있는 경우)의 일치 여부와 상관없이 정수 결과를 반환한다.
사용 예
gSQL> SELECT
MONTHS_BETWEEN('2018-01-18', '2018-01-17')
FROM DUAL;
MONTHS_BETWEEN('2018-01-18', '2018-01-17')
------------------------------------------
3.225806451612903E-2
1 row selected.
gSQL> SELECT
MONTHS_BETWEEN('2018-02-17', '2018-01-17')
FROM DUAL;
MONTHS_BETWEEN('2018-02-17', '2018-01-17')
------------------------------------------
1
1 row selected.
gSQL> SELECT
MONTHS_BETWEEN('2018-02-28', '2018-01-31')
FROM DUAL;
MONTHS_BETWEEN('2018-02-28', '2018-01-31')
------------------------------------------
1
1 row selected.NEXT_DAY
구문
NEXT_DAY( date, day )
설명
인자로 주어진 date (날짜)를 지나 처음으로 도래하는 day (요일)의 날짜를 구한다.
두 번째 인자 day에는 day를 지칭하는 스트링 또는 숫자가 올 수 있다. • 스트링: SUNDAY ~ SATURDAY 또는 SUN ~ SAT • 숫자: 1 (sunday) ~ 7 (saturday) 입력 인자 중 하나라도 NULL이면 결과값도 NULL이다.
반환되는 타입은 date의 입력 타입에 상관없이 항상 DATE 타입이다. 결과값의 시분초는 입력 인자 date의 시분초를 동일하게 반환한다.
사용 예
2020-08-11은 화요일이다.
gSQL> SELECT NEXT_DAY( TO_DATE( '2020-08-11', 'YYYY-MM-DD'),
'SUNDAY' ) AS RESULT1
FROM DUAL;
RESULT1
----------
2020-08-16
1 row selected.
gSQL> SELECT NEXT_DAY( TO_DATE( '2020-08-11', 'YYYY-MM-DD' ),
'SUN' ) AS RESULT1
FROM DUAL;
RESULT1
----------
2020-08-16
1 row selected.
gSQL> SELECT NEXT_DAY( TO_DATE( '2020-08-11', 'YYYY-MM-DD' ),
1 ) AS RESULT1
FROM DUAL;
RESULT1
----------
2020-08-16
1 row selected.
gSQL> SELECT TO_CHAR( NEXT_DAY( TO_DATE( '2020-08-11', 'YYYY-MM-DD' ),
'SUNDAY' ),
'YYYY-MM-DD HH24:MI:SS' ) AS RESULT1
FROM DUAL;
RESULT1
-------------------
2020-08-16 00:00:00
1 row selected.NEXTVAL
구문
seq_name.NEXTVAL NEXTVAL( seq_name ) NEXT VALUE FOR seq_name
설명
시퀀스 객체의 다음 값을 얻는다.
사용 예
gSQL> CREATE SEQUENCE seq;
Sequence created.
gSQL> COMMIT;
Commit complete.
gSQL> SELECT seq.NEXTVAL FROM dual;
SEQ.NEXTVAL
-----------
1
1 row selected.
gSQL> SELECT NEXTVAL( seq ) FROM dual;
NEXTVAL( SEQ )
--------------
2
1 row selected.
gSQL> SELECT NEXT VALUE FOR seq FROM dual;
NEXT VALUE FOR SEQ
------------------
3
1 row selected.NULLIF
구문
NULLIF( expr1, expr2 )
설명
expr1과 expr2가 같으면 null을 반환하고, 같지 않으면 첫 번째 인자인 expr1을 반환한다.
expr1과 expr2의 타입이 서로 다를 경우, 결과 타입 조합 규칙에 따라 result type이 결정된다.
NULLIF는 CASE를 사용해서 동일하게 표현할 수 있다.
NULLIF( expr1, expr2 )
CASE WHEN expr1 = expr2 THEN NULL
ELSE expr1
END사용 예
gSQL> SELECT NULLIF( 'SUN', 'SUN' ) AS RESULT1,
NULLIF( 'SUN', 'MOON' ) AS RESULT2
FROM DUAL;
RESULT1 RESULT2
------- -------
null SUN
1 row selected.NUMTODSINTERVAL
구문
NUMTODSINTERVAL( num, interval_indicator )
설명
interval_indicator 단위인 number를 interval day to second 타입으로 변환하여 반환한다.
인자 number는 숫자 타입이다.
인자 interval_indicator는 CHAR, VARCHAR와 같은 문자 타입이며, 대소문자 구분없이 'DAY', 'HOUR', 'MINUTE', 'SECOND' 중 하나여야 한다.
인자 중 하나라도 NULL이면 결과로 NULL이 반환된다.
interval day(6) to second(6) 타입의 결과를 반환하며 precision은 사용자가 임의로 변경할 수 없다. 변환된 결과의 leading precision이 기본 precision을 초과하면 에러가 반환되며, fraction precision이 기본 precision을 초과하면 반올림한 결과를 반환한다.
사용 예
1 Day를 interval day to second 타입으로 변환한다.
gSQL> SELECT NUMTODSINTERVAL(1, 'DAY') FROM DUAL; NUMTODSINTERVAL(1, 'DAY') ------------------------- +000001 00:00:00.000000 1 row selected.
36 Hour를 interval day to second 타입으로 변환한다.
gSQL> SELECT NUMTODSINTERVAL(36, 'HOUR') FROM DUAL; NUMTODSINTERVAL(36, 'HOUR') --------------------------- +000001 12:00:00.000000 1 row selected.
1530 Minute를 interval day to second 타입으로 변환한다.
gSQL> SELECT NUMTODSINTERVAL(1530, 'MINUTE') FROM DUAL; NUMTODSINTERVAL(1530, 'MINUTE') ------------------------------- +000001 01:30:00.000000 1 row selected.
90100.1234567 Second를 interval day to second로 변환한다.
gSQL> SELECT NUMTODSINTERVAL(90100.1234567, 'SECOND') FROM DUAL; NUMTODSINTERVAL(90100.1234567, 'SECOND') ---------------------------------------- +000001 01:01:40.123457 1 row selected.
NUMTOYMINTERVAL
구문
NUMTOYMINTERVAL( num, interval_indicator )
설명
interval_indicator 단위인 number를 interval year to month 타입으로 변환하여 반환한다.
인자 number는 숫자 타입이다.
인자 interval_indicator는 CHAR, VARCHAR와 같은 문자 타입이며, 대소문자 구분없이 'YEAR', 'MONTH' 중 하나여야 한다.
인자 중 하나라도 NULL이면 결과로 NULL이 반환된다.
interval year(6) to month 타입을 결과로 반환하며 precision은 사용자가 임의로 변경할 수 없다. 변환된 결과의 leading precision이 기본 precision을 초과하면 에러가 반환된다.
사용 예
1 Year를 interval year to month로 변환한다.
gSQL> SELECT NUMTOYMINTERVAL(1, 'YEAR') FROM DUAL; NUMTOYMINTERVAL(1, 'YEAR') -------------------------- +000001-00 1 row selected.
13.5 Month를 interval year to month로 변환한다.
gSQL> SELECT NUMTOYMINTERVAL(13.5, 'MONTH') FROM DUAL; NUMTOYMINTERVAL(13.5, 'MONTH') ------------------------------ +000001-02 1 row selected.
NVL
구문
NVL( expr1, expr2 )
설명
expr1이 null이 아니면 expr1을 반환하고, expr1이 null이면 expr2를 반환한다.
결과 타입은 expr1의 데이터 타입에 따라 결정된다. expr1에 NULL이 기술된 경우에는 expr2의 타입에 따라 결과 타입이 결정된다. expr1의 데이터 타입이 숫자형 타입인 경우와 문자형 타입인 경우는 각각 expr1, expr2의 범위를 포함할 수 있는 타입으로 결정된다. expr1, expr2의 데이터 타입이 모두 CHAR 타입인 경우, 결과 타입은 VARCHAR로 결정된다.
사용 예
gSQL> SELECT I1, NVL( I1, 0 ) FROM T1; I1 NVL( I1, 0 ) ---- ------------ 1 1 null 0 2 rows selected.
NVL2
구문
NVL2( expr1, expr2, expr3 )
설명
expr1이 null이 아니면 expr2를 반환하고, expr1이 null이면 expr3을 반환한다.
결과 타입은 expr2의 데이터 타입에 따라 결정된다. expr2에 NULL이 기술된 경우에는 expr3의 타입에 따라 결과 타입이 결정된다. expr2의 데이터 타입이 숫자형인 경우와 문자형인 경우에는 각각 expr2, expr3의 범위를 포함할 수 있는 타입으로 결정된다. expr2, expr3의 데이터 타입이 모두 CHAR 타입인 경우, 결과 타입은 VARCHAR가 된다.
사용 예
gSQL> SELECT I1, NVL2( I1, I1 * 1000, 0 ) FROM T1; I1 NVL2( I1, I1 * 1000, 0 ) ---- ------------------------ 1 1000 null 0 2 rows selected.
OCTET_LENGTH
구문
OCTET_LENGTH( str ) BYTE_LENGTH( str ) LENGTHB( str )
설명
OCTET_LENGTH는 str의 바이트 수를 반환한다.
인자 str에는 CHARACTER, CHARACTER VARYING, CHARACTER LONG VARYING과 같은 CHARACTER 문자 타입과 BINARY, BINARY VARYING, BINARY LONG VARYING과 같은 BINARY 문자 타입이 올 수 있다.
str의 타입이 CHARACTER면 공백문자도 계산에 포함된다. str이 NULL이면 결과값도 NULL이다.
OCTET_LENGTH의 alias로는 BYTE_LENGTH와 LENGTHB 함수가 있다.
사용 예
Multi byte character set (예: UTF8): 1 byte character
gSQL> SELECT OCTET_LENGTH( 'OCTET_LENGTH' ) AS RESULT_1BYTE_CHARACTERS
FROM DUAL;
RESULT_1BYTE_CHARACTERS
-----------------------
12
1 row selected.Multi byte character set (예: UTF8): 2 byte character
gSQL> SELECT OCTET_LENGTH( 'αβ' ) AS RESULT_2BYTE_CHARACTERS FROM DUAL;
RESULT_2BYTE_CHARACTERS
-----------------------
4
1 row selected.OVERLAY
구문
OVERLAY( str1 PLACING str2 FROM start_position [ FOR string_length ] )
설명
OVERLAY 함수는 str1의 start_position부터 string_length까지의 문자를 str2로 치환한 결과를 반환한다.
인자 str1과 str2에는 CHARACTER, CHARACTER VARYING, CHARACTER LONG VARYING과 같은 CHARCATER 문자 타입과 BINARY, BINARY VARYING, BINARY LONG VARYING과 같은 BINARY 문자 타입이 올 수 있다. 인자 start_position과 string_length에는 숫자 타입이 올 수 있다.
OVERLAY 결과는 다음과 같다.
FOR가 지정된 경우
SUBSTRING( str1 FROM 1 FOR (start_position - 1) )
|| str2
|| SUBSTRING( str1 FROM (start_position + string_length )
FOR가 생략된 경우
SUBSTRING( str1 FROM 1 FOR (start_position - 1) )
|| str2
|| SUBSTRING( str1 FROM (start_position + CHAR_LENGTH(str2))
자세한 내용은 SUBSTRING을 참조한다.
결과 타입은 다음 표와 같다.
str1, str2 타입 | 결과 타입 |
|---|---|
CHAR 또는 VARCHAR | VARCHAR |
LONG VARCHAR | LONG VARCHAR |
BINARY 또는 VARBINARY | VARBINARY |
LONG VARBINARY | LONG VARBINARY |
사용 예
gSQL> SELECT
OVERLAY( 'RESULT_OF_XXX_FUNC' PLACING 'OVERLAY' FROM 11 )
AS RESULT1,
OVERLAY( 'RESULT_OF_XXX_FUNC' PLACING 'OVERLAY' FROM 11 FOR 3 )
AS RESULT2
FROM DUAL;
RESULT1 RESULT2
------------------ ----------------------
RESULT_OF_OVERLAYC RESULT_OF_OVERLAY_FUNC
1 row selected.PHYSICAL_LENGTH
구문
PHYSICAL_LENGTH( expr )
설명
PHYSICAL_LENGTH 함수는 expr의 내부 표현 정보 byte 수를 반환한다.
인자 expr에는 모든 데이터 타입이 올 수 있다.
입력 인자가 NULL이면 결과는 0 이다.
사용 예
입력 인자가 NULL인 경우
gSQL> SELECT PHYSICAL_LENGTH( NULL ) AS RESULT FROM DUAL;
RESULT
------
0
1 row selected.다음은 1, 123, 12345의 NUMBER type byte 수를 보여주는 예이다.
gSQL> SELECT PHYSICAL_LENGTH( 1 ) AS RESULT FROM DUAL;
RESULT
------
2
1 row selected.
gSQL> SELECT PHYSICAL_LENGTH( 123 ) AS RESULT FROM DUAL;
RESULT
------
3
1 row selected.
gSQL> SELECT PHYSICAL_LENGTH( 12345 ) AS RESULT FROM DUAL;
RESULT
------
4
1 row selected.PI
구문
PI()
설명
PI는 "π" constant를 반환한다.
사용 예
gSQL> SELECT PI() AS RESULT FROM DUAL;
RESULT
--------------------
3.141592653589793E+0
1 row selected.POSITION
구문
POSITION( str1 IN str2 )
설명
POSITION 함수는 str2에서 첫 번째 str1을 찾아 그 위치를 반환하는 함수이다.
str1과 str2에는 CHARACTER, CHARACTER VARYING, CHARACTER LONG VARYING과 같은 CHARACTER 문자 타입과 BINARY, BINARY VARYING, BINARY LONG VARYING과 같은 BINARY 문자 타입이 올 수 있다.
str2에서 str1을 찾을 수 없는 경우, 리턴값 0이 반환된다. str2에서 str1을 찾은 경우, 1을 시작으로 그 찾은 위치를 반환한다. 반환되는 위치값은 CHARACTER 단위로 계산된 값이다. (byte 단위가 아님) str1 또는 str2가 NULL이면, 반환되는 값도 NULL 이다.
사용 예
gSQL> SELECT POSITION( 'CHAR' IN 'LONG CHAR 2000' ) AS RESULT FROM DUAL;
RESULT
------
6
1 row selected.POWER
구문
POWER( num1, num2 )
설명
POWER 함수는 num1에 num2를 제곱한 값을 반환한다.
인수 num1과 num2에는 숫자 타입이 올 수 있다. num1이 음수이면, num2는 정수여야 한다. num1 또는 num2의 값이 NULL이면, 결과값도 NULL이다.
사용 예
gSQL> SELECT POWER( 2, 3 ) AS RESULT FROM DUAL;
RESULT
------
8
1 row selected.RADIANS
구문
RADIANS( degrees )
설명
RADIANS 함수는 degrees의 라디안을 반환한다. 인자 degrees에는 숫자 타입이 올 수 있다. 인자 degrees가 NULL이면 NULL을 반환한다.
사용 예
gSQL> SELECT RADIANS( 180 ) AS RESULT FROM DUAL;
RESULT
----------------
3.14159265358979
1 row selected.RANDOM
구문
RANDOM( min, max )
설명
RANDOM은 min 이상 max 이하의 random 값을 반환한다. 인자 min, max에는 숫자 타입이 올 수 있다. 인자 min 또는 max가 NULL이면 NULL을 반환한다.
사용 예
gSQL> SELECT RANDOM( 1, 100 ) AS RESULT FROM DUAL;
RESULT
----------------
34.1870528003201
1 row selected.REPEAT
구문
REPEAT( str, num )
설명
REPEAT 함수는 num에 지정된 수만큼 str을 반복한 string을 반환한다.
인자 str에는 CHARACTER, CHARACTER VARYING, CHARACTER LONG VARYING과 같은 CHARCATER 문자 타입과 BINARY, BINARY VARYING, BINARY LONG VARYING과 같은 BINARY 문자 타입이 올 수 있다.
인자 num에는 숫자 타입이 올 수 있다.
str 또는 num 중의 하나라도 NULL이면, 결과값도 NULL이다. num의 값이 0 또는 음수인 경우에도 결과값은 NULL이다.
결과 타입은 다음 표와 같다.
str 타입 | 결과 타입 |
|---|---|
CHAR 또는 VARCHAR | VARCHAR |
LONG VARCHAR | LONG VARCHAR |
BINARY 또는 VARBINARY | VARBINARY |
LONG VARBINARY | LONG VARBINARY |
사용 예
gSQL> SELECT REPEAT( 'ab', 3 ) AS RESULT FROM DUAL; RESULT ------ ababab 1 row selected.
REPLACE
구문
REPLACE( str, from, to )
설명
REPLACE는 str string 내의 모든 from string을 to string으로 치환하여 반환한다.
인자 str, from, to에는 CHARACTER, CHARACTER VARYING, CHARACTER LONG VARYING과 같은 CHARACTER 문자 타입이 올 수 있다.
str 값이 NULL인 경우, 결과값은 NULL이다. from 값이 NULL인 경우, str 값을 변환하지 않고 반환한다. to 값이 생략되었거나 NULL인 경우, str에서 from을 제거한 값이 반환된다.
결과 타입은 다음 표와 같다.
str 타입 | 결과 타입 |
|---|---|
CHAR 또는 VARCHAR | VARCHAR |
LONG VARCHAR | LONG VARCHAR |
사용 예
gSQL> SELECT REPLACE( 'HI GLIESE', 'HI', 'HELLO' ) AS RESULT FROM DUAL; RESULT ------------ HELLO GLIESE 1 row selected.
REVERSE
구문
REVERSE( str )
설명
REVERSE는 str의 문자를 역순으로 반환한다.
인자로는 character string 타입 또는 binary string 타입으로 변환될 수 있는 타입이 올 수 있으며 character string 타입은 해당 문자 단위로, binary string 타입은 byte 단위로 수행된다.
str이 NULL일 경우 NULL을 반환한다.
인자와 결과 타입은 다음 표와 같다.
str | 결과 타입 |
|---|---|
CHAR | CHAR |
VARCHAR | VARCHAR |
LONG VARCHAR | LONG VARCHAR |
BINARY | BINARY |
VARBINARY | VARBINARY |
LONG VARBINARY | LONG VARBINARY |
사용 예
gSQL> SELECT REVERSE( 'GOLDILOCKS' ) AS RESULT FROM DUAL; RESULT ---------- SKCOLIDLOG 1 row selected. gSQL> SELECT REVERSE( '선재소프트 2018' ) AS RESULT FROM DUAL; RESULT --------------- 8102 트프소재선 1 row selected.
ROUND( number )
구문
ROUND( num [, scale ] )
설명
ROUND는 scale을 기준으로 num을 반올림한 값을 반환한다.
인자 num, scale에는 숫자 타입이 올 수 있다.
scale이 생략된 경우, scale은 0이 되어 ROUND( num, 0 )와 같이 수행된다. scale이 양수인 경우 소수점 오른쪽 자리수를 기준으로 반올림되고, scale이 음수인 경우 소수점 왼쪽 자리수를 기준으로 반올림된다. 인자 num 또는 scale이 NULL이면 NULL을 반환한다.
사용 예
gSQL> SELECT ROUND( 152.4282, 2 ) AS RESULT FROM DUAL; RESULT ------ 152.43 1 row selected. gSQL> SELECT ROUND( 152.4282, -2 ) AS RESULT FROM DUAL; RESULT ------ 200 1 row selected.
ROUND( date )
구문
ROUND( date [ , fmt ] )
설명
ROUND( date ) 함수는 date를 지정된 fmt 단위로 반올림한 값을 반환한다.
인자 date에는 DATE, TIMESTAMP, TIMESTAMP WITH TIME ZONE 타입이 올 수 있다. 인자 fmt에는 CHARACTER, CHARACTER VARYING과 같은 CHARACTER 문자 타입이 올 수 있다. 인자 date 또는 fmt가 NULL이면 NULL을 반환한다. 결과 타입은 인자로 받은 date 타입과 관계없이 항상 DATE 타입이다.
fmt가 생략되었을 경우의 기본값은 DAY 이며, 사용 가능한 형식문자열은 다음 표와 같다.
문자열 | 설명 |
|---|---|
CC, SCC | 51년부터 반올림하여 네자리 연도로 표현한다. (예: XX01) |
YYYY, YEAR, SYYYY, SYEAR, YYY, YY, Y | 7월 1일부터 반올림한다. |
IYYY, IYY, IY, I | ISO 8601 표준에 정의된 calendar week를 수용하는 연도로써 7월 1일부터 반올림한다. |
Q | 분기의 두 번째 달의 16일부터 반올림한다. |
MONTH, MON, MM, RM | 16일부터 반올림한다. |
WW | 연도의 1월 1일부터 한 주가 시작되며 해당 WEEK의 수요일 오후 12시부터 반올림한다. |
IW | ISO 8601 표준에 정의된 calendar week (1 ~ 52주 또는 1 ~ 53주)로써 목요일 오후 12시부터 반올림한다. |
W | 월의 1일을 한 주로 시작해서 해당 WEEK의 수요일 오후 12시부터 반올림한다. |
DDD, DD, J | 오후 12시부터 반올림한다. |
DAY, DY, D | WEEK의 수요일 오후 12시부터 반올림한다. |
HH, HH12, HH24 | 30 분부터 반올림한다. |
MI | 30 초부터 반올림한다. |
사용 예
gSQL> SELECT
ROUND( TO_DATE( '2051-07-16', 'YYYY-MM-DD' ), 'CC' ) AS RESULT
FROM DUAL;
RESULT
----------
2101-01-01
1 row selected.
gSQL> SELECT
ROUND( TO_DATE( '2051-07-16', 'YYYY-MM-DD' ), 'YYYY' ) AS RESULT
FROM DUAL;
RESULT
----------
2052-01-01
1 row selected.
gSQL> SELECT
ROUND( TO_DATE( '2051-07-16', 'YYYY-MM-DD' ), 'MONTH' ) AS RESULT
FROM DUAL;
RESULT
----------
2051-08-01
1 row selected.
gSQL> SELECT
ROUND( TO_TIMESTAMP( '2001-05-05 15:22:33.999999',
'YYYY-MM-DD HH24:MI:SS.FF6' ) ) AS RESULT
FROM DUAL;
RESULT
----------
2001-05-06
1 row selected.ROWID_GRID_BLOCK_ID
구문
ROWID_GRID_BLOCK_ID( rowid )
설명
GRID block ID를 반환하는 함수이다.
Cluster system에서 유효한 정보이다.
사용 예
gSQL> SELECT C1, ROWID_GRID_BLOCK_ID( ROWID ) FROM T1; C1 ROWID_GRID_BLOCK_ID( ROWID ) -- ---------------------------- 1 52 2 52 3 52 3 rows selected.
ROWID_GRID_BLOCK_SEQ
구문
ROWID_GRID_BLOCK_SEQ( rowid )
설명
GRID block sequence를 반환하는 함수이다.
Cluster system에서 유효한 정보이다.
사용 예
gSQL> SELECT C1, ROWID_GRID_BLOCK_SEQ( ROWID ) FROM T1; C1 ROWID_GRID_BLOCK_SEQ( ROWID ) -- ----------------------------- 1 747465 2 747466 3 747467 3 rows selected.
ROWID_MEMBER_ID
구문
ROWID_MEMBER_ID( rowid )
설명
Member ID를 반환하는 함수이다.
Cluster system에서 유효한 정보이다.
사용 예
gSQL> SELECT C1, ROWID_MEMBER_ID( ROWID ) FROM T1; C1 ROWID_MEMBER_ID( ROWID ) -- ------------------------ 1 1 2 1 3 1 3 rows selected.
ROWID_OBJECT_ID
구문
ROWID_OBJECT_ID( rowid )
설명
Object ID를 반환하는 함수이다.
Cluster system에서 유효하지 않은 정보이다.
사용 예
gSQL> SELECT ROWID_OBJECT_ID( t1.ROWID ) FROM t1;
ROWID_OBJECT_ID( T1.ROWID )
---------------------------
22012
22012
22012
22012
4 rows selected.ROWID_PAGE_ID
구문
ROWID_PAGE_ID( rowid )
설명
Page ID를 반환하는 함수이다.
Cluster system에서 유효하지 않은 정보이다.
사용 예
gSQL> SELECT ROWID_PAGE_ID( t1.ROWID ) FROM t1;
ROWID_PAGE_ID( T1.ROWID )
-------------------------
8227
8227
8227
8227
4 rows selected.ROWID_ROW_NUMBER
구문
ROWID_ROW_NUMBER( rowid )
설명
Row number를 반환하는 함수이다.
Cluster system에서 유효하지 않은 정보이다.
사용 예
gSQL> SELECT ROWID_ROW_NUMBER( t1.ROWID ) FROM t1;
ROWID_ROW_NUMBER( T1.ROWID )
----------------------------
0
1
2
3
4 rows selected.ROWID_SHARD_ID
구문
ROWID_SHARD_ID( rowid )
설명
Shard ID를 반환하는 함수이다.
Cluster system에서 유효한 정보이다.
사용 예
gSQL> SELECT C1, ROWID_SHARD_ID( ROWID ) FROM T1; C1 ROWID_SHARD_ID( ROWID ) -- ----------------------- 1 0 2 1 3 2 3 rows selected.
ROWID_TABLESPACE_ID
구문
ROWID_TABLESPACE_ID( rowid )
설명
Tablespace ID를 반환하는 함수이다.
Cluster system에서 유효하지 않은 정보이다.
사용 예
gSQL> SELECT ROWID_TABLESPACE_ID( t1.ROWID ) FROM t1;
ROWID_TABLESPACE_ID( T1.ROWID )
-------------------------------
2
2
2
2
4 rows selected.ROWNUM
구문
ROWNUM
설명
WHERE 조건을 만족하는 row에 대하여 1부터 순차적으로 번호를 부여한다.
Oracle과의 호환성을 위해 WHERE 절에 ROWNUM 사용을 허용한다.
그러나 질의 결과의 개수를 제한하려면 다음과 같이 SQL 표준의 offset limit clause를 사용할 것을 권장한다.
(비표준) ROWNUM을 이용하여 결과 개수 기술
gSQL> SELECT * FROM t1 WHERE ROWNUM <= 3; C1 -- A B C 3 rows selected.
(SQL 표준) FETCH 구문을 이용하여 결과 개수 기술
gSQL> SELECT * FROM t1 FETCH 3; C1 -- A B C 3 rows selected.
질의 결과의 일부 범위를 제한하고자 할 때도 다음과 같이 OFFSET, FETCH 구문을 사용할 것을 권장한다.
(비표준) ROWNUM을 이용하여 결과 개수의 범위 기술
gSQL> SELECT c1
FROM ( SELECT ROWNUM rn, c1
FROM t1 )
WHERE rn BETWEEN 2 AND 3;
C1
--
B
C
2 rows selected.(SQL 표준) OFFSET, FETCH 구문을 이용하여 결과 개수의 범위 기술
gSQL> SELECT c1 FROM t1 OFFSET 1 FETCH 2; C1 -- B C 2 rows selected.
결과 개수 제한 이외의 용도로 ROWNUM을 WHERE 절에 사용하는 것은 권장하지 않는다.
다음 예와 같이 모호한 조건 (WHERE c1 < ROWNUM + 3)을 사용할 경우, 실행 방법에 따라 동일한 질의에 대한 결과가 달라질 수 있다.
데이터 생성
CREATE TABLE t1 ( c1 INTEGER ); CREATE INDEX t1_idx ON t1(c1); INSERT INTO t1 VALUES (1); INSERT INTO t1 VALUES (2); INSERT INTO t1 VALUES (3); INSERT INTO t1 VALUES (4); INSERT INTO t1 VALUES (5); COMMIT;
Oracle의 경우
SQL> SELECT ROWNUM, c1 FROM t1 WHERE c1 < ROWNUM + 3;
ROWNUM C1
---------- ----------
1 1
2 2
SQL> DROP INDEX t1_idx;N/A
인덱스가 삭제되었다.
SQL> SELECT ROWNUM, c1 FROM t1 WHERE c1 < ROWNUM + 3;
ROWNUM C1
---------- ----------
1 1
2 2
3 3
4 4
5 5GOLDILOCKS의 경우
gSQL> SELECT ROWNUM, c1 FROM t1 WHERE c1 < ROWNUM + 3;
ROWNUM C1
------ --
1 1
2 2
3 3
4 4
5 5
5 rows selected.
gSQL> DROP INDEX t1_idx;
Index dropped.
gSQL> SELECT ROWNUM, c1 FROM t1 WHERE c1 < ROWNUM + 3;
ROWNUM C1
------ --
1 1
2 2
3 3
4 4
5 5
5 rows selected.사용 예
gSQL> SELECT ROWNUM, c1 FROM t1;
ROWNUM C1
------ --
1 A
2 B
3 C
4 D
5 E
5 rows selected.RPAD
구문
RPAD( str, length, [, fill] )
설명
RPAD 함수는 string의 길이가 length가 될 때까지 str의 오른쪽에 문자열 fill을 추가한 값을 반환한다.
인자 str에는 CHARACTER, CHARACTER VARYING, CHARACTER LONG VARYING과 같은 CHARACTER 문자 타입과 BINARY, BINARY VARYING, BINARY LONG VARYING과 같은 BINARY 문자 타입이 올 수 있다.
인자 length에는 숫자 타입이 올 수 있다.
length는 문자의 개수를 의미하며 최대 범위는 결과 타입의 최대 PRECISION이다. fill이 생략된 경우, 공백 문자가 추가된다. str이 length보다 길이가 긴 경우에는 str을 length만큼 잘라서 반환한다. str, length, fill 중 하나라도 NULL이면 결과값도 NULL이며, length가 0 또는 음수인 경우에도 결과값은 NULL이다.
결과 타입은 다음 표와 같다.
인자 str의 타입 | 결과 타입 |
|---|---|
CHAR 또는 VARCHAR | VARCHAR |
LONG VARCHAR | LONG VARCHAR |
BINARY 또는 VARBINARY | VARBINARY |
LONG VARBINARY | LONG VARBINARY |
사용 예
gSQL> SELECT RPAD('AA', 5) AS RESULT1,
RPAD('AA', 5, 'X') AS RESULT2,
RPAD('AA', 1) AS RESULT3
FROM DUAL;
RESULT1 RESULT2 RESULT3
------- ------- -------
AA AAXXX A
1 row selected.RTRIM
구문
RTRIM( trim_source [, trim_character ] )
설명
RTRIM 함수는 trim_source에서 trim_character를 오른쪽 방향에서 비교하여 일치하는 문자가 없을 때까지 제거한 결과를 반환한다.
인자 trim_character와 trim_source에는 CHARACTER, CHARACTER VARYING, CHARACTER LONG VARYING과 같은 CHARACTER 문자 타입과 BINARY, BINARY VARYING, BINARY LONG VARYING과 같은 BINARY 문자 타입이 올 수 있다.
trim_character, trim_source 중 하나라도 NULL이면, 결과값은 NULL이다.
trim_character가 생략된 경우에는 기본적으로 single blank space (' ')가 지정된다.결과 타입은 다음과 같다.
trim_source, trim_character 타입 | 결과 타입 |
|---|---|
CHAR 또는 VARCHAR | VARCHAR |
LONG VARCHAR | LONG VARCHAR |
BINARY 또는 VARBINARY | VARBINARY |
LONG VARBINARY | LONG VARBINARY |
사용 예
gSQL> SELECT RTRIM(' rtrim ') AS RESULT1,
RTRIM('______rtrim______','_') AS RESULT2
FROM DUAL;
RESULT1 RESULT2
----------- -----------
rtrim ______rtrim
1 row selected.SESSION_ID
구문
SESSION_ID()
설명
현재 session의 ID를 얻는다.
사용 예
gSQL> SELECT SESSION_ID() FROM dual;
SESSION_ID()
------------
4
1 row selected.SESSION_SERIAL
구문
SESSION_SERIAL()
설명
현재 session의 serial 번호를 얻는다.
사용 예
gSQL> SELECT SESSION_SERIAL() FROM dual;
SESSION_SERIAL()
----------------
16
1 row selected.SESSION_USER
구문
SESSION_USER[()]
설명
세션 사용자를 반환한다.
사용자 정보는 다음과 같은 세 가지 형태로 관리된다.
Logon user: login을 실행한 user로서 connection을 닫을 때까지 유지된다.
Session user: 최초 logon user와 동일하지만 SET SESSION AUTHORIZATION 구문을 이용해 변경할 수 있다.
Current user: 일반적으로 session user와 동일하지만 PSM, view 등을 사용할 때 접근 제어등을 위해 시스템 내부적으로 잠시 변경된다.
Session user와 current user는 unix system의 real user와 effective user의 차이와 유사한 개념이다.
사용 예
% gsql sys gliese gSQL> SET SESSION AUTHORIZATION test; Session set. gSQL> SELECT LOGON_USER() AS result1, SESSION_USER() AS result2 FROM DUAL; RESULT1 RESULT2 ------- ------- SYS TEST 1 row selected.
SHARD_GROUP_ID
구문
SHARD_GROUP_ID( table_name, shard_key_value [, ... ] )
설명
SHARD_GROUP_ID 함수는 table_name에 shard strategy가 정의된 경우, shard_key_value 값을 저장할 수 있는 shard를 관리하는 group ID를 반환한다.
입력 인자 table_name은 identifier로 기술하여야 하며 table_name에 해당하는 객체가 base table이 아니거나 shard strategy가 정의되지 않은 경우 에러가 발생한다.
입력 인자 shard_key_value는 table_name에 정의된 shard strategy의 shard key column 순으로 나열되어야 한다. shard_key_value 개수와 shard key column 개수가 일치하지 않을 경우, 에러가 발생한다.
결과 타입은 NATIVE_BIGINT이다.
Cluster system에서 유효한 정보이다.
사용 예
gSQL> SELECT T1.C1, SHARD_GROUP_ID( T1, T1.C1 ) FROM T1;
C1 SHARD_GROUP_ID( T1, T1.C1 )
-- ---------------------------
A 1
B 2
C 3
3 rows selected.
gSQL> SELECT SHARD_GROUP_ID( T1, 'B' ) FROM DUAL;
SHARD_GROUP_ID( T1, 'B' )
-------------------------
2
1 row selected.SHARD_GROUP_NAME
구문
SHARD_GROUP_NAME( table_name, shard_key_value [, ... ] )
설명
SHARD_GROUP_NAME 함수는 table_name에 shard strategy가 정의된 경우, shard_key_value 값을 저장할 수 있는 shard를 관리하는 group NAME을 반환한다.
입력 인자 table_name은 identifier로 기술하여야 하며 table_name에 해당하는 객체가 base table이 아니거나 shard strategy가 정의되지 않은 경우, 에러가 발생한다.
입력 인자 shard_key_value는 table_name에 정의된 shard strategy의 shard key column 순으로 나열되어야 한다. shard_key_value 개수와 shard key column 개수가 일치하지 않을 경우, 에러가 발생한다.
결과 타입은 VARCHAR이다.
Cluster system에서 유효한 정보이다.
사용 예
gSQL> SELECT T1.C1, SHARD_GROUP_NAME( T1, T1.C1 ) FROM T1; C1 SHARD_GROUP_NAME( T1, T1.C1 ) -- ----------------------------- A G1 B G2 C G3 3 rows selected. gSQL> SELECT SHARD_GROUP_NAME( T1, 'B' ) FROM DUAL; SHARD_GROUP_NAME( T1, 'B' ) --------------------------- G2 1 row selected.
SHARD_ID
구문
SHARD_ID( table_name, shard_key_value [, ... ] )
설명
SHARD_ID 함수는 table_name에 shard strategy가 정의된 경우, shard_key_value 값을 저장할 수 있는 shard에 대한 ID를 반환한다.
입력 인자 table_name은 identifier로 기술하여야 하며 table_name에 해당하는 객체가 base table이 아니거나 shard strategy가 정의되지 않은 경우, 에러가 발생한다.
입력 인자 shard_key_value는 table_name에 정의된 shard strategy의 shard key column 순으로 나열되어야 한다. shard_key_value 개수와 shard key column 개수가 일치하지 않을 경우, 에러가 발생한다.
결과 타입은 NATIVE_BIGINT이다.
Cluster system에서 유효한 정보이다.
사용 예
gSQL> SELECT T1.C1, SHARD_ID( T1, T1.C1 ) FROM T1;
C1 SHARD_ID( T1, T1.C1 )
-- ---------------------
A 0
B 1
C 2
3 rows selected.
gSQL> SELECT SHARD_ID( T1, 'B' ) FROM DUAL;
SHARD_ID( T1, 'B' )
-------------------
1
1 row selected.SHARD_NAME
구문
SHARD_NAME( table_name, shard_key_value [, ... ] )
설명
SHARD_NAME 함수는 table_name에 shard strategy가 정의된 경우, shard_key_value 값을 저장할 수 있는 shard에 대한 NAME을 반환한다.
입력 인자 table_name은 identifier로 기술하여야 하며 table_name에 해당하는 객체가 base table이 아니거나 shard strategy가 정의되지 않은 경우, 에러가 발생한다.
입력 인자 shard_key_value는 table_name에 정의된 shard strategy의 shard key column 순으로 나열되어야 한다. shard_key_value 개수와 shard key column 개수가 일치하지 않을 경우, 에러가 발생한다.
결과 타입은 VARCHAR이다.
Cluster system에서 유효한 정보이다.
사용 예
gSQL> SELECT T1.C1, SHARD_NAME( T1, T1.C1 ) FROM T1; C1 SHARD_NAME( T1, T1.C1 ) -- ----------------------- A S1 B S2 C S3 3 rows selected. gSQL> SELECT SHARD_NAME( T1, 'B' ) FROM DUAL; SHARD_NAME( T1, 'B' ) --------------------- S2 1 row selected.
SHIFT_LEFT
구문
SHIFT_LEFT( num, cnt )
설명
SHIFT_LEFT 함수는 num을 cnt 비트만큼 왼쪽으로 이동시킨 값을 반환한다.
입력 인자 num, cnt에는 NATIVE_SMALLINT, NATIVE_INTEGER, NATIVE_BIGINT 또는 NATIVE_BIGINT로 변환될 수 있는 타입이 올 수 있다. NATIVE_BIGINT 타입으로 변환하면 소수점은 TRUNCATE 된다.
연산 시 cnt는 6 bit로 마스킹하여 6 bit 범위 내의 값으로 처리한다.
num 또는 cnt가 NULL이면 NULL을 반환한다.
결과 타입은 NATIVE_BIGINT이다.
사용 예
gSQL> SELECT SHIFT_LEFT(1, 3) FROM DUAL;
SHIFT_LEFT(1, 3)
----------------
8
1 row selected.SHIFT_RIGHT
구문
SHIFT_RIGHT( num, cnt )
설명
SHIFT_RIGHT 함수는 num을 cnt 비트만큼 오른쪽으로 이동시킨 값을 반환한다.
입력 인자 num, cnt에는 NATIVE_SMALLINT, NATIVE_INTEGER, NATIVE_BIGINT 또는 NATIVE_BIGINT로 변환될 수 있는 타입이 올 수 있다. NATIVE_BIGINT 타입으로 변환하면 소수점은 TRUNCATE 된다.
연산 시 cnt는 6 bit로 마스킹하여 6 bit 범위내의 값으로 처리한다.
num 또는 cnt가 NULL이면 NULL을 반환한다.
결과 타입은 NATIVE_BIGINT이다.
사용 예
gSQL> SELECT SHIFT_RIGHT(8, 3) FROM DUAL;
SHIFT_RIGHT(8, 3)
-----------------
1
1 row selected.SIGN
구문
SIGN( num )
설명
SIGN 함수는 num의 부호를 반환한다.
인자 num에는 숫자타입이 올 수 있다.
반환값은 다음과 같다. • num < 0 이면 -1 • num = 0 이면 0 • num > 0 이면 1 num이 NULL이면 NULL을 반환한다.
사용 예
gSQL> SELECT SIGN(-10) AS RESULT1,
SIGN(0) AS RESULT2,
SIGN(10) AS RESULT3 FROM DUAL;
RESULT1 RESULT2 RESULT3
------- ------- -------
-1 0 1
1 row selected.SIN
구문
SIN( num )
설명
SIN 함수는 num의 sine 값을 반환한다. num이 NULL이면 NULL을 반환한다.
사용 예
gSQL> SELECT SIN( 0 ) AS RESULT FROM DUAL;
RESULT
------
0
1 row selected.SPLIT_PART
구문
SPLIT_PART( string, delimiter, field )
설명
SPLIT_PART 함수는 string 내에서 delimiter로 지정된 문자를 구분자로 하여 field의 문자열을 반환한다.
인자 string, delimiter에는 CHARACTER, CHARACTER VARYING, CHARACTER LONG VARYING과 같은 CHARACTER 문자 타입이 올 수 있다.
인자 field에는 숫자 타입이 올 수 있다.
string, delimiter, field 중에 하나라도 NULL인 경우에는 결과값도 NULL이다. field에는 1 이상의 숫자값만 올 수 있고, 0 또는 음수일 경우에는 에러를 반환한다.
결과 타입은 다음 표와 같다.
string 타입 | 결과 타입 |
|---|---|
CHAR 또는 VARCHAR | VARCHAR |
LONG VARCHAR | LONG VARCHAR |
사용 예
gSQL> SELECT SPLIT_PART( 'AB;CD;EF;GH', ';', 3 ) AS RESULT FROM DUAL; RESULT ------ EF 1 row selected.
SQRT
구문
SQRT( num )
설명
SQRT 함수는 num의 제곱근을 반환한다. 인자 num에는 숫자 타입이 올 수 있고, 음수가 아닌 0 이상의 값이어야 한다. 인자 num이 NULL이면 NULL을 반환한다.
사용 예
gSQL> SELECT SQRT( 9 ) AS RESULT FROM DUAL;
RESULT
------
3
1 row selected.STATEMENT_DATE
구문
STATEMENT_DATE() CURRENT_DATE [()]
설명
현재 날짜 (DATE type) 값을 얻는다.
현재 날짜를 얻는 함수들 사이에는 다음과 같은 차이가 있다. • TRANSACTION_DATE(): 트랜잭션 내의 모든 날짜값이 동일하다. • STATEMENT_DATE(): 하나의 SQL 문장 내에서 모든 날짜 값이 동일하다. • CLOCK_DATE(): 함수가 호출될 때마다 현재 날짜 값을 얻는다.
사용 예
gSQL> SELECT STATEMENT_DATE() AS result FROM t1; RESULT ---------- 2013-12-12 2013-12-12 2013-12-12 3 rows selected.
STATEMENT_LOCALTIME
구문
STATEMENT_LOCALTIME() LOCALTIME [()]
설명
Session 시간을 기준으로 현재 TIME WITHOUT TIME ZONE type 값을 얻는다.
LOCALTIME은 SQL 표준 함수이다.
현재 시간을 얻는 함수들 사이에는 다음과 같은 차이가 있다. • TRANSACTION_LOCALTIME(): 트랜잭션 내의 모든 시간값이 동일하다. • STATEMENT_LOCALTIME(): 하나의 SQL 문장 내에서 모든 시간값이 동일하다. • CLOCK_LOCALTIME(): 함수가 호출될 때마다 현재 시간값을 얻는다.
사용 예
모든 row가 같은 시간값을 갖는다.
gSQL> SELECT STATEMENT_LOCALTIME() AS result FROM t1; RESULT --------------- 16:18:50.775870 16:18:50.775870 16:18:50.775870 3 rows selected.
STATEMENT_LOCALTIMESTAMP
구문
STATEMENT_LOCALTIMESTAMP() LOCALTIMESTAMP [()]
설명
Session 시간을 기준으로 현재 TIMESTAMP WITHOUT TIME ZONE type 값을 얻는다.
LOCALTIMESTAMP는 SQL 표준 함수이다.
현재 TIMESTAMP를 얻는 함수들 사이에는 다음과 같은 차이가 있다. • TRANSACTION_LOCALTIMESTAMP(): 트랜잭션 내의 모든 TIMESTAMP 값이 동일하다. • STATEMENT_LOCALTIMESTAMP(): 하나의 SQL 문장 내에서 모든 TIMESTAMP 값이 동일하다. • CLOCK_LOCALTIMESTAMP(): 함수가 호출될 때마다 현재 TIMESTAMP 값을 얻는다.
사용 예
모든 row가 같은 값을 갖는다.
gSQL> SELECT STATEMENT_LOCALTIMESTAMP() FROM t1; STATEMENT_LOCALTIMESTAMP() -------------------------- 2013-12-12 16:23:39.782187 2013-12-12 16:23:39.782187 2013-12-12 16:23:39.782187 3 rows selected.
STATEMENT_TIME
구문
STATEMENT_TIME() CURRENT_TIME [()]
설명
TIME ZONE이 있는 현재 TIME (TIME WITH TIME ZONE type) 값을 얻는다.
CURRENT_TIME은 SQL 표준 함수이다.
현재 시간을 얻는 함수들 사이에는 다음과 같은 차이가 있다. • TRANSACTION_TIME(): 트랜잭션 내의 모든 시간값이 동일하다. • STATEMENT_TIME(): 하나의 SQL 문장 내에서 모든 시간값이 동일하다. • CLOCK_TIME(): 함수가 호출될 때마다 현재 시간값을 얻는다.
사용 예
모든 row가 같은 시간값을 갖는다.
gSQL> SELECT STATEMENT_TIME() AS result FROM t1; RESULT ---------------------- 16:28:19.268513 +09:00 16:28:19.268513 +09:00 16:28:19.268513 +09:00 3 rows selected.
STATEMENT_TIMESTAMP
구문
STATEMENT_TIMESTAMP() CURRENT_TIMESTAMP [()]
설명
TIME ZONE이 있는 현재 TIMESTAMP (TIMESTAMP WITH TIME ZONE type) 값을 얻는다.
CURRENT_TIMESTAMP는 SQL 표준 함수이다.
현재 TIMESTAMP를 얻는 함수들 사이에는 다음과 같은 차이가 있다. • TRANSACTION_TIMESTAMP(): 트랜잭션 내의 모든 TIMESTAMP 값이 동일하다. • STATEMENT_TIMESTAMP(): 하나의 SQL 문장 내에서 모든 TIMESTAMP 값이 동일하다. • CLOCK_TIMESTAMP(): 함수가 호출될 때마다 현재 TIMESTAMP 값을 얻는다.
사용 예
모든 row가 같은 값을 갖는다.
gSQL> SELECT STATEMENT_TIMESTAMP() AS result FROM t1; RESULT --------------------------------- 2013-12-12 16:36:11.032957 +09:00 2013-12-12 16:36:11.032957 +09:00 2013-12-12 16:36:11.032957 +09:00 3 rows selected.
STATEMENT_VIEW_SCN
구문
STATEMENT_VIEW_SCN()
설명
현재 STATEMENT의 VIEW SCN을 얻는다.
사용 예
gSQL> SELECT STATEMENT_VIEW_SCN() FROM dual; STATEMENT_VIEW_SCN() -------------------- 17697.658.17880 1 row selected.
STATEMENT_VIEW_SCN_DCN
구문
STATEMENT_VIEW_SCN_DCN()
설명
현재 STATEMENT의 VIEW SCN의 Domain Change Number (DCN) 값을 얻는다.
사용 예
gSQL> SELECT STATEMENT_VIEW_SCN_DCN() FROM dual;
STATEMENT_VIEW_SCN_DCN()
------------------------
658
1 row selected.STATEMENT_VIEW_SCN_GCN
구문
STATEMENT_VIEW_SCN_GCN()
설명
현재 STATEMENT의 VIEW SCN의 Global Change Number (GCN) 값을 얻는다.
사용 예
gSQL> SELECT STATEMENT_VIEW_SCN_GCN() FROM dual;
STATEMENT_VIEW_SCN_GCN()
------------------------
17697
1 row selected.STATEMENT_VIEW_SCN_LCN
구문
STATEMENT_VIEW_SCN_LCN()
설명
현재 STATEMENT의 VIEW SCN의 Local Change Number (LCN) 값을 얻는다.
사용 예
gSQL> SELECT STATEMENT_VIEW_SCN_LCN() FROM dual;
STATEMENT_VIEW_SCN_LCN()
------------------------
17880
1 row selected.STDDEV
구문
STDDEV( [ ALL | DISTINCT ] expr )
설명
Aggregation 함수로써 expr set의 표준편차 (standard deviation)를 얻는다.
ALL을 명시한 경우, 모든 값들에 대해 수행하고, DISTINCT를 명시한 경우 중복을 제거한 값들에 대해 수행한다. 둘 다 명시하지 않은 경우, ALL을 명시한 것과 동일하게 처리한다.
NULL 값을 제외하고 DISTINCT로 중복을 제거한 후의 expr set의 개수가 한 개일 경우, VARIANCE와 같이 0을 반환한다.
인자와 결과 타입은 다음 표와 같다.
expr | 결과 타입 |
|---|---|
NATIVE_INTEGER 계열
| NATIVE_DOUBLE |
NUMBER | NUMBER |
NATIVE_DOUBLE 계열
| NATIVE_DOUBLE |
GOLDILOCKS는 다음과 같이 표준편차를 계산한다. • expr set의 개수가 1이면 0을 반환한다. • expr set의 개수가 1보다 크면 STDDEV_SAMP( expr ) 값을 반환한다.
표준편차는, 분산의 양의 제곱근으로써 분산에 루트를 씌워서 계산한다.
즉, STDDEV 함수는 VARIANCE 함수에 루트를 씌운 것과 같다.
STDDEV( [ ALL ] expr )
= SQRT( VARIANCE( [ ALL ] expr ) )
STDDEV( DISTINCT expr )
= SQRT( VARIANCE( DISTINCT expr ) )
사용 예
gSQL> SELECT STDDEV(c1) FROM t1;
STDDEV(C1)
----------------
11.4978258814438
1 row selected.
gSQL> SELECT STDDEV(ALL c1) FROM t1;
STDDEV(ALL C1)
----------------
11.4978258814438
1 row selected.
gSQL> SELECT STDDEV(DISTINCT c1) FROM t1;
STDDEV(DISTINCT C1)
-------------------
13.2759180473518
1 row selected.STDDEV_POP
구문
STDDEV_POP( expr )
설명
Aggregation 함수로써 expr set의 모 표준편차 (population standard deviation)를 얻는다. NULL 값을 제외한 expr set의 개수가 한 개일 때 0을 반환한다.
인자와 결과 타입은 다음 표와 같다.
expr | 결과 타입 |
|---|---|
NATIVE_INTEGER 계열
| NATIVE_DOUBLE |
NUMBER | NUMBER |
NATIVE_DOUBLE 계열
| NATIVE_DOUBLE |
모 표준편차는 모 분산의 양의 제곱근으로써 모 분산에 루트를 씌워서 계산한다.
즉, STDDEV_POP 함수는 VAR_POP 함수에 루트를 씌운 것과 같다.
STDDEV_POP( expr )
= SQRT( VAR_POP( expr ) )
사용 예
gSQL> SELECT STDDEV_POP(c1) FROM t1; STDDEV_POP(C1) --------------- 10.283968105746 1 row selected.
STDDEV_SAMP
구문
STDDEV_SAMP( expr )
설명
Aggregation 함수로써 expr set의 표본 표준편차 (sample standard deviation)를 얻는다. NULL 값을 제외한 expr set의 개수가 한 개일 때 NULL값을 반환한다.
인자와 결과 타입은 다음 표와 같다.
expr | 결과 타입 |
|---|---|
NATIVE_INTEGER 계열
| NATIVE_DOUBLE |
NUMBER | NUMBER |
NATIVE_DOUBLE 계열
| NATIVE_DOUBLE |
표본 표준편차는 표본 분산의 양의 제곱근으로써 표본 분산에 루트를 씌워서 계산한다.
즉, STDDEV_SAMP 함수는 VAR_SAMP 함수에 루트를 씌운 것과 같다.
STDDEV_SAMP( expr )
= SQRT( VAR_SAMP( expr ) )
사용 예
gSQL> SELECT STDDEV_SAMP(c1) FROM t1; STDDEV_SAMP(C1) ---------------- 11.4978258814438 1 row selected.
SUBSTR
구문
SUBSTR( str FROM start_position [ FOR string_length ] ) SUBSTR( str, start_position [ , string_length ] )
설명
SUBSTRING의 alias이다.
사용 예
Multi byte character set (예: UTF8): 1 byte character
gSQL> SELECT
SUBSTR( 'DATABASE MANAGEMENT SYSTEM', 10, 10 ) AS RESULT
FROM DUAL;
RESULT
----------
MANAGEMENT
1 row selected.Multi byte character set (예: UTF8): 2 bytes or 3 bytes character
gSQL> SELECT SUBSTR( '“αβ≠ΑΒ”', 2, 5 ) AS RESULT FROM DUAL; RESULT ------ αβ≠ΑΒ 1 row selected.
SUBSTRB
구문
SUBSTRB( str, start_position [ , string_length ] )
설명
SUBSTRB 함수는 str에 대해 start_position으로부터 string_length 범위의 문자를 추출하여 반환한다.
SUBSTRB 함수는 start_position과 string_length가 byte 단위로 계산된다는 점 외에는 SUBSTRING 함수와 동일하다.
사용 예
Multi byte character set (예: UTF8): 1 byte character
gSQL> SELECT
SUBSTRB( 'DATABASE MANAGEMENT SYSTEM', 10, 10 ) AS RESULT
FROM DUAL;
RESULT
----------
MANAGEMENT
1 row selected.Multi byte character set (예: UTF8): 2 bytes or 3 bytes character
gSQL> SELECT SUBSTRB( '“αβ≠ΑΒ”', 4, 11 ) AS RESULT FROM DUAL; RESULT ------ αβ≠ΑΒ 1 row selected.
SUBSTRING
구문
SUBSTRING( str FROM start_position [ FOR string_length ] ) SUBSTRING( str, start_position [ , string_length ] )
설명
SUBSTRING 함수는 str에 대해 start_position으로부터 string_length 범위의 문자를 추출하여 반환한다.
인자 str에는 CHARACTER, CHARACTER VARYING, CHARACTER LONG VARYING과 같은 CHARACTER 문자 타입과 BINARY, BINARY VARYING, BINARY LONG VARYING과 같은 BINARY 문자 타입이 올 수 있다.
인자 start_position과 string_length에는 숫자 타입이 올 수 있다.
str, start_position과 string_length 중의 하나라도 NULL인 경우, 결과값은 NULL이다. start_position과 string_length는 1부터 시작하며, character set에 따른 문자 단위로 계산된다. (byte 단위가 아님)
start_position이 0인 경우, 1로 처리된다. start_position이 양수인 경우, str의 앞부분에서부터 position의 위치를 찾는다. start_position이 음수인 경우, str의 뒷부분에서부터 position의 위치를 찾는다. string_length가 생략된 경우, start_position으로부터 str의 마지막 문자까지 반환한다. string_length에 0 또는 음수가 오는 경우, 결과값은 NULL이다. start_position > (str의 길이) 이면, 결과값은 NULL이다. (str의 길이 + start_position ) < 0 이면, 결과값은 NULL이다.
SUBSTR의 alias이다. 자세한 내용은 SUBSTR과 SUBSTRB를 참조한다.
결과 타입은 다음 표와 같다.
str | 결과 타입 |
|---|---|
CHAR 또는 VARCHAR | VARCHAR |
LONG VARCHAR | LONG VARCHAR |
BINARY 또는 VARBINARY | VARBINARY |
LONG VARBINARY | LONG VARBINARY |
사용 예
Multi byte character set (예: UTF8): 1 byte character
gSQL> SELECT
SUBSTRING( 'DATABASE MANAGEMENT SYSTEM' FROM 10 FOR 10 ) AS RESULT
FROM DUAL;
RESULT
----------
MANAGEMENT
1 row selected.Multi byte character set (예: UTF8): 2 bytes or 3 bytes character
gSQL> SELECT SUBSTRING( '“αβ≠ΑΒ”' FROM 2 FOR 5 ) AS RESULT FROM DUAL; RESULT ------ αβ≠ΑΒ 1 row selected.
SUM
구문
SUM( [ ALL | DISTINCT ] expr )
설명
Aggregation 함수로써 expr 값들의 합을 얻는다.
ALL을 명시한 경우, 모든 값들에 대해 aggregation을 수행한다. DISTINCT를 명시한 경우, 중복을 제거한 값들에 대해 aggregation을 수행한다. ALL이나 DISTINCT를 명시하지 않은 경우, ALL을 명시한 것과 동일하게 처리한다.
사용 예
gSQL> SELECT SUM(c1) FROM t1;
SUM(C1)
-------
6
1 row selected.SYSDATE
구문
SYSDATE
설명
Database server가 위치하는 OS 시간을 기준으로 현재의 DATE type 값을 얻는다.
사용 예
gSQL> SELECT SYSDATE FROM t1; SYSDATE ---------- 2013-12-12 2013-12-12 2013-12-12 3 rows selected.
SYS_EXTRACT_UTC
구문
SYS_EXTRACT_UTC( datetime_with_timezone )
설명
SYS_EXTRACT_UTC 는 UTC (Coordinated Universal Time—formerly Greenwich Mean Time) 값을 반환한다. timezone이 명시되지 않은 경우, session time zone으로 계산된다.
입력 인자에는 time, time with time zone, timestamp, timestamp with time zone 타입이 올 수 있다. 결과 타입은 time 또는 timestamp 타입이다.
사용 예
gSQL> SELECT
SYS_EXTRACT_UTC(
TO_TIMESTAMP_TZ( '2017-05-25 00:00:00.000000 +09:00',
'YYYY-MM-DD HH24:MI:SS.FF6 TZH:TZM' )
) AS RESULT
FROM DUAL;
RESULT
--------------------------
2017-05-24 15:00:00.000000
1 row selected.SYSTIME
구문
SYSTIME
설명
Database server가 위치하는 OS 시간을 기준으로 TIME ZONE이 있는 현재 시간 (TIME WITH TIME ZONE type) 값을 얻는다.
사용 예
gSQL> SELECT SYSTIME FROM t1; SYSTIME ---------------------- 16:30:46.954941 +09:00 16:30:46.954941 +09:00 16:30:46.954941 +09:00 3 rows selected.
SYSTIMESTAMP
구문
SYSTIMESTAMP
설명
Database server가 위치하는 OS 시간을 기준으로 TIME ZONE이 있는 현재 TIMESTAMP WITH TIME ZONE type 값을 얻는다.
사용 예
gSQL> SELECT SYSTIMESTAMP FROM t1; SYSTIMESTAMP --------------------------------- 2013-12-12 16:37:34.432241 +09:00 2013-12-12 16:37:34.432241 +09:00 2013-12-12 16:37:34.432241 +09:00 3 rows selected.
TAN
구문
TAN( num )
설명
TAN 함수는 num의 tangent 값을 라디안 단위로 반환한다. num이 NULL이면 NULL을 반환한다.
사용 예
gSQL> SELECT TAN( 1 ) AS RESULT FROM DUAL;
RESULT
---------------
1.5574077246549
1 row selected.TO_BASE64
구문
TO_BASE64( str )
설명
TO_BASE64는 str을 base64 인코딩으로 변환한 문자를 반환한다. 인자 str에는 CHARACTER, CHARACTER VARYING, CHARACTER LONG VARYING과 같은 CHARACTER 문자 타입 또는 문자 타입으로 변환될 수 있는 타입과 BINARY, BINARY VARYING, BINARY LONG VARYING과 같은 BINARY 문자 타입이 올 수 있다. 결과 타입은 CHARACTER VARYING 또는 CHARACTER LONG VARYING과 같은 CHARACTER 문자 타입이다.
str이 NULL이면 결과값도 NULL이다.
Base64 인코딩은 8 비트 바이너리 데이터를 ascii 영역으로 구성된 64개의 문자로 표현한다. 64개의 문자는 A~Z, a~z, 0~9, +, / 로 구성된다.
6 bit를 하나의 문자로 표현하며, 세 개의 문자 (24 bit)를 하나의 단위로 네 개의 문자로 표현한다. 인코딩 된 문자가 네 개의 문자를 채우지 못하면 나머지는 '=' 로 채운다. 인코딩 된 문자가 76개를 넘으면 newline이 추가되어 여러 라인으로 나누어진다.
Base64 인코딩 된 문자의 디코딩은 FROM_BASE64() 함수를 이용한다. Base64를 디코딩 할 때는 newline, carriage return, tab, space가 무시된다.
자세한 내용은 FROM_BASE64를 참조한다.
사용 예
gSQL> SELECT TO_BASE64( 'abc' ), TO_BASE64( 'abcd' ) FROM DUAL; TO_BASE64( 'abc' ) TO_BASE64( 'abcd' ) ------------------ ------------------- YWJj YWJjZA== 1 row selected.
TO_CHAR( datetime )
구문
TO_CHAR( datetime [, fmt ] )
설명
TO_CHAR( datetime ) 함수는 datetime을 명시된 fmt 형식의 문자열로 변환하여 반환한다.
인자 datetime에는 DATE, TIMESTAMP, TIMESTAMP WITH TIME ZONE, TIME, TIME WITH TIME ZONE, INTERVAL 타입이 올 수 있다. 인자 fmt에는 CHARACTER, CHARACTER VARYING과 같은 CHARACTER 문자 타입이 올 수 있다. 입력 인자의 값이 하나라도 NULL이면 NULL을 반환한다.
fmt가 생략된 경우, default format 형식을 따른다. • DATE: NLS_DATE_FORMAT • TIMESTAMP: NLS_TIMESTAMP_FORMAT • TIMESTAMP WITH TIME ZONE: NLS_TIMESTAMP_WITH_TIME_ZONE_FORMAT • TIME: NLS_TIME_FORMAT • TIME WITH TIME ZONE: NLS_TIME_WITH_TIME_ZONE_FORMAT
인자 datetime이 INTERVAL 타입인 경우, fmt와 무관하게 string으로 변환하여 반환한다.
fmt에 지정할 수 있는 문자열은 Datetime Format 문자열을 참조한다.
결과 타입은 CHARACTER VARYING 이다.
사용 예
다음은 fmt가 생략되고, NLS_DATE_FORMAT = 'YYYY-MM-DD' 인 경우의 예이다.
gSQL> SELECT
TO_CHAR( TO_DATE( '2012-03-15','YYYY-MM-DD' ) ) AS RESULT
FROM DUAL;
RESULT
----------
2012-03-15
1 row selected.다음은 fmt가 지정된 경우의 예이다.
gSQL> SELECT
TO_CHAR( TO_DATE('2012-03-15','YYYY-MM-DD'), 'DD-MON-YY' ) AS RESULT
FROM DUAL;
RESULT
---------
15-MAR-12
1 row selected.TO_CHAR( number )
구문
TO_CHAR( number [, fmt ] )
설명
TO_CHAR( number ) 함수는 number를 명시된 fmt 형식의 문자열로 변환하여 반환한다.
인자 number에는 숫자 타입이 올 수 있다. 인자 fmt에는 CHARACTER, CHARACTER VARYING과 같은 CHARACTER 문자 타입이 올 수 있다. fmt가 생략된 경우, 모든 유효 숫자를 문자열로 변환하여 반환한다. fmt에 지정할 수 있는 문자열은 Number Format 문자열을 참조한다. 입력 인자의 값이 하나라도 NULL이면 NULL을 반환한다.
결과 타입은 CHARACTER VARYING 이다.
사용 예
gSQL> SELECT TO_CHAR( 12500000 ) AS RESULT FROM DUAL; RESULT -------- 12500000 1 row selected. gSQL> SELECT TO_CHAR( 12500000, 'S999,999,999' ) AS RESULT FROM DUAL; RESULT ------------ +12,500,000 1 row selected.
TO_DATE
구문
TO_DATE( str [, fmt ] )
설명
TO_DATE 함수는 명시된 fmt 형식의 문자열 str을 DATE 타입으로 변환하여 반환한다.
인자 str과 fmt에는 CHARACTER, CHARACTER VARYING, CHARACTER LONG VARYING과 같은 CHARACTER 문자 타입이 올 수 있다. fmt가 생략된 경우, NLS_DATE_FORMAT은 default format 형식이 되고, 이 경우 str은 default format 형식의 문자열이어야 한다.
fmt에 지정할 수 있는 문자열은 Datetime Format 문자열을 참조한다. 자세한 내용은 NLS_DATE_FORMAT을 참조한다. str 또는 fmt가 NULL이면 NULL을 반환한다.
결과 타입은 DATE 이다.
사용 예
다음은 fmt가 생략되었고, NLS_DATE_FORMAT = 'YYYY-MM-DD' 인 경우의 예이다.
gSQL> SELECT TO_DATE( '2009-07-29' ) AS RESULT FROM DUAL; RESULT ---------- 2009-07-29 1 row selected.
다음은 fmt가 지정된 경우의 예이다.
gSQL> SELECT TO_DATE( '29-JUL-09', 'DD-MON-YY' ) AS RESULT FROM DUAL; RESULT ---------- 2009-07-29 1 row selected.
TO_NATIVE_BIGINT
구문
TO_NATIVE_BIGINT( str [, fmt ] )
설명
TO_NATIVE_BIGINT 함수는 명시된 fmt 형식의 문자열 str을 NATIVE_BIGINT 타입으로 변환하여 반환한다.
인자 str과 fmt에는 CHARACTER, CHARACTER VARYING, CHARACTER LONG VARYING과 같은 CHARACTER 문자 타입이 올 수 있다.
str과 fmt 중 하나라도 NULL이면, 결과값도 NULL이다. fmt에 지정할 수 있는 문자열은 Number Format 문자열을 참조한다.
결과 타입은 NATIVE_BIGINT이다.
사용 예
gSQL> SELECT TO_NATIVE_BIGINT( '123.45' ) AS RESULT1,
TO_NATIVE_BIGINT( '+123.45', 'S999.99' ) AS RESULT2
FROM DUAL;
RESULT1 RESULT2
------- -------
123 123
1 row selected.TO_NATIVE_DOUBLE
구문
TO_NATIVE_DOUBLE( str [, fmt ] )
설명
TO_NATIVE_DOUBLE 함수는 명시된 fmt 형식의 문자열 str을 NATIVE_DOUBLE 타입으로 변환하여 반환한다.
인자 str과 fmt에는 CHARACTER, CHARACTER VARYING, CHARACTER LONG VARYING과 같은 CHARACTER 문자 타입이 올 수 있다.
str과 fmt 중 하나라도 NULL이면, 결과값도 NULL이다. fmt에 지정할 수 있는 문자열은 Number Format 문자열을 참조한다.
결과 타입은 NATIVE_DOUBLE이다.
사용 예
gSQL> SELECT TO_NATIVE_DOUBLE( '123.45' ) AS RESULT1,
TO_NATIVE_DOUBLE( '+123.45', 'S999.99' ) AS RESULT2
FROM DUAL;
RESULT1 RESULT2
------- -------
123.45 123.45
1 row selected.TO_NATIVE_INTEGER
구문
TO_NATIVE_INTEGER( str [, fmt ] )
설명
TO_NATIVE_INTEGER 함수는 명시된 fmt 형식의 문자열 str을 NATIVE_INTEGER 타입으로 변환하여 반환한다.
인자 str과 fmt에는 CHARACTER, CHARACTER VARYING, CHARACTER LONG VARYING과 같은 CHARACTER 문자 타입이 올 수 있다.
str과 fmt 중 하나라도 NULL이면, 결과값도 NULL이다. fmt에 지정할 수 있는 문자열은 Number Format 문자열을 참조한다.
결과 타입은 NATIVE_INTEGER이다.
사용 예
gSQL> SELECT TO_NATIVE_INTEGER( '123.45' ) AS RESULT1,
TO_NATIVE_INTEGER( '+123.45', 'S999.99' ) AS RESULT2
FROM DUAL;
RESULT1 RESULT2
------- -------
123 123
1 row selected.TO_NATIVE_REAL
구문
TO_NATIVE_REAL( str [, fmt ] )
설명
TO_NATIVE_REAL 함수는 명시된 fmt 형식의 문자열 str을 NATIVE_REAL 타입으로 변환하여 반환한다.
인자 str과 fmt에는 CHARACTER, CHARACTER VARYING, CHARACTER LONG VARYING과 같은 CHARACTER 문자 타입이 올 수 있다.
str과 fmt 중 하나라도 NULL이면, 결과값도 NULL이다. fmt에 지정할 수 있는 문자열은 Number Format 문자열을 참조한다.
결과 타입은 NATIVE_REAL이다.
사용 예
gSQL> SELECT TO_NATIVE_REAL( '123.45' ) AS RESULT1,
TO_NATIVE_REAL( '+123.45', 'S999.99' ) AS RESULT2
FROM DUAL;
RESULT1 RESULT2
------- -------
123.45 123.45TO_NATIVE_SMALLINT
구문
TO_NATIVE_SMALLINT( str [, fmt ] )
설명
TO_NATIVE_SMALLINT 함수는 명시된 fmt 형식의 문자열 str을 NATIVE_SMALLINT 타입으로 변환하여 반환한다.
인자 str과 fmt에는 CHARACTER, CHARACTER VARYING, CHARACTER LONG VARYIN과 같은 CHARACTER 문자 타입이 올 수 있다.
str과 fmt 중 하나라도 NULL이면, 결과값도 NULL이다. fmt에 지정할 수 있는 문자열은 Number Format 문자열을 참조한다.
결과 타입은 NATIVE_SMALLINT이다.
사용 예
gSQL> SELECT TO_NATIVE_SMALLINT( '123.45' ) AS RESULT1,
TO_NATIVE_SMALLINT( '+123.45', 'S999.99' ) AS RESULT2
FROM DUAL;
RESULT1 RESULT2
------- -------
123 123
1 row selected.TO_NUMBER
구문
TO_NUMBER( str [, fmt] )
설명
TO_NUMBER 함수는 명시된 fmt 형식의 문자열 str을 NUMBER 타입으로 변환하여 반환한다.
인자 str과 fmt에는 CHARACTER, CHARACTER VARYING, CHARACTER LONG VARYING과 같은 CHARACTER 문자 타입이 올 수 있다.
str과 fmt 중 하나라도 NULL이면 결과값도 NULL이다. fmt에 지정할 수 있는 문자열은 Number Format 문자열을 참조한다.
결과 타입은 NUMBER이다.
사용 예
gSQL> SELECT TO_NUMBER( '123.45' ) AS RESULT1,
TO_NUMBER( '+123.45', 'S999.99' ) AS RESULT2
FROM DUAL;
RESULT1 RESULT2
------- -------
123.45 123.45
1 row selected.TO_TIME
구문
TO_TIME( str [, fmt ] )
설명
TO_TIME 함수는 명시된 fmt 형식의 문자열 str을 TIME 타입으로 변환하여 반환한다.
인자 str과 fmt에는 CHARACTER, CHARACTER VARYING, CHARACTER LONG VARYING과 같은 CHARACTER 문자 타입이 올 수 있다. fmt가 생략된 경우, NLS_TIME_FORMAT이 default format 형식이 되고, 이 경우 str은 default format 형식의 문자열이어야 한다.
fmt에 지정할 수 있는 문자열은 Datetime Format 문자열을 참조한다. 자세한 내용은 NLS_TIME_FORMAT을 참조한다. str 또는 fmt가 NULL이면 NULL을 반환한다.
결과 타입은 TIME 이다.
사용 예
다음은 fmt가 생략되었고, NLS_TIME_FORMAT = 'HH24:MI:SS.FF6' 인 경우의 예이다.
gSQL> SELECT TO_TIME( '11:22:33.999999' ) AS RESULT FROM DUAL; RESULT --------------- 11:22:33.999999 1 row selected.
다음은 fmt가 지정된 경우의 예이다.
gSQL> SELECT
TO_TIME( '112233.999999/P.M.', 'HH12MISS.FF6/P.M.' ) AS RESULT
FROM DUAL;
RESULT
---------------
23:22:33.999999
1 row selected.TO_TIME_TZ
구문
TO_TIME_TZ( str [, fmt ] )
설명
TO_TIME_WITH_TIME_ZONE의 alias이다. 자세한 내용은 TO_TIME_WITH_TIME_ZONE과 NLS_TIME_WITH_TIME_ZONE_FORMAT을 참조한다.
사용 예
다음은 fmt가 생략되었고, NLS_TIME_WITH_TIME_ZONE_FORMAT = 'HH24:MI:SS.FF6 TZH:TZM' 인 경우의 예이다.
gSQL> SELECT TO_TIME_TZ( '11:22:33.999999 +09:00' ) AS RESULT FROM DUAL; RESULT ---------------------- 11:22:33.999999 +09:00 1 row selected.
다음은 fmt가 지정된 경우의 예이다.
gSQL> SELECT TO_TIME_TZ( '11:22:33.999999 +09:00 PM',
'HH12:MI:SS.FF6 TZH:TZM PM' ) AS RESULT
FROM DUAL;
RESULT
----------------------
23:22:33.999999 +09:00
1 row selected.TO_TIME_WITH_TIME_ZONE
구문
TO_TIME_WITH_TIME_ZONE( str [, fmt ] ) TO_TIME_TZ( str [, fmt ] )
설명
TO_TIME_WITH_TIME_ZONE 함수는 명시된 fmt 형식의 문자열 str을 TIME WITH TIME ZONE 타입으로 변환하여 반환한다.
인자 str과 fmt에는 CHARACTER, CHARACTER VARYING, CHARACTER LONG VARYING과 같은 CHARACTER 문자 타입이 올 수 있다. fmt가 생략된 경우, NLS_TIME_WITH_TIME_ZONE_FORMAT이 default format 형식이 되고, 이 경우 str은 default format 형식의 문자열이어야 한다.
fmt에 지정할 수 있는 문자열은 Datetime Format 문자열을 참조한다. 자세한 내용은 NLS_TIME_WITH_TIME_ZONE_FORMAT을 참조한다. str 또는 fmt가 NULL이면 NULL을 반환한다.
TO_TIME_WITH_TIME_ZONE의 alias로는 TO_TIME_TZ 함수가 있다.
결과 타입은 TIME WITH TIME ZONE 이다.
사용 예
다음은 fmt가 생략되었고, NLS_TIME_WITH_TIME_ZONE_FORMAT = 'HH24:MI:SS.FF6 TZH:TZM' 인 경우의 예이다.
gSQL> SELECT
TO_TIME_WITH_TIME_ZONE( '11:22:33.999999 +09:00' ) AS RESULT
FROM DUAL;
RESULT
----------------------
11:22:33.999999 +09:00
1 row selected.다음은 fmt가 지정된 경우의 예이다.
gSQL> SELECT
TO_TIME_WITH_TIME_ZONE( '11:22:33.999999 +09:00 PM',
'HH12:MI:SS.FF6 TZH:TZM PM' )
AS RESULT
FROM DUAL;
RESULT
----------------------
23:22:33.999999 +09:00
1 row selected.TO_TIMESTAMP
구문
TO_TIMESTAMP( str [, fmt ] )
설명
TO_TIMESTAMP 함수는 명시된 fmt 형식의 문자열 str을 TIMESTAMP 타입으로 변환하여 반환한다.
인자 str과 fmt에는 CHARACTER, CHARACTER VARYING, CHARACTER LONG VARYING과 같은 CHARACTER 문자 타입이 올 수 있다. fmt가 생략된 경우, NLS_TIMESTAMP_FORMAT이 default format 형식이 되고, 이 경우 str은 default format 형식의 문자열이어야 한다.
fmt에 지정할 수 있는 문자열은 Datetime Format 문자열을 참조한다. 자세한 내용은 NLS_TIMESTAMP_FORMAT을 참조한다. str 또는 fmt가 NULL이면 NULL을 반환한다.
결과 타입은 TIMESTAMP 이다.
사용 예
다음은 fmt가 생략되었고, NLS_TIMESTAMP_FORMAT = 'YYYY-MM-DD HH24:MI:SS.FF6'' 인 경우의 예이다.
gSQL> SELECT
TO_TIMESTAMP( '2009-07-29 11:22:33.999999' ) AS RESULT
FROM DUAL;
RESULT
--------------------------
2009-07-29 11:22:33.999999
1 row selected.다음은 fmt가 지정된 경우의 예이다.
gSQL> SELECT
TO_TIMESTAMP( '090729 112233999999 PM', 'YYMMDD HH12MISSFF6 PM' )
AS RESULT
FROM DUAL;
RESULT
--------------------------
2009-07-29 23:22:33.999999
1 row selected.TO_TIMESTAMP_TZ
구문
TO_TIMESTAMP_TZ( str [, fmt ] )
설명
TO_TIMESTAMP_WITH_TIME_ZONE의 alias 이다. 자세한 내용은 TO_TIMESTAMP_WITH_TIME_ZONE과 NLS_TIMESTAMP_WITH_TIME_ZONE_FORMAT을 참조한다.
사용 예
다음은 fmt가 생략되었고, NLS_TIMESTAMP_WITH_TIME_ZONE_FORMAT = 'YYYY-MM-DD HH24:MI:SS.FF6 TZH:TZM' 인 경우의 예이다.
gSQL> SELECT
TO_TIMESTAMP_TZ( '2009-07-29 11:22:33.999999 +09:00' ) AS RESULT
FROM DUAL;
RESULT
---------------------------------
2009-07-29 11:22:33.999999 +09:00
1 row selected.다음은 fmt가 지정된 경우의 예이다.
gSQL> SELECT
TO_TIMESTAMP_TZ( '29-JUL-09 11:22:33.999999 +09:00',
'DD-MON-RR HH12:MI:SS.FF6 TZH:TZM' ) AS RESULT
FROM DUAL;
RESULT
---------------------------------
2009-07-29 11:22:33.999999 +09:00
1 row selected.TO_TIMESTAMP_WITH_TIME_ZONE
구문
TO_TIMESTAMP_WITH_TIME_ZONE( str [, fmt ] ) TO_TIMESTAMP_TZ( str [, fmt ] )
설명
TO_TIMESTAMP_WITH_TIME_ZONE 함수는 명시된 fmt 형식의 문자열 str을 TIMESTAMP WITH TIME ZONE 타입으로 변환하여 반환한다.
인자 str과 fmt에는 CHARACTER, CHARACTER VARYING, CHARACTER LONG VARYING과 같은 CHARACTER 문자 타입이 올 수 있다. fmt가 생략된 경우, NLS_TIMESTAMP_WITH_TIME_ZONE_FORMAT이 default format 형식이 되고, 이 경우 str은 default format 형식의 문자열이어야 한다.
fmt에 지정할 수 있는 문자열은 Datetime Format 문자열을 참조한다. 자세한 내용은 NLS_TIMESTAMP_WITH_TIME_ZONE_FORMAT을 참조한다. str 또는 fmt가 NULL이면 NULL을 반환한다.
TO_TIMESTAMP_WITH_TIME_ZONE의 alias로는 TO_TIMESTAMP_TZ 함수가 있다.
결과 타입은 TIMESTAMP WITH TIME ZONE 이다.
사용 예
다음은 fmt가 생략되었고, NLS_TIMESTAMP_WITH_TIME_ZONE_FORMAT = 'YYYY-MM-DD HH24:MI:SS.FF6 TZH:TZM' 인 경우의 예이다.
gSQL> SELECT
TO_TIMESTAMP_WITH_TIME_ZONE( '2009-07-29 11:22:33.999999 +09:00' )
AS RESULT
FROM DUAL;
RESULT
---------------------------------
2009-07-29 11:22:33.999999 +09:00
1 row selected.다음은 fmt가 지정된 경우의 예이다.
gSQL> SELECT
TO_TIMESTAMP_WITH_TIME_ZONE( '29-JUL-09 11:22:33.999999 +09:00',
'DD-MON-RR HH12:MI:SS.FF6 TZH:TZM' )
AS RESULT
FROM DUAL;
RESULT
---------------------------------
2009-07-29 11:22:33.999999 +09:00
1 row selected.TRANSACTION_DATE
구문
TRANSACTION_DATE()
설명
Session 시간을 기준으로 현재 날짜 (DATE type) 값을 얻는다.
현재 날짜를 얻는 함수들 사이에는 다음과 같은 차이가 있다. • TRANSACTION_DATE(): 트랜잭션 내의 모든 날짜값이 동일하다. • STATEMENT_DATE(): 하나의 SQL 문장 내에서 모든 날짜 값이 동일하다. • CLOCK_DATE(): 함수가 호출될 때마다 현재 날짜 값을 얻는다.
사용 예
동일한 transaction 내에서는 날짜 값이 항상 같다.
gSQL> SELECT TRANSACTION_DATE() FROM dual; TRANSACTION_DATE() ------------------ 2013-12-12 1 row selected. gSQL> SELECT TRANSACTION_DATE() FROM dual; TRANSACTION_DATE() ------------------ 2013-12-12 1 row selected. gSQL> COMMIT; Commit complete. gSQL> SELECT TRANSACTION_DATE() FROM dual; TRANSACTION_DATE() ------------------ 2013-12-13 1 row selected.
TRANSACTION_LOCALTIME
구문
TRANSACTION_LOCALTIME()
설명
Session 시간을 기준으로 TIME ZONE이 없는 현재 시간 (TIME WITHOUT TIME ZONE type) 값을 얻는다.
현재 시간을 얻는 함수들 사이에는 다음과 같은 차이가 있다. • TRANSACTION_LOCALTIME(): 트랜잭션 내의 모든 시간값이 동일하다. • STATEMENT_LOCALTIME(): 하나의 SQL 문장 내에서 모든 시간값이 동일하다. • CLOCK_LOCALTIME(): 함수가 호출될 때마다 현재 시간값을 얻는다.
사용 예
동일한 transaction 내에서는 시간값이 항상 같다.
gSQL> SELECT TRANSACTION_LOCALTIME() FROM dual; TRANSACTION_LOCALTIME() ----------------------- 16:43:24.391834 1 row selected. gSQL> SELECT TRANSACTION_LOCALTIME() FROM dual; TRANSACTION_LOCALTIME() ----------------------- 16:43:24.391834 1 row selected. gSQL> COMMIT; Commit complete. gSQL> SELECT TRANSACTION_LOCALTIME() FROM dual; TRANSACTION_LOCALTIME() ----------------------- 16:43:32.651833 1 row selected.
TRANSACTION_LOCALTIMESTAMP
구문
TRANSACTION_LOCALTIMESTAMP()
설명
Session 시간을 기준으로 TIME ZONE이 없는 현재 TIMESTAMP (TIMESTAMP WITHOUT TIME ZONE type) 값을 얻는다.
현재 TIMESTAMP를 얻는 함수들 사이에는 다음과 같은 차이가 있다. • TRANSACTION_LOCALTIMESTAMP(): 트랜잭션 내의 모든 TIMESTAMP 값이 동일하다. • STATEMENT_LOCALTIMESTAMP(): 하나의 SQL 문장 내에서 모든 TIMESTAMP 값이 동일하다. • CLOCK_LOCALTIMESTAMP(): 함수가 호출될 때마다 현재 TIMESTAMP 값을 얻는다.
사용 예
동일한 transaction 내에서는 TIMESTAMP 값이 항상 같다.
gSQL> SELECT TRANSACTION_LOCALTIMESTAMP() FROM dual; TRANSACTION_LOCALTIMESTAMP() ---------------------------- 2013-12-12 16:43:32.651833 1 row selected. gSQL> SELECT TRANSACTION_LOCALTIMESTAMP() FROM dual; TRANSACTION_LOCALTIMESTAMP() ---------------------------- 2013-12-12 16:43:32.651833 1 row selected. gSQL> COMMIT; Commit complete. gSQL> SELECT TRANSACTION_LOCALTIMESTAMP() FROM dual; TRANSACTION_LOCALTIMESTAMP() ---------------------------- 2013-12-12 16:46:07.831834 1 row selected.
TRANSACTION_TIME
구문
TRANSACTION_TIME()
설명
Session 시간을 기준으로 TIME ZONE이 있는 현재 시간 (TIME WITH TIME ZONE type) 값을 얻는다.
현재 시간을 얻는 함수들 사이에는 다음과 같은 차이가 있다. • TRANSACTION_TIME(): 트랜잭션 내의 모든 시간값이 동일하다. • STATEMENT_TIME(): 하나의 SQL 문장 내에서 모든 시간값이 동일하다. • CLOCK_TIME(): 함수가 호출될 때마다 현재 시간값을 얻는다.
사용 예
동일한 transaction 내에서는 시간값이 항상 같다.
gSQL> SELECT TRANSACTION_TIME() FROM dual; TRANSACTION_TIME() ---------------------- 16:46:07.831834 +09:00 1 row selected. gSQL> SELECT TRANSACTION_TIME() FROM dual; TRANSACTION_TIME() ---------------------- 16:46:07.831834 +09:00 1 row selected. gSQL> COMMIT; Commit complete. gSQL> SELECT TRANSACTION_TIME() FROM dual; TRANSACTION_TIME() ---------------------- 16:48:00.691827 +09:00 1 row selected.
TRANSACTION_TIMESTAMP
구문
TRANSACTION_TIMESTAMP()
설명
Session 시간을 기준으로 TIME ZONE이 있는 현재 TIMESTAMP (TIMESTAMP WITH TIME ZONE type) 값을 얻는다.
현재 TIMESTAMP를 얻는 함수들 사이에는 다음과 같은 차이가 있다. • TRANSACTION_TIMESTAMP(): 트랜잭션 내의 모든 TIMESTAMP 값이 동일하다. • STATEMENT_TIMESTAMP(): 하나의 SQL 문장 내에서 모든 TIMESTAMP 값이 동일하다. • CLOCK_TIMESTAMP(): 함수가 호출될 때마다 현재 TIMESTAMP 값을 얻는다.
사용 예
동일한 transaction 내에서는 TIMESTAMP 값이 항상 같다.
gSQL> SELECT TRANSACTION_TIMESTAMP() FROM dual; TRANSACTION_TIMESTAMP() --------------------------------- 2013-12-12 16:48:00.691827 +09:00 1 row selected. gSQL> SELECT TRANSACTION_TIMESTAMP() FROM dual; TRANSACTION_TIMESTAMP() --------------------------------- 2013-12-12 16:48:00.691827 +09:00 1 row selected. gSQL> COMMIT; Commit complete. gSQL> SELECT TRANSACTION_TIMESTAMP() FROM dual; TRANSACTION_TIMESTAMP() --------------------------------- 2013-12-12 16:49:26.291827 +09:00 1 row selected.
TRANSLATE
구문
TRANSLATE( string, from, to )
설명
TRANSLATE 함수는 문자를 치환하는 함수로, from의 문자와 일치하는 string의 문자를 from의 문자와 같은 위치에 있는 to의 문자로 치환하여 반환한다.
인자 string, from, to에는 CHARACTER, CHARACTER VARYING, CHARACTER LONG VARYING과 같은 CHARACTER 문자 타입이 올 수 있다.
string, from, to 중의 하나라도 NULL이면 결과값도 NULL이다.
from의 문자와 일치하는 string 문자가 있을 경우
from의 길이와 to의 길이가 같으면 from의 문자와 같은 위치에 있는 to의 문자로 치환한다.
from의 길이가 to의 길이보다 길면 to의 문자 길이 이후의 위치에 있는 from의 문자는 string에서 제거된다.
from의 문자가 중복된 문자로 이뤄져 있으면 from의 중복되는 문자의 첫 위치와 동일한 위치에 있는 to의 문자로 치환된다.
from의 문자와 일치하는 string 문자가 없을 경우, string은 치환되지 않는다.
결과 타입은 다음 표와 같다.
string 타입 | 결과 타입 |
|---|---|
CHAR 또는 VARCHAR | VARCHAR |
LONG VARCHAR | LONG VARCHAR |
사용 예
from의 문자와 일치하는 string 문자가 있으면, 같은 위치의 to의 문자로 치환된다.
A → Z, C → Y, E → X, G → W
gSQL> SELECT TRANSLATE('ABCDEFG', 'ACEG', 'ZYXW') AS RESULT
FROM DUAL;
RESULT
-------
ZBYDXFW
1 row selected.from의 문자열 길이가 to의 문자열 길이보다 길면, to의 문자열 길이 이후 위치한 from의 문자는 string에서 제거되고 치환된다.
A → Z, C → Y, E 제거, G 제거
gSQL> SELECT TRANSLATE('ABCDEFG', 'ACEG', 'ZY') AS RESULT
FROM DUAL;
RESULT
------
ZBYDF
1 row selected.TRIM
구문
TRIM([ [ LEADING | TRAILING | BOTH ] [trim_character] FROM ] trim_source)
설명
TRIM 함수는 trim_source에서 trim_character를 LEADING, TRAILING, BOTH 방향에서 비교하여 일치되는 문자가 없을 때까지 제거한 결과를 반환한다.
인자 trim_character와 trim_source에는 CHARACTER, CHARACTER VARYING, CHARACTER LONG VARYING과 같은 CHARACTER 문자 타입과 BINARY, BINARY VARYING, BINARY LONG VARYING과 같은 BINARY 문자 타입이 올 수 있다.
trim_character, trim_source 중 하나라도 NULL이면 결과값은 NULL이다.
[ LEADING | TRAILING | BOTH ]
LEADING: trim_source의 앞부분부터 trim_character를 제거한다.
TRAILING: trim_source의 뒷부분부터 trim_character를 제거한다.
BOTH: trim_source의 앞뒤 양방향에서 trim_character를 제거한다.
trim_character는 한 개의 문자만 허용된다.
trim_character가 생략된 경우에는 single blank space (' ')가 기본적으로 지정된다.
FROM이 지정된 경우
[ LEADING | TRAILING | BOTH ] 또는 trim_character 또는 [ LEADING | TRAILING | BOTH ] trim_character가 지정되어야 한다.
예: TRIM( LEADING FROM ' abc' ) , TRIM( 'x' FROM 'xabc' ) , TRIM( LEADING 'x' FROM 'xabc' )
[ LEADING | TRAILING | BOTH ]이 생략된 경우에는 BOTH가 기본적으로 지정된다.
FROM이 생략된 경우
TRIM( trim_source )인 경우이며 TRIM( BOTH ' ' FROM trim_source )과 동일하게 수행된다.
결과 타입은 다음 표와 같다.
trim_character, trim_source 타입 | 결과 타입 |
|---|---|
CHAR 또는 VARCHAR | VARCHAR |
LONG VARCHAR | LONG VARCHAR |
BINARY 또는 VARBINARY | VARBINARY |
LONG VARBINARY | LONG VARBINARY |
사용 예
gSQL> SELECT TRIM( LEADING '_' FROM '___TRIM FUNCTION___' ) AS RESULT
FROM DUAL;
RESULT
----------------
TRIM FUNCTION___
1 row selected.
gSQL> SELECT TRIM( TRAILING '_' FROM '___TRIM FUNCTION___' ) AS RESULT
FROM DUAL;
RESULT
----------------
___TRIM FUNCTION
1 row selected.
gSQL> SELECT TRIM( BOTH '_' FROM '___TRIM FUNCTION___' ) AS RESULT
FROM DUAL;
RESULT
-------------
TRIM FUNCTION
1 row selected.TRUNC( number )
구문
TRUNC( num [ , scale ] )
설명
TRUNC( number ) 함수는 scale 기준으로 num을 버림한 값을 반환한다.
인자 num과 scale에는 숫자 타입이 올 수 있다. 인자 num 또는 scale이 NULL이면 NULL을 반환한다.
scale이 생략된 경우, scale은 0이 되어 TRUNC( num, 0 )일 때와 같이 실행된다. scale이 양수인 경우, 소수점 오른쪽 자리수를 기준으로 버림한다. scale이 음수인 경우, 소수점 왼쪽 자리수를 기준으로 버림한다.
사용 예
gSQL> SELECT TRUNC( 142.4282, 2 ) AS RESULT FROM DUAL; RESULT ------ 142.42 1 row selected. gSQL> SELECT TRUNC( 142.4282, -2 ) AS RESULT FROM DUAL; RESULT ------ 100 1 row selected.
TRUNC( date )
구문
TRUNC( date [ , fmt ] )
설명
TRUNC( date ) 함수는 date를 지정된 fmt 단위로 버림한 값을 반환한다.
인자 date에는 DATE, TIMESTAMP, TIMESTAMP WITH TIME ZONE 타입이 올 수 있다. 인자 fmt에는 CHARACTER, CHARACTER VARYING과 같은 CHARACTER 문자 타입이 올 수 있다. 인자 date 또는 fmt이 NULL이면 NULL을 반환한다.
결과 타입은 인자로 받은 date 타입과 관계없이 항상 DATE 타입이다.
fmt가 생략되었을 경우의 기본값은 DAY이며, 사용 가능한 형식문자열은 다음 표와 같다.
형식문자열 | 설명 |
|---|---|
CC, SCC | 세기 |
YYYY, YEAR, SYYYY, SYEAR, YYY, YY, Y | 년 |
IYYY, IYY, IY, I | ISO 8601 표준에 정의된 calendar week를 수용하는 연도 |
Q | 분기 |
MONTH, MON, MM, RM | 월 |
WW | 연도의 1월 1일을 한 주로 시작하는 주 |
IW | ISO 8601 표준에 정의된 calendar week (1~52주 또는 1~53주)로 지정된 연도의 첫 번째 목요일이 있는 주가 첫 번째 주 |
W | 월의 1일을 한 주로 시작하는 주 |
DDD, DD, J | 일 |
DAY, DY, D | 요일 |
HH, HH12, HH24 | 시 |
MI | 분 |
사용 예
gSQL> SELECT
TRUNC( TO_DATE( '2051-07-16', 'YYYY-MM-DD' ), 'CC' ) AS RESULT
FROM DUAL;
RESULT
----------
2001-01-01
1 row selected.
gSQL> SELECT
TRUNC( TO_DATE( '2051-07-16', 'YYYY-MM-DD' ), 'YYYY' ) AS RESULT
FROM DUAL;
RESULT
----------
2051-01-01
1 row selected.
gSQL> SELECT
TRUNC( TO_DATE( '2051-07-16', 'YYYY-MM-DD' ), 'MONTH' ) AS RESULT
FROM DUAL;
RESULT
----------
2051-07-01
1 row selected.
gSQL> SELECT
TRUNC( TO_TIMESTAMP( '2001-05-05 11:22:33.999999',
'YYYY-MM-DD HH24:MI:SS.FF6' ) ) AS RESULT
FROM DUAL;
RESULT
----------
2001-05-05
1 row selected.UPPER
구문
UPPER( str )
설명
UPPER 함수는 str의 대문자를 반환한다.
인자 str에는 CHARACTER, CHARACTER VARYING, CHARACTER LONG VARYING과 같은 문자 타입이 올 수 있다. str이 NULL이면 결과값도 NULL이다.
반환되는 타입은 인자 str과 동일한 타입이다.
사용 예
gSQL> SELECT UPPER( 'spring' ) AS RESULT FROM DUAL; RESULT ------ SPRING 1 row selected.
UNHEX
구문
UNHEX( str )
설명
인자 str은 16진수 문자이며, 이를 각 byte로 표현하여 binary string으로 반환한다.
입력 인자에는 CHARACTER VARYING, CHARACTER LONG VARYING과 같은 CHARACTER 문자 타입이 올 수 있고, 결과 타입은 BINARY VARYING이나 BINARY LONG VARYING과 같은 BINARY 문자 타입이다.
str이 NULL이면 결과값도 NULL이다. str에 16진수 범위에 속하지 않는 문자가 포함되면 에러를 반환한다.
자세한 내용은 HEX를 참조한다.
사용 예
gSQL> SELECT UNHEX( HEX( 'abc' ) ) FROM DUAL; UNHEX( HEX( 'abc' ) ) --------------------- 616263 1 row selected.
UNHEX_TO_CHARSTR
구문
UNHEX_TO_CHARSTR( str )
설명
인자 str은 16진수 문자이며 이를 각 byte로 표현하여 character string으로 반환한다.
입력 인자에는 CHARACTER VARYING, CHARACTER LONG VARYING과 같은 CHARACTER 문자 타입이 올 수 있고, 결과 타입은 CHARACTER VARYING이나 CHARACTER LONG VARYING과 같은 CHARACTER 문자 타입이다.
str이 NULL이면 결과값도 NULL이다. str에 16진수 범위에 속하지 않는 문자가 포함되면 에러를 반환한다.
인자 str가 어떤 데이터의 16진수 문자표현인지 알 수 없으므로 character string으로 반환할 때 현재 적용할 수 있는 character set을 적용하여 결과값을 반환한다. 현재 적용할 수 있는 character set에 포함되지 않는 경우, 에러를 반환한다.
자세한 내용은 HEX와 UNHEX를 참조한다.
사용 예
gSQL> SELECT UNHEX_TO_CHARSTR( '616263' ) FROM DUAL; UNHEX_TO_CHARSTR( '616263' ) ---------------------------- abc 1 row selected. gSQL> SELECT UNHEX_TO_CHARSTR( HEX( 'abc' ) ) FROM DUAL; UNHEX_TO_CHARSTR( HEX( 'abc' ) ) -------------------------------- abc 1 row selected.
USER_ID
구문
USER_ID ()
설명
현재 사용자의 number ID를 얻는다.
Cluster system에서는 접속한 server에 따라 다른 값을 가질 수 있다.
현재 사용자의 이름을 얻는 CURRENT_USER 함수 사용을 권장한다.
사용 예
% gsql test test
gSQL> SELECT USER_ID() FROM dual;
USER_ID()
---------
6
1 row selected.UUID
구문
UUID()
설명
UUID 함수는 전역고유식별자 (Universal Unique Identifier) 를 생성하여 반환한다. 반환되는 타입은 VARBINARY 이며 내부적으로 16 바이트로 구성된다.
사용 예
gSQL> SELECT HEX( UUID() ) FROM DUAL; HEX( UUID() ) -------------------------------- E6F0A5C2387511E8B95259E479C2FD50 1 row selected.
VAR_POP
구문
VAR_POP( expr )
설명
Aggregation 함수로써 expr set의 모 분산 (population variance)을 얻는다. NULL 값을 제외한 expr set의 개수가 한 개일 때 0을 반환한다.
인자와 결과 타입은 다음 표와 같다.
expr | 결과 타입 |
|---|---|
NATIVE_INTEGER 계열
| NATIVE_DOUBLE |
NUMBER | NUMBER |
NATIVE_DOUBLE 계열
| NATIVE_DOUBLE |
모 분산은 모 집단 (전체)의 분산이며 분산은 편차 제곱의 평균이다. 즉, 데이터의 각 값에서 모 평균 (전체의 평균)을 빼고 제곱해서 모두 더한 뒤 모 집단의 데이터 개수로 나눈다.
이는 각 관찰값들이 평균으로부터 얼마나 많이 퍼져있는지 파악하는데 사용된다.
자세한 내용은 STDDEV_POP을 참조한다.
사용 예
gSQL> SELECT VAR_POP(c1) FROM t1;
VAR_POP(C1)
-----------
105.76
1 row selected.VAR_SAMP
구문
VAR_SAMP( expr )
설명
Aggregation 함수로써 expr set의 표본 분산 (sample variance)을 얻는다. NULL 값을 제외한 expr set의 개수가 한 개일 때 NULL값을 반환한다.
인자와 결과 타입은 다음 표와 같다.
expr | 결과 타입 |
|---|---|
NATIVE_INTEGER 계열
| NATIVE_DOUBLE |
NUMBER | NUMBER |
NATIVE_DOUBLE 계열
| NATIVE_DOUBLE |
모 집단 (전체)을 다루는 모 분산과 달리, 표본 분산은 추출한 표본으로 평균과 편차를 다룬다. 즉, 데이터의 각 값에서 표본의 평균을 빼고 제곱해서 모두 더한 뒤, 표본 집단의 데이터 개수 - 1로 나눈다.
이는 모 집단의 분산을 추정하는 데 사용된다.
자세한 내용은 STDDEV_SAMP을 참조한다.
사용 예
gSQL> SELECT VAR_SAMP(c1) FROM t1;
VAR_SAMP(C1)
------------
132.2
1 row selected.VARIANCE
구문
VARIANCE( [ ALL | DISTINCT ] expr )
설명
Aggregation 함수로써 expr set의 분산 (variance)을 얻는다.
ALL을 명시한 경우 모든 값들에 대해 수행하고, DISTINCT를 명시한 경우 중복을 제거한 값들에 대해 수행한다. 둘 다 명시하지 않은 경우, ALL을 명시한 것과 동일하게 처리한다.
NULL 값을 제외하고 DISTINCT로 중복을 제거한 후의 expr set의 개수가 한 개일 경우, 0을 반환한다.
인자와 결과 타입은 다음 표와 같다.
expr | 결과 타입 |
|---|---|
NATIVE_INTEGER 계열
| NATIVE_DOUBLE |
NUMBER | NUMBER |
NATIVE_DOUBLE 계열
| NATIVE_DOUBLE |
GOLDILOCKS는 분산을 다음과 같이 계산한다.
expr set의 개수가 1이면 0을 반환한다.
expr set의 개수가 1보다 크면, VAR_SAMP( expr ) 값을 반환한다.
자세한 내용은 STDDEV를 참조한다.
사용 예
gSQL> SELECT VARIANCE(c1) FROM t1;
VARIANCE(C1)
------------
132.2
1 row selected.
gSQL> SELECT VARIANCE(ALL c1) FROM t1;
VARIANCE(ALL C1)
----------------
132.2
1 row selected.
gSQL> SELECT VARIANCE(DISTINCT c1) FROM t1;
VARIANCE(DISTINCT C1)
---------------------
176.25
1 row selected.VERSION
구문
VERSION()
설명
제품의 version string을 얻는다.
사용 예
gSQL> SELECT VERSION() FROM dual; VERSION() ------------------------------------- Release Name.X.X.X revision(XXXXX) 1 row selected.
WIDTH_BUCKET
구문
WIDTH_BUCKET( num, min, max, cnt )
설명
WIDTH_BUCKET 함수는 명시된 min, max 범위에서 cnt와 동일한 넓이를 갖는 구간을 생성하고, num이 속하는 구간의 위치를 반환한다.
인자 num, min, max, cnt에는 숫자 타입이 올 수 있다.
min, max는 구간에 대한 범위를 의미하며, min, max 값이 같은 경우에는 에러를 반환한다. cnt는 구간 개수를 의미하고 양의 정수이어야 하며 0 이거나 음수인 경우에는 에러를 반환한다. 구간의 위치에는 1부터 시작하는 번호가 부여된다.
num, min, max, cnt 중 하나라도 NULL인 경우, 결과값도 NULL이다.
사용 예
gSQL> SELECT WIDTH_BUCKET( 5, 1, 20, 5 ) AS RESULT FROM DUAL;
RESULT
------
2
1 row selected.