이 페이지에서는 함수와 연산자를 비롯한 Cloud Spanner SQL 표현식을 설명합니다.
함수 호출 규칙
함수 설명에 달리 명시되어 있지 않는 한 모든 함수에는 다음 규칙이 적용됩니다.
- 숫자 유형을 허용하는 함수의 경우 한 피연산자가 부동 소수점 피연산자이고 다른 피연산자가 다른 숫자 유형이라면 함수가 평가되기 전에 두 피연산자 모두 FLOAT64로 변환됩니다.
- 피연산자가
NULL
이면 결과도NULL
입니다(IS 연산자 제외). - 시간대를 구분하는 함수의 경우(함수 설명에 나와 있음) 시간대를 지정하지 않으면 기본 시간대(America/Los_Angeles)가 사용됩니다.
SAFE. 접두사
구문:
SAFE.function_name()
설명
스칼라 함수를 SAFE.
프리픽스로 시작하면 오류 대신 NULL
을 반환합니다. SAFE.
프리픽스는 프리픽스가 붙은 함수 자체의 오류만 방지하며 인수 표현식을 평가하는 동안 발생하는 오류는 방지하지 않습니다. SAFE.
프리픽스는 '값이 범위를 벗어남' 오류와 같이 함수 입력 값 때문에 발생하는 오류만 방지하며, 내부 오류나 시스템 오류 같은 다른 오류는 여전히 발생할 수 있습니다. 함수가 오류를 반환하지 않으면 SAFE.
는 출력에 영향을 미치지 않습니다. RAND
같이 절대 오류를 반환하지 않는 함수에는 SAFE.
는 아무런 영향이 없습니다.
+
및 =
와 같은 연산자는 SAFE.
프리픽스를 지원하지 않습니다. 나누기 연산의 오류를 방지하려면 SAFE_DIVIDE를 사용하세요. IN
, ARRAY
, UNNEST
같은 일부 연산자는 함수와 비슷하지만 SAFE.
프리픽스를 지원하지 않습니다. CAST
및 EXTRACT
함수도 SAFE.
프리픽스를 지원하지 않습니다. 변환 오류를 방지하려면 SAFE_CAST를 사용하세요.
예시
다음 예시에서 SUBSTR
함수를 처음 사용하면 일반적으로 오류가 반환되는데, 함수가 음의 값을 가진 길이 인수를 지원하지 않기 때문입니다. 하지만 SAFE.
프리픽스가 있기 때문에 함수에서 대신 NULL
을 반환합니다. SUBSTR
함수를 두 번째 사용하면 예상되는 출력이 제공되며, SAFE.
프리픽스는 영향을 미치지 않습니다.
SELECT SAFE.SUBSTR('foo', 0, -2) AS safe_output UNION ALL
SELECT SAFE.SUBSTR('bar', 0, 2) AS safe_output;
+-------------+
| safe_output |
+-------------+
| NULL |
| ba |
+-------------+
변환 규칙
'변환'에는 Cast 변환과 강제 변환이 포함되며 이에 국한되지 않습니다.
- Cast 변환은 명시적 변환으로,
CAST()
함수를 사용합니다. - 강제 변환은 암시적 변환으로, 아래 설명된 조건에 따라 Cloud Spanner SQL이 자동으로 수행합니다.
UNIX_DATE()
와 같은 자체 함수 이름을 가진 세 번째 변환 함수 그룹도 있습니다.
아래 표는 Cloud Spanner SQL 데이터 유형에 가능한 모든 CAST
및 강제 변환을 요약한 것입니다. '강제 변환 대상'은 특정 데이터 유형(예: 열)의 모든 표현식에 적용됩니다.
원본 유형 | CAST 대상 | 강제 변환 대상 |
---|---|---|
INT64 | BOOL INT64 NUMERIC FLOAT64 STRING |
NUMERIC FLOAT64 |
NUMERIC | INT64 NUMERIC FLOAT64 STRING |
FLOAT64 |
FLOAT64 | INT64 NUMERIC FLOAT64 STRING |
|
BOOL | BOOL INT64 STRING |
|
STRING | BOOL INT64 NUMERIC FLOAT64 STRING BYTES DATE TIMESTAMP |
|
BYTES | STRING BYTES |
|
DATE | STRING DATE TIMESTAMP |
|
TIMESTAMP | STRING DATE TIMESTAMP |
|
ARRAY | ARRAY | |
STRUCT | STRUCT |
Cast 변환
구문:
CAST(expr AS typename)
쿼리에서 사용되는 Cast 구문은 표현식의 결과 유형이 다른 유형으로 변환되어야 함을 나타냅니다.
예시:
CAST(x=1 AS STRING)
x
가 1
이면 "true"
이고, NULL
외의 값이면 "false"
이고, x
가 NULL
이면 NULL
입니다.
원본 값에서 대상 도메인으로 성공적으로 매핑되지 못하는 지원 유형 간의 변환은 런타임 오류를 유발합니다. 예를 들어 BYTES를 STRING으로 변환하는데 바이트 시퀀스가 유효한 UTF-8이 아닌 경우에는 런타임 오류가 발생합니다.
다음 유형의 x
표현식을 변환할 때는 다음과 같은 규칙이 적용됩니다.
원본 | 대상 | x Cast 변환 시 규칙 |
---|---|---|
INT64 | FLOAT64 | 가깝지만 정확하지 않을 수 있는 FLOAT64 값을 반환합니다. |
INT64 | BOOL | x 가 0 이면 FALSE , 그렇지 않으면 TRUE 를 반환합니다. |
NUMERIC | 부동 소수점 | NUMERIC은 가장 가까운 부동 소수점 수로 변환되며 정밀도가 떨어질 수 있습니다. |
FLOAT64 | INT64 | 가장 가까운 INT64 값을 반환합니다. 1.5나 -0.5와 같은 중간 값은 0에서 멀어지는 방향으로 반올림됩니다. |
FLOAT64 | STRING | 근사치의 문자열 표시를 반환합니다. |
FLOAT64 | NUMERIC | 부동 소수점 수는 0에서 멀어지는 방향으로 반올림됩니다. NaN , +inf , -inf 변환 시 오류가 반환됩니다. NUMERIC 범위를 벗어난 값을 Cast 변환하면 오버플로 오류가 반환됩니다.
|
BOOL | INT64 | x 가 TRUE 이면 1 , 그렇지 않으면 0 을 반환합니다. |
BOOL | STRING | x 가 TRUE 이면 "true" , 그렇지 않으면 "false" 를 반환합니다. |
STRING | FLOAT64 | x 를 FLOAT64 값으로 반환하며, 유효한 FLOAT64 리터럴과 동일한 형식을 지니는 것으로 해석합니다."inf" , "+inf" , "-inf" , "nan" 의 변환도 지원합니다.변환 시 대소문자를 구분하지 않습니다. |
STRING | NUMERIC | STRING 에 포함된 숫자 리터럴은 NUMERIC 유형의 최대 정밀도 또는 범위를 초과하면 안 됩니다. 초과하면 오류가 발생합니다. 소수점 이하 자릿수가 9자리를 초과하면 결과 NUMERIC 값은 소수점 이하 자릿수가 9자리가 되도록 0에서 멀어지는 방향으로 반올림됩니다.
|
STRING | BOOL | x 가 "true" 이면TRUE , x 가 "false" 이면 FALSE 를 반환합니다.그 밖에 다른 x 값은 유효하지 않으며 이 경우 BOOL로 변환하지 않고 오류가 발생합니다.STRING은 BOOL로 변환 시 대소문자를 구분하지 않습니다. |
STRING | BYTES | STRING은 UTF-8 인코딩을 사용하여 BYTES로 변환됩니다. 예를 들어 STRING '©'는 BYTES로 변환될 때 16진수 값 C2와 A9를 갖는 2바이트 시퀀스가 됩니다. |
BYTES | STRING | UTF-8 STRING으로 해석되는 x 를 반환합니다.예를 들어 BYTES 리터럴 b'\xc2\xa9' 는 STRING으로 변환될 때 UTF-8로 해석되어 유니코드 문자 '©'가 됩니다.x 가 유효한 UTF-8이 아니면 오류가 발생합니다. |
ARRAY | ARRAY | 정확히 동일한 ARRAY 유형이어야 합니다. |
STRUCT | STRUCT | 다음 조건이 충족될 경우에 허용됩니다.
|
Safe 변환
CAST
사용 시 Cloud Spanner SQL이 Cast 변환을 수행할 수 없으면 쿼리가 실패할 수 있습니다. 예를 들어 다음 쿼리는 오류를 생성합니다.
SELECT CAST("apple" AS INT64) AS not_a_number;
이런 유형의 오류에서 쿼리를 보호하기 위해 SAFE_CAST
를 사용할 수 있습니다. SAFE_CAST
는 오류를 발생시키지 않고 NULL을 반환한다는 점을 제외하면 CAST
와 동일합니다.
SELECT SAFE_CAST("apple" AS INT64) AS not_a_number;
+--------------+
| not_a_number |
+--------------+
| NULL |
+--------------+
바이트에서 문자열로 변환하려면 SAFE_CONVERT_BYTES_TO_STRING
함수를 사용해도 됩니다. 잘못된 UTF-8 문자는 유니코드 대체 문자인 U+FFFD
로 대체됩니다. 자세한 내용은 SAFE_CONVERT_BYTES_TO_STRING을 참조하세요.
16진수 문자열을 정수로 변환
16진수 문자열(0x123
)로 작업하는 경우, 이 문자열을 정수로 변환할 수 있습니다.
SELECT '0x123' as hex_value, CAST('0x123' as INT64) as hex_to_int;
+-----------+------------+
| hex_value | hex_to_int |
+-----------+------------+
| 0x123 | 291 |
+-----------+------------+
SELECT '-0x123' as hex_value, CAST('-0x123' as INT64) as hex_to_int;
+-----------+------------+
| hex_value | hex_to_int |
+-----------+------------+
| -0x123 | -291 |
+-----------+------------+
날짜 유형 변환
Cloud Spanner SQL은 다음과 같이 날짜 유형과 문자열 간의 변환을 지원합니다.
CAST(date_expression AS STRING)
CAST(string_expression AS DATE)
날짜 유형을 문자열로 변환하는 것은 시간대와 관계가 없으며 YYYY-MM-DD
형태를 갖습니다. 문자열에서 날짜로 Cast 변환할 경우, 문자열이 지원되는 날짜 리터럴 형식과 일치해야 하며, 이는 시간대와 관계가 없습니다. 문자열 표현식이 유효하지 않거나 지원되는 최소/최대 범위 밖의 날짜를 나타낼 경우, 오류가 발생합니다.
타임스탬프 유형 변환
Cloud Spanner SQL은 다음과 같이 타임스탬프 유형을 문자열로, 또 그 반대로 변환하는 것을 지원합니다.
CAST(timestamp_expression AS STRING)
CAST(string_expression AS TIMESTAMP)
타임스탬프 유형에서 문자열로 변환할 경우, 타임스탬프가 기본 시간대인 America/Los_Angeles를 사용하여 해석됩니다. 생성되는 1초 미만 자릿수의 개수는 1초 미만 단위에 따라오는 0의 개수에 따라 결정됩니다. CAST 함수는 0, 3 또는 6자릿수를 잘라냅니다.
문자열에서 타임스탬프로 변환할 경우, string_expression
이 지원되는 타임스탬프 리터럴 형식과 일치해야 하며, 그렇지 않으면 런타임 오류가 발생합니다. string_expression
에 time_zone
이 포함될 수 있습니다. 시간대를 참조하세요.
string_expression
에 시간대가 있으면 해당 시간대가 변환에 사용되고, 그렇지 않으면 기본 시간대인 America/Los_Angeles가 사용됩니다.
문자열이 6자리 미만이면 묵시적으로 확장됩니다.
string_expression
이 유효하지 않거나, 1초 미만 자릿수가 6개보다 많거나(즉, 정밀도가 마이크로초 이상인 경우), 지원되는 타임스탬프 범위 밖의 시간을 나타내는 경우 오류가 발생합니다.
날짜 유형과 타임스탬프 유형 간 변환
Cloud Spanner SQL은 변환 규칙 테이블에 표시된 대로 날짜와 타임스탬프 유형 간 Cast 변환을 지원합니다.
CAST(date_expression AS TIMESTAMP)
CAST(timestamp_expression AS DATE)
날짜에서 타임스탬프로 변환할 경우 date_expression
은 기본 시간대인 America/Los_Angeles의 자정(하루의 시작)을 기준으로 해석됩니다. 타임스탬프에서 날짜로 변환할 경우 기본 시간대를 기준으로 타임스탬프가 효과적으로 잘립니다.
강제 변환
Cloud Spanner SQL은 함수 서명을 일치시켜야 하는 경우 표현식의 결과 유형을 다른 유형으로 강제 변환합니다. 예를 들어 함수 func()가 INT64 유형의 단일 인수를 취하도록 정의되어 있고, 표현식이 FLOAT64의 결과 유형을 갖는 인수로 사용되는 경우 이 표현식의 결과는 func()가 계산되기 전에 INT64 유형으로 강제 변환됩니다.
기타 변환 함수
Cloud Spanner SQL은 다음과 같은 변환 함수를 추가로 제공합니다.
집계 함수
집계 함수는 그룹의 행을 단일 값으로 요약하는 함수입니다. 집계 함수의 예로는 COUNT
, MIN
, MAX
가 있습니다.
SELECT COUNT(*) as total_count, COUNT(fruit) as non_null_count,
MIN(fruit) as min, MAX(fruit) as max
FROM (SELECT NULL as fruit UNION ALL
SELECT "apple" as fruit UNION ALL
SELECT "pear" as fruit UNION ALL
SELECT "orange" as fruit)
+-------------+----------------+-------+------+
| total_count | non_null_count | min | max |
+-------------+----------------+-------+------+
| 4 | 3 | apple | pear |
+-------------+----------------+-------+------+
GROUP BY
절과 함께 사용하면 일반적으로 요약된 그룹에 하나 이상의 행이 있습니다. 연결된 SELECT
에 GROUP BY
절이 없거나 특정 집계 함수가 요약할 그룹의 행을 필터링하면 집계 함수가 빈 그룹을 요약해야 할 수 있습니다. 이 경우 COUNT
및 COUNTIF
함수는 0
을 반환하고 다른 모든 집계 함수는 NULL
을 반환합니다.
다음 섹션에서는 Cloud Spanner SQL이 지원하는 집계 함수를 설명합니다.
ANY_VALUE
ANY_VALUE(expression [HAVING {MAX | MIN} expression2])
설명
그룹에서 선택한 일부 행의 expression
을 반환합니다. 선택할 행은 확정되어 있지 않으며 무작위가 아닙니다. 입력으로 행이 생성되지 않으면 NULL
을 반환합니다. 그룹의 모든 행에서 expression
이 NULL
이면 NULL
을 반환합니다.
ANY_VALUE
는 IGNORE NULLS
가 지정된 것과 같이 작동합니다. expression
이 NULL
인 행은 고려되지 않으며 선택되지 않습니다.
지원되는 인수 유형
모두
선택적 절
HAVING MAX
또는 HAVING MIN
: 함수가 집계하는 행 집합을 최댓값 또는 최솟값으로 제한합니다. 자세한 내용은 HAVING MAX 및 HAVING MIN 절을 참조하세요.
반환되는 데이터 유형
입력 데이터 유형과 일치합니다.
예시
SELECT ANY_VALUE(fruit) as any_value
FROM UNNEST(["apple", "banana", "pear"]) as fruit;
+-----------+
| any_value |
+-----------+
| apple |
+-----------+
ARRAY_AGG
ARRAY_AGG([DISTINCT] expression [{IGNORE|RESPECT} NULLS] [HAVING {MAX | MIN} expression2])
설명
expression
값의 ARRAY를 반환합니다.
지원되는 인수 유형
ARRAY를 제외한 모든 데이터 유형.
옵션 절
절은 다음 순서로 적용됩니다.
DISTINCT
: 각각의 고유한expression
값이 한 번만 결과에 집계됩니다.IGNORE NULLS
또는RESPECT NULLS
:IGNORE NULLS
가 지정되면NULL
값이 결과에서 제외됩니다.RESPECT NULLS
가 지정되거나 아무것도 지정되지 않으면 결과에NULL
값이 포함됩니다.HAVING MAX
또는HAVING MIN
: 함수가 집계하는 행 집합을 최댓값 또는 최솟값으로 제한합니다. 자세한 내용은 HAVING MAX 및 HAVING MIN 절을 참조하세요.
출력 요소 순서
출력 내 요소의 순서는 확정값이 아닙니다. 즉, 이 함수를 사용할 때마다 다른 결과를 얻을 수 있다는 뜻입니다.
반환되는 데이터 유형
ARRAY
0이 입력된 행이 있는 경우, 이 함수는 NULL
을 반환합니다.
예시
SELECT ARRAY_AGG(x) AS array_agg
FROM UNNEST([2, 1, -2, 3, -2, 1, 2]) AS x;
+-------------------------+
| array_agg |
+-------------------------+
| [2, 1, -2, 3, -2, 1, 2] |
+-------------------------+
SELECT ARRAY_AGG(DISTINCT x) AS array_agg
FROM UNNEST([2, 1, -2, 3, -2, 1, 2]) AS x;
+---------------+
| array_agg |
+---------------+
| [2, 1, -2, 3] |
+---------------+
SELECT ARRAY_AGG(x IGNORE NULLS) AS array_agg
FROM UNNEST([NULL, 1, -2, 3, -2, 1, NULL]) AS x;
+-------------------+
| array_agg |
+-------------------+
| [1, -2, 3, -2, 1] |
+-------------------+
ARRAY_CONCAT_AGG
ARRAY_CONCAT_AGG(expression [HAVING {MAX | MIN} expression2])
설명
ARRAY유형의 expression
에서 요소들을 연결하여 단일 ARRAY를 결과로 반환합니다. 이 함수는 NULL 입력 배열은 무시하지만 비 NULL 입력 배열의 NULL 요소는 고려합니다.
지원되는 인수 유형
ARRAY
선택적 절
HAVING MAX
또는 HAVING MIN
: 함수가 집계하는 행 집합을 최댓값 또는 최솟값으로 제한합니다. 자세한 내용은 HAVING MAX 및 HAVING MIN 절을 참조하세요.
출력 요소 순서
출력 내 요소의 순서는 확정값이 아닙니다. 즉, 이 함수를 사용할 때마다 다른 결과를 얻을 수 있다는 뜻입니다.
반환되는 데이터 유형
ARRAY
0이 입력된 행이 있거나 expression
이 모든 행에서 NULL로 평가되는 경우 NULL
을 반환합니다.
예시
SELECT ARRAY_CONCAT_AGG(x) AS array_concat_agg FROM (
SELECT [NULL, 1, 2, 3, 4] AS x
UNION ALL SELECT NULL
UNION ALL SELECT [5, 6]
UNION ALL SELECT [7, 8, 9]
);
+-----------------------------------+
| array_concat_agg |
+-----------------------------------+
| [NULL, 1, 2, 3, 4, 5, 6, 7, 8, 9] |
+-----------------------------------+
AVG
AVG([DISTINCT] expression [HAVING {MAX | MIN} expression2])
설명
NULL
이외 입력 값들의 평균을 반환하거나, 입력에 NaN
이 포함되어 있는 경우 NaN
을 반환합니다.
지원되는 인수 유형
INT64 등 모든 숫자 입력 유형. 부동 소수점 입력 유형의 경우 반환 결과가 확정값이 아닙니다. 즉, 이 함수를 사용할 때마다 다른 결과를 얻을 수 있다는 의미입니다.
옵션 절
절은 다음 순서로 적용됩니다.
DISTINCT
: 각각의 고유한expression
값이 한 번만 결과에 집계됩니다.HAVING MAX
또는HAVING MIN
: 함수가 집계하는 행 집합을 최댓값 또는 최솟값으로 제한합니다. 자세한 내용은 HAVING MAX 및 HAVING MIN 절을 참조하세요.
반환되는 데이터 유형
입력 | INT64 | NUMERIC | FLOAT64 |
---|---|---|---|
출력 | FLOAT64 | NUMERIC | FLOAT64 |
예시
SELECT AVG(x) as avg
FROM UNNEST([0, 2, 4, 4, 5]) as x;
+-----+
| avg |
+-----+
| 3 |
+-----+
SELECT AVG(DISTINCT x) AS avg
FROM UNNEST([0, 2, 4, 4, 5]) AS x;
+------+
| avg |
+------+
| 2.75 |
+------+
BIT_AND
BIT_AND([DISTINCT] expression [HAVING {MAX | MIN} expression2])
설명
expression
에 대해 비트 AND 연산을 수행하여 그 결과를 반환합니다.
지원되는 인수 유형
- INT64
옵션 절
절은 다음 순서로 적용됩니다.
DISTINCT
: 각각의 고유한expression
값이 한 번만 결과에 집계됩니다.HAVING MAX
또는HAVING MIN
: 함수가 집계하는 행 집합을 최댓값 또는 최솟값으로 제한합니다. 자세한 내용은 HAVING MAX 및 HAVING MIN 절을 참조하세요.
반환되는 데이터 유형
INT64
예시
SELECT BIT_AND(x) as bit_and FROM UNNEST([0xF001, 0x00A1]) as x;
+---------+
| bit_and |
+---------+
| 1 |
+---------+
BIT_OR
BIT_OR([DISTINCT] expression [HAVING {MAX | MIN} expression2])
설명
expression
에 대해 비트 OR 연산을 수행하여 그 결과를 반환합니다.
지원되는 인수 유형
- INT64
옵션 절
절은 다음 순서로 적용됩니다.
DISTINCT
: 각각의 고유한expression
값이 한 번만 결과에 집계됩니다.HAVING MAX
또는HAVING MIN
: 함수가 집계하는 행 집합을 최댓값 또는 최솟값으로 제한합니다. 자세한 내용은 HAVING MAX 및 HAVING MIN 절을 참조하세요.
반환되는 데이터 유형
INT64
예시
SELECT BIT_OR(x) as bit_or FROM UNNEST([0xF001, 0x00A1]) as x;
+--------+
| bit_or |
+--------+
| 61601 |
+--------+
BIT_XOR
BIT_XOR([DISTINCT] expression [HAVING {MAX | MIN} expression2])
설명
expression
에 대해 비트 XOR 연산을 수행하여 그 결과를 반환합니다.
지원되는 인수 유형
- INT64
옵션 절
절은 다음 순서로 적용됩니다.
DISTINCT
: 각각의 고유한expression
값이 한 번만 결과에 집계됩니다.HAVING MAX
또는HAVING MIN
: 함수가 집계하는 행 집합을 최댓값 또는 최솟값으로 제한합니다. 자세한 내용은 HAVING MAX 및 HAVING MIN 절을 참조하세요.
반환되는 데이터 유형
INT64
예시
SELECT BIT_XOR(x) AS bit_xor FROM UNNEST([5678, 1234]) AS x;
+---------+
| bit_xor |
+---------+
| 4860 |
+---------+
SELECT BIT_XOR(x) AS bit_xor FROM UNNEST([1234, 5678, 1234]) AS x;
+---------+
| bit_xor |
+---------+
| 5678 |
+---------+
SELECT BIT_XOR(DISTINCT x) AS bit_xor FROM UNNEST([1234, 5678, 1234]) AS x;
+---------+
| bit_xor |
+---------+
| 4860 |
+---------+
COUNT
1.
COUNT(*)
2.
COUNT([DISTINCT] expression [HAVING {MAX | MIN} expression2])
설명
- 입력에 있는 행의 수를 반환합니다.
NULL
이외의 값으로 평가된expression
이 있는 행의 수를 반환합니다.
지원되는 인수 유형
expression
에는 모든 데이터 유형이 지원됩니다. DISTINCT
가 있는 경우 expression
은 그룹화가 가능한 데이터 유형만 지원됩니다.
옵션 절
절은 다음 순서로 적용됩니다.
DISTINCT
: 각각의 고유한expression
값이 한 번만 결과에 집계됩니다.HAVING MAX
또는HAVING MIN
: 함수가 집계하는 행 집합을 최댓값 또는 최솟값으로 제한합니다. 자세한 내용은 HAVING MAX 및 HAVING MIN 절을 참조하세요.
반환 데이터 유형
INT64
예시
SELECT
COUNT(*) AS count_star,
COUNT(DISTINCT x) AS count_dist_x
FROM UNNEST([1, 4, 4, 5]) AS x;
+------------+--------------+
| count_star | count_dist_x |
+------------+--------------+
| 4 | 3 |
+------------+--------------+
SELECT COUNT(*) AS count_star, COUNT(x) AS count_x
FROM UNNEST([1, 4, NULL, 4, 5]) AS x;
+------------+---------+
| count_star | count_x |
+------------+---------+
| 5 | 4 |
+------------+---------+
COUNTIF
COUNTIF([DISTINCT] expression [HAVING {MAX | MIN} expression2])
설명
expression
의 TRUE
값 개수를 반환합니다. 입력 행이 없거나 expression
이 모든 행에 대해 FALSE
또는 NULL
로 평가하는 경우 0
을 반환합니다.
지원되는 인수 유형
BOOL
옵션 절
절은 다음 순서로 적용됩니다.
DISTINCT
: 각각의 고유한expression
값이 한 번만 결과에 집계됩니다.HAVING MAX
또는HAVING MIN
: 함수가 집계하는 행 집합을 최댓값 또는 최솟값으로 제한합니다. 자세한 내용은 HAVING MAX 및 HAVING MIN 절을 참조하세요.
반환 데이터 유형
INT64
예시
SELECT COUNTIF(x<0) AS num_negative, COUNTIF(x>0) AS num_positive
FROM UNNEST([5, -2, 3, 6, -10, -7, 4, 0]) AS x;
+--------------+--------------+
| num_negative | num_positive |
+--------------+--------------+
| 3 | 4 |
+--------------+--------------+
LOGICAL_AND
LOGICAL_AND(expression [HAVING {MAX | MIN} expression2])
설명
NULL
이 아닌 모든 표현식의 논리적 AND를 반환합니다. 0이 입력된 행이 있거나 expression
이 모든 행에서 NULL
로 평가되는 경우 NULL
을 반환합니다.
지원되는 인수 유형
BOOL
선택적 절
HAVING MAX
또는 HAVING MIN
: 함수가 집계하는 행 집합을 최댓값 또는 최솟값으로 제한합니다. 자세한 내용은 HAVING MAX 및 HAVING MIN 절을 참조하세요.
반환 데이터 유형
BOOL
예시
SELECT LOGICAL_AND(x) AS logical_and FROM UNNEST([true, false, true]) AS x;
+-------------+
| logical_and |
+-------------+
| false |
+-------------+
LOGICAL_OR
LOGICAL_OR(expression [HAVING {MAX | MIN} expression2])
설명
NULL
이 아닌 모든 표현식의 논리적 OR을 반환합니다. 0이 입력된 행이 있거나 expression
이 모든 행에서 NULL
로 평가되는 경우 NULL
을 반환합니다.
지원되는 인수 유형
BOOL
선택적 절
HAVING MAX
또는 HAVING MIN
: 함수가 집계하는 행 집합을 최댓값 또는 최솟값으로 제한합니다. 자세한 내용은 HAVING MAX 및 HAVING MIN 절을 참조하세요.
반환 데이터 유형
BOOL
예시
SELECT LOGICAL_OR(x) AS logical_or FROM UNNEST([true, false, true]) AS x;
+------------+
| logical_or |
+------------+
| true |
+------------+
MAX
MAX(expression [HAVING {MAX | MIN} expression2])
설명
NULL
이 아닌 표현식의 최댓값을 반환합니다. 0이 입력된 행이 있거나 expression
이 모든 행에서 NULL
로 평가되는 경우 NULL
을 반환합니다.
입력에 NaN
이 포함된 경우 NaN
을 반환합니다.
지원되는 인수 유형
다음을 제외한 모든 데이터 유형: ARRAY
STRUCT
선택적 절
HAVING MAX
또는 HAVING MIN
: 함수가 집계하는 행 집합을 최댓값 또는 최솟값으로 제한합니다. 자세한 내용은 HAVING MAX 및 HAVING MIN 절을 참조하세요.
반환 데이터 유형
입력값으로 사용된 데이터 유형과 동일합니다.
예시
SELECT MAX(x) AS max
FROM UNNEST([8, 37, 4, 55]) AS x;
+-----+
| max |
+-----+
| 55 |
+-----+
MIN
MIN(expression [HAVING {MAX | MIN} expression2])
설명
NULL
이 아닌 표현식의 최솟값을 반환합니다. 0이 입력된 행이 있거나 expression
이 모든 행에서 NULL
로 평가되는 경우 NULL
을 반환합니다.
입력에 NaN
이 포함된 경우 NaN
을 반환합니다.
지원되는 인수 유형
다음을 제외한 모든 데이터 유형: ARRAY
STRUCT
선택적 절
HAVING MAX
또는 HAVING MIN
: 함수가 집계하는 행 집합을 최댓값 또는 최솟값으로 제한합니다. 자세한 내용은 HAVING MAX 및 HAVING MIN 절을 참조하세요.
반환 데이터 유형
입력값으로 사용된 데이터 유형과 동일합니다.
예시
SELECT MIN(x) AS min
FROM UNNEST([8, 37, 4, 55]) AS x;
+-----+
| min |
+-----+
| 4 |
+-----+
STRING_AGG
STRING_AGG([DISTINCT] expression [, delimiter] [HAVING {MAX | MIN} expression2])
설명
null이 아닌 값을 연결하여 얻은 값(STRING 또는 BYTES)을 반환합니다.
delimiter
가 지정된 경우 연결된 값이 해당 구분 기호로 구분되고, 그렇지 않은 경우 쉼표가 구분 기호로 사용됩니다.
지원되는 인수 유형
STRING BYTES
옵션 절
절은 다음 순서로 적용됩니다.
DISTINCT
: 각각의 고유한expression
값이 한 번만 결과에 집계됩니다.HAVING MAX
또는HAVING MIN
: 함수가 집계하는 행 집합을 최댓값 또는 최솟값으로 제한합니다. 자세한 내용은 HAVING MAX 및 HAVING MIN 절을 참조하세요.
출력 요소 순서
출력 내 요소의 순서는 확정값이 아닙니다. 즉, 이 함수를 사용할 때마다 다른 결과를 얻을 수 있다는 뜻입니다.
반환 데이터 유형
STRING BYTES
예시
SELECT STRING_AGG(fruit) AS string_agg
FROM UNNEST(["apple", NULL, "pear", "banana", "pear"]) AS fruit;
+------------------------+
| string_agg |
+------------------------+
| apple,pear,banana,pear |
+------------------------+
SELECT STRING_AGG(fruit, " & ") AS string_agg
FROM UNNEST(["apple", "pear", "banana", "pear"]) AS fruit;
+------------------------------+
| string_agg |
+------------------------------+
| apple & pear & banana & pear |
+------------------------------+
SELECT STRING_AGG(DISTINCT fruit, " & ") AS string_agg
FROM UNNEST(["apple", "pear", "banana", "pear"]) AS fruit;
+-----------------------+
| string_agg |
+-----------------------+
| apple & pear & banana |
+-----------------------+
SUM
SUM([DISTINCT] expression [HAVING {MAX | MIN} expression2])
설명
null이 아닌 값의 합계를 반환합니다.
표현식이 부동 소수점 값인 경우, 합계가 확정값이 아닙니다. 즉, 이 함수를 사용할 때마다 다른 결과를 얻을 수 있다는 뜻입니다.
지원되는 인수 유형
지원되는 모든 숫자 데이터 유형.
옵션 절
절은 다음 순서로 적용됩니다.
DISTINCT
: 각각의 고유한expression
값이 한 번만 결과에 집계됩니다.HAVING MAX
또는HAVING MIN
: 함수가 집계하는 행 집합을 최댓값 또는 최솟값으로 제한합니다. 자세한 내용은 HAVING MAX 및 HAVING MIN 절을 참조하세요.
반환 데이터 유형
입력 | INT64 | NUMERIC | FLOAT64 |
---|---|---|---|
출력 | INT64 | NUMERIC | FLOAT64 |
특수한 경우:
입력에 NULL
만 포함된 경우 NULL
을 반환합니다.
입력에 행이 없으면 NULL
을 반환합니다.
입력에 Inf
가 포함된 경우 Inf
를 반환합니다.
입력에 -Inf
가 포함된 경우 -Inf
를 반환합니다.
입력에 NaN
이 포함된 경우 NaN
을 반환합니다.
입력에 Inf
와 -Inf
의 조합이 포함된 경우 NaN
을 반환합니다.
예시
SELECT SUM(x) AS sum
FROM UNNEST([1, 2, 3, 4, 5, 4, 3, 2, 1]) AS x;
+-----+
| sum |
+-----+
| 25 |
+-----+
SELECT SUM(DISTINCT x) AS sum
FROM UNNEST([1, 2, 3, 4, 5, 4, 3, 2, 1]) AS x;
+-----+
| sum |
+-----+
| 15 |
+-----+
SELECT SUM(x) AS sum
FROM UNNEST([]) AS x;
+------+
| sum |
+------+
| NULL |
+------+
공통 절
HAVING MAX 및 HAVING MIN 절
대부분의 집계 함수는 HAVING MAX
및 HAVING MIN
라는 두 개의 선택적 절을 지원하는데 이는 함수가 특정 열에서 최댓값 또는 최솟값을 가진 행으로 집계하는 행 집합을 제한합니다. 구문은 일반적으로 다음과 같습니다.
aggregate_function(expression1 [HAVING {MAX | MIN} expression2])
HAVING MAX
: 함수가 집계하는 행 집합을 그룹 내expression2
의 최댓값과 동일한expression2
값을 갖는 항목으로 제한합니다. 최댓값은MAX(expression2)
의 결과와 같습니다.HAVING MIN
: 함수가 집계하는 행 집합을 그룹 내expression2
의 최솟값과 동일한expression2
값을 갖는 항목으로 제한합니다. 최솟값은MIN(expression2)
의 결과와 같습니다.
이러한 절은 expression2
가 모든 행에서 NULL
로 평가되지 않는 한 최댓값 또는 최솟값을 계산할 때 NULL
값을 무시합니다.
이러한 절은 다음 데이터 유형을 지원하지 않습니다.
ARRAY
STRUCT
예시
이 예시에서는 최근 연도인 2001년에 대한 평균 강수량을 반환합니다.
WITH Precipitation AS
(SELECT 2001 as year, 'spring' as season, 9 as inches UNION ALL
SELECT 2001, 'winter', 1 UNION ALL
SELECT 2000, 'fall', 3 UNION ALL
SELECT 2000, 'summer', 5 UNION ALL
SELECT 2000, 'spring', 7 UNION ALL
SELECT 2000, 'winter', 2)
SELECT AVG(inches HAVING MAX year) as average FROM Precipitation
+---------+
| average |
+---------+
| 5 |
+---------+
먼저 이 쿼리는 year
열에서 최댓값이 있는 행을 가져옵니다.
다음과 같이 2개가 있습니다.
+------+--------+--------+
| year | season | inches |
+------+--------+--------+
| 2001 | spring | 9 |
| 2001 | winter | 1 |
+------+--------+--------+
마지막으로 이 쿼리는 inches
열(9 및 1)의 값을 다음과 같은 결과로 평균을 계산합니다.
+---------+
| average |
+---------+
| 5 |
+---------+
통계 집계 함수
Cloud Spanner SQL은 다음 통계 집계 함수를 지원합니다.
STDDEV_SAMP
STDDEV_SAMP([DISTINCT] expression [HAVING {MAX | MIN} expression2])
설명
값의 샘플(비편향) 표준 편차를 반환합니다. 반환 결과는 0
~+Inf
사이입니다.
모든 숫자 유형이 지원됩니다. 입력이 NUMERIC
이면 최종 출력이 FLOAT64
로 변환되어 내부 집계가 안정적입니다.
그렇지 않으면 입력이 집계 전에 FLOAT64
으로 변환되어 결과가 불안정할 수 있습니다.
이 함수는 모든 NULL 입력을 무시합니다. NULL이 아닌 입력이 2개 미만인 경우, 이 함수는 NULL을 반환합니다.
옵션 절
절은 다음 순서로 적용됩니다.
DISTINCT
: 각각의 고유한expression
값이 한 번만 결과에 집계됩니다.HAVING MAX
또는HAVING MIN
: 함수가 집계하는 행 집합을 최댓값 또는 최솟값으로 제한합니다. 자세한 내용은 HAVING MAX 및 HAVING MIN 절을 참조하세요.
반환 데이터 유형
FLOAT64
STDDEV
STDDEV([DISTINCT] expression [HAVING {MAX | MIN} expression2])
설명
STDDEV_SAMP의 별칭입니다.
VAR_SAMP
VAR_SAMP([DISTINCT] expression [HAVING {MAX | MIN} expression2])
설명
값의 샘플(비편향) 분산을 반환합니다. 반환 결과는 0
~+Inf
사이입니다.
모든 숫자 유형이 지원됩니다. 입력이 NUMERIC
이면 최종 출력이 FLOAT64
로 변환되어 내부 집계가 안정적입니다.
그렇지 않으면 입력이 집계 전에 FLOAT64
으로 변환되어 결과가 불안정할 수 있습니다.
이 함수는 모든 NULL 입력을 무시합니다. NULL이 아닌 입력이 2개 미만인 경우, 이 함수는 NULL을 반환합니다.
옵션 절
절은 다음 순서로 적용됩니다.
DISTINCT
: 각각의 고유한expression
값이 한 번만 결과에 집계됩니다.HAVING MAX
또는HAVING MIN
: 함수가 집계하는 행 집합을 최댓값 또는 최솟값으로 제한합니다. 자세한 내용은 HAVING MAX 및 HAVING MIN 절을 참조하세요.
반환 데이터 유형
FLOAT64
VARIANCE
VARIANCE([DISTINCT] expression [HAVING {MAX | MIN} expression2])
설명
VAR_SAMP의 별칭입니다.
수학 함수
모든 수학 함수는 다음과 같이 동작합니다.
- 입력 매개변수 중 하나가
NULL
인 경우NULL
을 반환합니다. - 인수 중 하나가
NaN
인 경우NaN
을 반환합니다.
ABS
ABS(X)
설명
절대값을 계산합니다. 인수가 정수이고 출력값을 동일한 유형으로 나타낼 수 없는 경우 오류를 반환합니다. 양의 표현이 없는 최대 음의 입력값의 경우에만 이 오류가 발생합니다.
X | ABS(X) |
---|---|
25 | 25 |
-25 | 25 |
+inf |
+inf |
-inf |
+inf |
반환 데이터 유형
입력 | INT64 | NUMERIC | FLOAT64 |
---|---|---|---|
출력 | INT64 | NUMERIC | FLOAT64 |
SIGN
SIGN(X)
설명
음의 인수, 0, 양의 인수에 각각 -1
, 0
, +1
을 반환합니다. 이 함수는 부동 소수점 인수의 양의 0과 음의 0을 구별하지 않습니다.
X | SIGN(X) |
---|---|
25 | +1 |
0 | 0 |
-25 | -1 |
NaN | NaN |
반환 데이터 유형
입력 | INT64 | NUMERIC | FLOAT64 |
---|---|---|---|
출력 | INT64 | NUMERIC | FLOAT64 |
IS_INF
IS_INF(X)
설명
값이 양의 무한대이거나 음의 무한대이면 TRUE
를 반환합니다.
NUMERIC
가 INF
일 수 없으므로 NUMERIC
입력에는 FALSE
을 반환합니다.
X | IS_INF(X) |
---|---|
+inf |
TRUE |
-inf |
TRUE |
25 | FALSE |
IS_NAN
IS_NAN(X)
설명
값이 NaN
값이면 TRUE
를 반환합니다.
NUMERIC
가 NaN
일 수 없으므로 NUMERIC
입력에는 FALSE
을 반환합니다.
X | IS_NAN(X) |
---|---|
NaN |
TRUE |
25 | FALSE |
IEEE_DIVIDE
IEEE_DIVIDE(X, Y)
설명
X를 Y로 나눕니다. 이 함수는 절대 실패하지 않습니다. FLOAT64
를 반환합니다. 나누기 연산자(/)와 달리 이 함수는 0으로 나누기 또는 오버플로 오류를 생성하지 않습니다.
X | Y | IEEE_DIVIDE(X, Y) |
---|---|---|
20.0 | 4.0 | 5.0 |
0.0 | 25.0 | 0.0 |
25.0 | 0.0 | +inf |
-25.0 | 0.0 | -inf |
0.0 | 0.0 | NaN |
0.0 | NaN |
NaN |
NaN |
0.0 | NaN |
+inf |
+inf |
NaN |
-inf |
-inf |
NaN |
SQRT
SQRT(X)
설명
X의 제곱근을 계산합니다. X가 0보다 작은 경우 오류를 생성합니다.
X | SQRT(X) |
---|---|
25.0 |
5.0 |
+inf |
+inf |
X < 0 |
오류 |
반환 데이터 유형
NUMERIC
은 입력으로 직접 지원되지 않습니다. 먼저 NUMERIC
을 명시적으로 FLOAT64
로 변환해야 합니다. 출력은 FLOAT64
입니다.
POW
POW(X, Y)
설명
X의 Y로 거듭제곱한 값을 반환합니다. 결과가 언더플로이고 나타낼 수 없는 경우, 이 함수는 0 값을 반환합니다.
X | Y | POW(X, Y) |
---|---|---|
2.0 | 3.0 | 8.0 |
1.0 | NaN 을 포함한 모든 값 |
1.0 |
NaN 을 포함한 모든 값 |
0 | 1.0 |
-1.0 | +inf |
1.0 |
-1.0 | -inf |
1.0 |
ABS(X) < 1 | -inf |
+inf |
ABS(X) > 1 | -inf |
0.0 |
ABS(X) < 1 | +inf |
0.0 |
ABS(X) > 1 | +inf |
+inf |
-inf |
Y < 0 | 0.0 |
-inf |
Y > 0 | Y가 홀수이면 -inf , 그렇지 않으면 +inf |
+inf |
Y < 0 | 0 |
+inf |
Y > 0 | +inf |
Finite 값 < 0 | 정수 아님 | 오류 |
0 | Finite 값 < 0 | 오류 |
반환 데이터 유형
반환 데이터 유형은 다음 표의 인수 유형에 따라 결정됩니다.
입력 | INT64 | NUMERIC | FLOAT64 |
---|---|---|---|
INT64 | FLOAT64 | NUMERIC | FLOAT64 |
NUMERIC | NUMERIC | NUMERIC | FLOAT64 |
FLOAT64 | FLOAT64 | FLOAT64 | FLOAT64 |
POWER
POWER(X, Y)
설명
POW(X, Y)
의 동의어입니다.
EXP
EXP(X)
설명
e의 X승을 계산합니다. 자연 지수 함수라고도 합니다. 결과가 언더플로인 경우, 이 함수는 0을 반환합니다. 결과가 오버플로인 경우 오류를 생성합니다.
X | EXP(X) |
---|---|
0.0 | 1.0 |
+inf |
+inf |
-inf |
0.0 |
반환 데이터 유형
NUMERIC
은 입력으로 직접 지원되지 않습니다. 먼저 NUMERIC
입력을 FLOAT64
로 명시적으로 전송해야 합니다. 출력은 FLOAT64
입니다.
LN
LN(X)
설명
X의 자연대수를 계산합니다. X가 0 이하이면 오류를 생성합니다.
X | LN(X) |
---|---|
1.0 | 0.0 |
+inf |
+inf |
X < 0 |
오류 |
반환 데이터 유형
NUMERIC
은 입력으로 직접 지원되지 않습니다. 먼저 NUMERIC
입력을 FLOAT64
로 명시적으로 전송해야 합니다. 출력은 FLOAT64
입니다.
LOG
LOG(X [, Y])
설명
X만 존재하는 경우, LOG
는 LN
의 동의어입니다. Y도 존재한다면, LOG
는 Y를 밑으로 하는 X의 로그를 계산합니다.
X | Y | LOG(X, Y) |
---|---|---|
100.0 | 10.0 | 2.0 |
-inf |
모든 값 | NaN |
모든 값 | +inf |
NaN |
+inf |
0.0 < Y < 1.0 | -inf |
+inf |
Y > 1.0 | +inf |
X <= 0 | 모든 값 | 오류 |
모든 값 | Y <= 0 | 오류 |
모든 값 | 1.0 | 오류 |
반환 데이터 유형
NUMERIC
은 입력으로 직접 지원되지 않습니다. 먼저 NUMERIC
입력을 FLOAT64
로 명시적으로 전송해야 합니다. 출력은 FLOAT64
입니다.
LOG10
LOG10(X)
설명
LOG
와 유사하되, 10을 밑으로 한 로그를 계산합니다.
X | LOG10(X) |
---|---|
100.0 | 2.0 |
-inf |
NaN |
+inf |
NaN |
X <= 0 | 오류 |
반환 데이터 유형
NUMERIC
은 입력으로 직접 지원되지 않습니다. 먼저 NUMERIC
입력을 FLOAT64
로 명시적으로 전송해야 합니다. 출력은 FLOAT64
입니다.
GREATEST
GREATEST(X1,...,XN)
설명
< 비교에 따라 X1, ..., XN 중 가장 큰 값을 반환합니다.
X1,...,XN | GREATEST(X1,...,XN) |
---|---|
3,5,1 | 5 |
반환 데이터 유형
입력 값의 데이터 유형입니다.
LEAST
LEAST(X1,...,XN)
설명
> 비교에 따라 X1, ..., XN 중 가장 작은 값을 반환합니다.
X1,...,XN | LEAST(X1,...,XN) |
---|---|
3,5,1 | 1 |
반환 데이터 유형
입력 값의 데이터 유형입니다.
DIV
DIV(X, Y)
설명
X/Y의 정수 나누기 결과를 반환합니다. 0으로 나눌 경우 오류를 반환합니다. -1로 나누면 오버플로가 발생할 수 있습니다. 두 입력 모두 NUMERIC
이고 결과가 오버플로인 경우 numeric overflow
오류가 반환됩니다.
X | Y | DIV(X, Y) |
---|---|---|
20 | 4 | 5 |
0 | 20 | 0 |
20 | 0 | 오류 |
반환 데이터 유형
반환 데이터 유형은 다음 표의 인수 유형에 따라 결정됩니다.
입력 | INT64 | NUMERIC |
---|---|---|
INT64 | INT64 | NUMERIC |
NUMERIC | NUMERIC | NUMERIC |
SAFE_DIVIDE
SAFE_DIVIDE(X, Y)
설명
나누기 연산자(X / Y
)와 동일하지만 0으로 나누기와 같은 오류가 발생하면 NULL
을 반환합니다.
X | Y | SAFE_DIVIDE(X, Y) |
---|---|---|
20 | 4 | 5 |
0 | 20 | 0 |
20 | 0 | NULL |
반환 데이터 유형
입력 | INT64 | NUMERIC | FLOAT64 |
---|---|---|---|
INT64 | FLOAT64 | NUMERIC | FLOAT64 |
NUMERIC | NUMERIC | NUMERIC | FLOAT64 |
FLOAT64 | FLOAT64 | FLOAT64 | FLOAT64 |
SAFE_MULTIPLY
SAFE_MULTIPLY(X, Y)
설명
곱하기 연산자(*
)와 동일하지만 오버플로가 발생하면 NULL
을 반환합니다.
X | Y | SAFE_MULTIPLY(X, Y) |
---|---|---|
20 | 4 | 80 |
반환 데이터 유형
입력 | INT64 | NUMERIC | FLOAT64 |
---|---|---|---|
INT64 | INT64 | NUMERIC | FLOAT64 |
NUMERIC | NUMERIC | NUMERIC | FLOAT64 |
FLOAT64 | FLOAT64 | FLOAT64 | FLOAT64 |
SAFE_NEGATE
SAFE_NEGATE(X)
설명
단행 빼기 연산자(-
)와 동일하지만 오버플로가 발생하면 NULL
을 반환합니다.
X | SAFE_NEGATE(X) |
---|---|
+1 | -1 |
-1 | +1 |
0 | 0 |
반환 데이터 유형
입력 | INT64 | NUMERIC | FLOAT64 |
---|---|---|---|
출력 | INT64 | NUMERIC | FLOAT64 |
SAFE_ADD
SAFE_ADD(X, Y)
설명
더하기 연산자(+
)와 동일하지만 오버플로가 발생하면 NULL
을 반환합니다.
X | Y | SAFE_ADD(X, Y) |
---|---|---|
5 | 4 | 9 |
반환 데이터 유형
입력 | INT64 | NUMERIC | FLOAT64 |
---|---|---|---|
INT64 | INT64 | NUMERIC | FLOAT64 |
NUMERIC | NUMERIC | NUMERIC | FLOAT64 |
FLOAT64 | FLOAT64 | FLOAT64 | FLOAT64 |
SAFE_SUBTRACT
SAFE_SUBTRACT(X, Y)
설명
X에서 Y를 뺀 결과를 반환합니다.
뺄셈 연산자(-
)와 동일하지만 오버플로가 발생하면 NULL
을 반환합니다.
X | Y | SAFE_SUBTRACT(X, Y) |
---|---|---|
5 | 4 | 1 |
반환 데이터 유형
입력 | INT64 | NUMERIC | FLOAT64 |
---|---|---|---|
INT64 | INT64 | NUMERIC | FLOAT64 |
NUMERIC | NUMERIC | NUMERIC | FLOAT64 |
FLOAT64 | FLOAT64 | FLOAT64 | FLOAT64 |
MOD
MOD(X, Y)
설명
모듈로 함수: X를 Y로 나눈 나머지를 반환합니다. 반환되는 값은 X와 동일한 기호를 갖습니다. Y가 0이면 오류가 생성됩니다.
X | Y | MOD(X, Y) |
---|---|---|
25 | 12 | 1 |
25 | 0 | 오류 |
반환 데이터 유형
반환 데이터 유형은 다음 표의 인수 유형에 따라 결정됩니다.
입력 | INT64 | NUMERIC |
---|---|---|
INT64 | INT64 | NUMERIC |
NUMERIC | NUMERIC | NUMERIC |
ROUND
ROUND(X [, N])
설명
X만 존재하는 경우, ROUND
는 X를 가장 가까운 정수로 반올림합니다. N이 존재하는 경우, ROUND
는 X를 소수점 이하 N자리까지 반올림합니다. N이 음수이면 ROUND
는 소수점 왼쪽의 자릿수를 반올림합니다. 중간값은 올림됩니다. 오버플로가 발생하면 오류를 생성합니다.
X | ROUND(X) |
---|---|
2.0 | 2.0 |
2.3 | 2.0 |
2.8 | 3.0 |
2.5 | 3.0 |
-2.3 | -2.0 |
-2.8 | -3.0 |
-2.5 | -3.0 |
0 | 0 |
+inf |
+inf |
-inf |
-inf |
NaN |
NaN |
반환 데이터 유형
입력 | INT64 | NUMERIC | FLOAT64 |
---|---|---|---|
출력 | FLOAT64 | NUMERIC | FLOAT64 |
TRUNC
TRUNC(X [, N])
설명
X만 존재하는 경우 TRUNC
는 절대값이 X의 절대값 이하인 가장 가까운 정수로 X를 반올림합니다. N도 존재할 경우, TRUNC
는 ROUND(X, N)
과 유사하게 동작하지만, 항상 0쪽으로 반올림하며 절대 오버플로가 발생하지 않습니다.
X | TRUNC(X) |
---|---|
2.0 | 2.0 |
2.3 | 2.0 |
2.8 | 2.0 |
2.5 | 2.0 |
-2.3 | -2.0 |
-2.8 | -2.0 |
-2.5 | -2.0 |
0 | 0 |
+inf |
+inf |
-inf |
-inf |
NaN |
NaN |
반환 데이터 유형
입력 | INT64 | NUMERIC | FLOAT64 |
---|---|---|---|
출력 | FLOAT64 | NUMERIC | FLOAT64 |
CEIL
CEIL(X)
설명
X보다 작은 가장 작은 정수 값을 반환합니다.
X | CEIL(X) |
---|---|
2.0 | 2.0 |
2.3 | 3.0 |
2.8 | 3.0 |
2.5 | 3.0 |
-2.3 | -2.0 |
-2.8 | -2.0 |
-2.5 | -2.0 |
0 | 0 |
+inf |
+inf |
-inf |
-inf |
NaN |
NaN |
반환 데이터 유형
입력 | INT64 | NUMERIC | FLOAT64 |
---|---|---|---|
출력 | FLOAT64 | NUMERIC | FLOAT64 |
CEILING
CEILING(X)
설명
CEIL(X)의 동의어
FLOOR
FLOOR(X)
설명
X보다 크지 않은 가장 큰 정수 값을 반환합니다.
X | FLOOR(X) |
---|---|
2.0 | 2.0 |
2.3 | 2.0 |
2.8 | 2.0 |
2.5 | 2.0 |
-2.3 | -3.0 |
-2.8 | -3.0 |
-2.5 | -3.0 |
0 | 0 |
+inf |
+inf |
-inf |
-inf |
NaN |
NaN |
반환 데이터 유형
입력 | INT64 | NUMERIC | FLOAT64 |
---|---|---|---|
출력 | FLOAT64 | NUMERIC | FLOAT64 |
COS
COS(X)
설명
라디안으로 지정된 X의 코사인을 계산합니다. 절대 실패하지 않습니다.
X | COS(X) |
---|---|
+inf |
NaN |
-inf |
NaN |
NaN |
NaN |
COSH
COSH(X)
설명
라디안으로 지정된 X의 쌍곡선 코사인을 계산합니다. 오버플로가 발생하면 오류를 생성합니다.
X가 NUMERIC
이면 출력은 FLOAT64
입니다.
X | COSH(X) |
---|---|
+inf |
+inf |
-inf |
+inf |
NaN |
NaN |
ACOS
ACOS(X)
설명
X의 역코사인 주요 값을 계산합니다. 반환 값의 범위는 [0,π]입니다. X의 값이 [-1, 1] 범위를 벗어나면 오류를 생성합니다.
X가 NUMERIC
이면 출력은 FLOAT64
입니다.
X | ACOS(X) |
---|---|
+inf |
NaN |
-inf |
NaN |
NaN |
NaN |
X < -1 | 오류 |
X > 1 | 오류 |
ACOSH
ACOSH(X)
설명
X의 역쌍곡선 코사인을 계산합니다. X의 값이 1 미만이면 오류를 생성합니다.
X가 NUMERIC
이면 출력은 FLOAT64
입니다.
X | ACOSH(X) |
---|---|
+inf |
+inf |
-inf |
NaN |
NaN |
NaN |
X < 1 | 오류 |
SIN
SIN(X)
설명
라디안으로 지정된 X의 사인을 계산합니다. 절대 실패하지 않습니다.
X | SIN(X) |
---|---|
+inf |
NaN |
-inf |
NaN |
NaN |
NaN |
SINH
SINH(X)
설명
라디안으로 지정된 X의 쌍곡선 사인을 계산합니다. 오버플로가 발생하면 오류를 생성합니다.
X가 NUMERIC
이면 출력은 FLOAT64
입니다.
X | SINH(X) |
---|---|
+inf |
+inf |
-inf |
-inf |
NaN |
NaN |
ASIN
ASIN(X)
설명
X의 역사인 주요 값을 계산합니다. 반환 값의 범위는 [-π/2,π/2]입니다. X가 [-1, 1] 범위를 벗어나면 오류를 생성합니다.
X가 NUMERIC
이면 출력은 FLOAT64
입니다.
X | ASIN(X) |
---|---|
+inf |
NaN |
-inf |
NaN |
NaN |
NaN |
X < -1 | 오류 |
X > 1 | 오류 |
ASINH
ASINH(X)
설명
X의 역쌍곡선 사인을 계산합니다. 이 함수는 실패하지 않습니다.
X가 NUMERIC
이면 출력은 FLOAT64
입니다.
X | ASINH(X) |
---|---|
+inf |
+inf |
-inf |
-inf |
NaN |
NaN |
TAN
TAN(X)
설명
라디안으로 지정된 X의 탄젠트를 계산합니다. 오버플로가 발생하면 오류를 생성합니다.
X | TAN(X) |
---|---|
+inf |
NaN |
-inf |
NaN |
NaN |
NaN |
TANH
TANH(X)
설명
라디안으로 지정된 X의 쌍곡선 탄젠트를 계산합니다. 오류가 발생하지 않습니다.
X가 NUMERIC
이면 출력은 FLOAT64
입니다.
X | TANH(X) |
---|---|
+inf |
1.0 |
-inf |
-1.0 |
NaN |
NaN |
ATAN
ATAN(X)
설명
X의 역탄젠트 주요 값을 계산합니다. 반환 값의 범위는 [-π/2,π/2]입니다. 이 함수는 실패하지 않습니다.
X가 NUMERIC
이면 출력은 FLOAT64
입니다.
X | ATAN(X) |
---|---|
+inf |
π/2 |
-inf |
-π/2 |
NaN |
NaN |
ATANH
ATANH(X)
설명
X의 역쌍곡선 탄젠트를 계산합니다. X의 값이 [-1, 1] 범위를 벗어나면 오류를 생성합니다.
X가 NUMERIC
이면 출력은 FLOAT64
입니다.
X | ATANH(X) |
---|---|
+inf |
NaN |
-inf |
NaN |
NaN |
NaN |
X < -1 | 오류 |
X > 1 | 오류 |
ATAN2
ATAN2(X, Y)
설명
사분면을 결정하기 위해 두 인수의 기호를 사용하여 X/Y의 역탄젠트 주 값을 계산합니다. 반환 값은 [-π,π] 범위 이내입니다.
X가 NUMERIC
이면 출력은 FLOAT64
입니다.
X | Y | ATAN2(X, Y) |
---|---|---|
NaN |
모든 값 | NaN |
모든 값 | NaN |
NaN |
0.0 | 0.0 | 0.0 |
양의 유한 값 | -inf |
π |
음의 유한 값 | -inf |
-π |
유한 값 | +inf |
0.0 |
+inf |
유한 값 | π/2 |
-inf |
유한 값 | -π/2 |
+inf |
-inf |
¾π |
-inf |
-inf |
-¾π |
+inf |
+inf |
π/4 |
-inf |
+inf |
-π/4 |
해시 함수
FARM_FINGERPRINT
FARM_FINGERPRINT(value)
설명
오픈소스 FarmHash 라이브러리의 Fingerprint64
함수를 사용하여 STRING
또는 BYTES
입력의 지문을 계산합니다. 특정 입력에 대한 이 함수의 출력은 변경되지 않습니다.
반환 유형
INT64
예시
WITH example AS (
SELECT 1 AS x, "foo" AS y, true AS z UNION ALL
SELECT 2 AS x, "apple" AS y, false AS z UNION ALL
SELECT 3 AS x, "" AS y, true AS z
)
SELECT
*,
FARM_FINGERPRINT(CONCAT(CAST(x AS STRING), y, CAST(z AS STRING)))
AS row_fingerprint
FROM example;
+---+-------+-------+----------------------+
| x | y | z | row_fingerprint |
+---+-------+-------+----------------------+
| 1 | foo | true | -1541654101129638711 |
| 2 | apple | false | 2794438866806483259 |
| 3 | | true | -4880158226897771312 |
+---+-------+-------+----------------------+
SHA1
SHA1(input)
설명
SHA-1 알고리즘을 사용하여 입력의 해시를 계산합니다. 입력은 STRING
또는 BYTES
일 수 있습니다. 문자열 버전은 입력을 바이트 배열로 취급합니다.
이 함수는 20바이트를 반환합니다.
반환 유형
BYTES
예시
SELECT SHA1("Hello World") as sha1;
-- Note that the result of SHA1 is of type BYTES, displayed as a base64-encoded string.
+------------------------------+
| sha1 |
+------------------------------+
| Ck1VqNd45QIvq3AZd8XYQLvEhtA= |
+------------------------------+
SHA256
SHA256(input)
설명
SHA-256 알고리즘을 사용하여 입력의 해시를 계산합니다. 입력은 STRING
또는 BYTES
일 수 있습니다. 문자열 버전은 입력을 바이트 배열로 취급합니다.
이 함수는 32바이트를 반환합니다.
반환 유형
BYTES
예시
SELECT SHA256("Hello World") as sha256;
SHA512
SHA512(input)
설명
SHA-512 알고리즘을 사용하여 입력의 해시를 계산합니다. 입력은 STRING
또는 BYTES
일 수 있습니다. 문자열 버전은 입력을 바이트 배열로 취급합니다.
이 함수는 64바이트를 반환합니다.
반환 유형
BYTES
예시
SELECT SHA512("Hello World") as sha512;
문자열 함수
이 문자열 함수는 STRING
및 BYTES
데이터 유형이라는 두 가지 값에 작동합니다. STRING
값은 올바르게 구성된 UTF-8이어야 합니다.
STRPOS와 같은 위치 값을 반환하는 함수는 이러한 위치를 INT64
로 인코딩합니다. 값 1
은 첫 번째 문자(또는 바이트)를 나타내고 2
는 두 번째 문자를 나타냅니다.
값 0
은 잘못된 색인을 나타냅니다. STRING
유형에서 작동하는 경우 반환되는 위치는 문자 위치를 나타냅니다.
모든 문자열 비교는 유니코드 규범적 등가와 관계없이 바이트 단위로 수행됩니다.
BYTE_LENGTH
BYTE_LENGTH(value)
설명
값 유형이 STRING
이나 BYTES
에 관계없이 STRING
또는 BYTES
값의 길이를 BYTES
단위로 반환합니다.
반환 유형
INT64
예시
WITH example AS
(SELECT "абвгд" AS characters, b"абвгд" AS bytes)
SELECT
characters,
BYTE_LENGTH(characters) AS string_example,
bytes,
BYTE_LENGTH(bytes) AS bytes_example
FROM example;
+------------+----------------+-------+---------------+
| characters | string_example | bytes | bytes_example |
+------------+----------------+-------+---------------+
| абвгд | 10 | абвгд | 10 |
+------------+----------------+-------+---------------+
CHAR_LENGTH
CHAR_LENGTH(value)
설명
STRING
의 길이를 문자 단위로 반환합니다.
반환 유형
INT64
예시
WITH example AS
(SELECT "абвгд" AS characters)
SELECT
characters,
CHAR_LENGTH(characters) AS char_length_example
FROM example;
+------------+---------------------+
| characters | char_length_example |
+------------+---------------------+
| абвгд | 5 |
+------------+---------------------+
CHARACTER_LENGTH
CHARACTER_LENGTH(value)
설명
CHAR_LENGTH의 동의어입니다.
반환 유형
INT64
예시
WITH example AS
(SELECT "абвгд" AS characters)
SELECT
characters,
CHARACTER_LENGTH(characters) AS char_length_example
FROM example;
+------------+---------------------+
| characters | char_length_example |
+------------+---------------------+
| абвгд | 5 |
+------------+---------------------+
CODE_POINTS_TO_BYTES
CODE_POINTS_TO_BYTES(ascii_values)
설명
확장된 ASCII 코드 포인트의 배열(INT64
의 ARRAY
)을 사용하여 BYTES
를 반환합니다.
BYTES
를 코드 포인트의 배열로 변환하려면 TO_CODE_POINTS를 참조하세요.
반환 유형
BYTES
예시
다음은 CODE_POINTS_TO_BYTES
를 사용하는 기본적인 예시입니다.
SELECT CODE_POINTS_TO_BYTES([65, 98, 67, 100]) AS bytes;
-- Note that the result of CODE_POINTS_TO_BYTES is of type BYTES, displayed as a base64-encoded string.
-- In BYTES format, b'AbCd' is the result.
+----------+
| bytes |
+----------+
| QWJDZA== |
+----------+
다음 예시에서는 ROT13(rotate-by-13 places) 알고리즘을 사용하여 문자열을 인코딩합니다.
SELECT CODE_POINTS_TO_BYTES(ARRAY(
(SELECT
CASE
WHEN chr BETWEEN b'a' AND b'z'
THEN TO_CODE_POINTS(b'a')[offset(0)] +
MOD(code + 13 - TO_CODE_POINTS(b'a')[offset(0)],26)
WHEN chr BETWEEN b'A' AND b'Z'
THEN TO_CODE_POINTS(b'A')[offset(0)] +
MOD(code + 13 - TO_CODE_POINTS(b'A')[offset(0)],26)
ELSE code
END
FROM
(SELECT code, CODE_POINTS_TO_BYTES(ARRAY[code]) AS chr
FROM UNNEST(TO_CODE_POINTS(input)) AS code WITH OFFSET
ORDER BY OFFSET)
))) AS encoded_string
FROM UNNEST(ARRAY['Test String!']) AS input;
-- Note that the result of CODE_POINTS_TO_BYTES is of type BYTES, displayed as a base64-encoded string.
-- In BYTES format, b'Grfg Fgevat!' is the result.
+------------------+
| encoded_string |
+------------------+
| R3JmZyBGZ2V2YXQh |
+------------------+
CODE_POINTS_TO_STRING
CODE_POINTS_TO_STRING(value)
설명
유니코드 코드 포인트의 배열(INT64
의 ARRAY
)을 사용하여 STRING
을 반환합니다. 코드 포인트가 0이면 STRING
에 코드 문자를 반환하지 않습니다.
문자열을 코드 포인트의 배열로 변환하려면 TO_CODE_POINTS를 참조하세요.
반환 유형
STRING
예시
다음은 CODE_POINTS_TO_STRING
을 사용하는 기본 예시입니다.
SELECT CODE_POINTS_TO_STRING([65, 255, 513, 1024]) AS string;
+--------+
| string |
+--------+
| AÿȁЀ |
+--------+
SELECT CODE_POINTS_TO_STRING([97, 0, 0xF9B5]) AS string;
+--------+
| string |
+--------+
| a例 |
+--------+
SELECT CODE_POINTS_TO_STRING([65, 255, NULL, 1024]) AS string;
+--------+
| string |
+--------+
| NULL |
+--------+
다음 예시는 단어 집합에서 문자 빈도 수를 계산합니다.
WITH Words AS (
SELECT word
FROM UNNEST(['foo', 'bar', 'baz', 'giraffe', 'llama']) AS word
)
SELECT
CODE_POINTS_TO_STRING([code_point]) AS letter,
COUNT(*) AS letter_count
FROM Words,
UNNEST(TO_CODE_POINTS(word)) AS code_point
GROUP BY 1
ORDER BY 2 DESC;
+--------+--------------+
| letter | letter_count |
+--------+--------------+
| a | 5 |
| f | 3 |
| r | 2 |
| b | 2 |
| l | 2 |
| o | 2 |
| g | 1 |
| z | 1 |
| e | 1 |
| m | 1 |
| i | 1 |
+--------+--------------+
CONCAT
CONCAT(value1[, ...])
설명
하나 이상의 STRING
또는 BYTE
값을 하나의 결과로 연결합니다.
입력 인수가 NULL
이면 이 함수는 NULL
을 반환합니다.
반환 유형
STRING
또는 BYTES
예시
SELECT CONCAT("T.P.", " ", "Bar") as author;
+---------------------+
| author |
+---------------------+
| T.P. Bar |
+---------------------+
With Employees AS
(SELECT
"John" AS first_name,
"Doe" AS last_name
UNION ALL
SELECT
"Jane" AS first_name,
"Smith" AS last_name
UNION ALL
SELECT
"Joe" AS first_name,
"Jackson" AS last_name)
SELECT
CONCAT(first_name, " ", last_name)
AS full_name
FROM Employees;
+---------------------+
| full_name |
+---------------------+
| John Doe |
| Jane Smith |
| Joe Jackson |
+---------------------+
ENDS_WITH
ENDS_WITH(value1, value2)
설명
STRING
또는 BYTES
값 두 개를 사용합니다. 두 번째 값이 첫 번째 값의 서픽스이면 TRUE
를 반환합니다.
반환 유형
BOOL
예시
WITH items AS
(SELECT "apple" as item
UNION ALL
SELECT "banana" as item
UNION ALL
SELECT "orange" as item)
SELECT
ENDS_WITH(item, "e") as example
FROM items;
+---------+
| example |
+---------+
| True |
| False |
| True |
+---------+
FORMAT
Cloud Spanner SQL은 문자열 형식 지정을 위한 FORMAT()
함수를 지원합니다. 이 함수는 C printf
함수와 비슷합니다. 이 함수는 형식 지정자가 0개 이상 포함된 형식 문자열에서 형식 지정자와 일치하는 추가 인수의 가변 길이 목록과 함께 STRING
을 생성합니다.
예를 들면 다음과 같습니다.
설명 | 문 | 결과 |
---|---|---|
단순 정수 | FORMAT('%d', 10) | 10 |
왼쪽 공백 패딩이 있는 정수 | FORMAT('|%10d|', 11) | | 11| |
왼쪽 0 패딩이 있는 정수 | FORMAT('+%010d+', 12) | +0000000012+ |
쉼표가 있는 정수 | FORMAT('%'d', 123456789) | 123,456,789 |
STRING | FORMAT('-%s-', 'abcd efg') | -abcd efg- |
FLOAT64 | FORMAT('%f %E', 1.1, 2.2) | 1.100000 2.200000E+00 |
DATE | FORMAT('%t', date '2015-09-01') | 2015-09-01 |
TIMESTAMP | FORMAT('%t', timestamp '2015-09-01 12:34:56 America/Los_Angeles') | 2015‑09‑01 19:34:56+00 |
FORMAT()
함수는 모든 유형과 값의 완전한 커스텀 설정이 가능한 형식 지정을 제공하지 않을 뿐 아니라 언어를 구분하는 형식 지정도 제공하지 않습니다.
유형에 커스텀 형식 지정이 필요하면 먼저 FORMAT_DATE()
또는 FORMAT_TIMESTAMP()
같은 유형별 형식 함수를 사용하여 형식을 지정해야 합니다.
예를 들면 다음과 같습니다.
SELECT FORMAT("date: %s!", FORMAT_DATE("%B %d, %Y", date '2015-01-02'));
반환
date: January 02, 2015!
구문
FORMAT()
구문은 형식 문자열과 인수의 가변 길이 목록을 사용하여 STRING
결과를 생성합니다.
FORMAT(format_string, ...)
format_string
표현식에는 형식 지정자가 0개 이상 포함될 수 있습니다.
각 형식 지정자는 %
기호로 도입되며 하나 이상의 나머지 인수에 매핑되어야 합니다. 대부분의 경우, *
지정자가 있는 경우를 제외하고 일대일 매핑입니다. 예를 들어 %.*i
는 2개의 인수, 즉 길이 인수와 부호가 있는 정수 인수에 매핑됩니다. 형식 지정자와 관련된 인수의 수가 인수의 수와 다르면 오류가 발생합니다.
지원되는 형식 지정자
FORMAT()
함수 형식 지정자는 다음 프로토타입 다음에 옵니다.
%[flags][width][.precision]specifier
지원되는 형식 지정자는 아래 표에 나와 있습니다. printf()의 편차는 기울임꼴로 되어 있습니다.
지정자 | 설명 | 예시 | 유형 |
d 또는 i |
10진수 | 392 | INT64 |
o |
8진수 | 610 | INT64* |
x |
16진수 | 7fa | INT64* |
X |
16진수(대문자) | 7FA | INT64* |
f |
10진수 표기법, 유한한 값의 경우 [-](정수 부분).(소수 부분), 유한하지 않은 값의 경우 소문자 | 392.650000 inf nan |
NUMERIC FLOAT64 |
F |
10진수 표기법, 유한한 값의 경우 [-](정수 부분).(소수 부분), 유한하지 않은 값의 경우 대문자 | 392.650000 INF NAN |
NUMERIC FLOAT64 |
e |
과학적 표기법(가수/지수), 소문자 | 3.926500e+02 inf nan |
NUMERIC FLOAT64 |
E |
과학적 표기법(가수/지수), 대문자 | 3.926500E+02 INF NAN |
NUMERIC FLOAT64 |
g |
입력 값의 지수와 지정된 정밀도에 따라 소수점 표기법 또는 과학적 표기법을 선택합니다. 소문자입니다. 자세한 내용은 %g 및 %G 동작을 참조하세요. | 392.65 3.9265e+07 inf nan |
NUMERIC FLOAT64 |
G |
입력 값 지수와 지정된 정밀도에 따라 소수점 표기법이나 과학적 표기법을 선택합니다. 대문자입니다. 자세한 내용은 %g 및 %G 동작을 참조하세요. |
392.65 3.9265E+07 INF NAN |
NUMERIC FLOAT64 |
s |
문자의 문자열 | sample | STRING |
t |
값을 나타내는 출력 가능한 문자열을 반환합니다. 인수를 STRING 으로 Cast 변환과 유사하게 보이는 경우가 많습니다.
%t 및 %T 동작을 참조하세요.
|
샘플 2014‑01‑01 |
<any> |
T |
값의 유형과 비슷한 유형의 유효한 Cloud Spanner SQL 상수인 문자열을 생성합니다(더 넓거나 문자열일 수 있음). %t 및 %T 동작을 참조하세요. |
'sample' b'bytes sample' 1234 2.3 date '2014‑01‑01' |
<any> |
% |
'%%'는 단일 '%'를 생성합니다. | % | 해당 사항 없음 |
*음수 값이 사용되면 %o
, %x
, %X
지정자에서 오류가 발생합니다.
형식 지정자는 위 지정자 프로토타입에서 식별된 하위 지정자를 선택적으로 포함할 수 있습니다.
이러한 하위 지정자는 다음 사양을 준수해야 합니다.
플래그
플래그 | 설명 |
- |
지정된 필드 너비 내에서 왼쪽 정렬. 오른쪽 정렬이 기본값입니다(너비 하위 지정자 참조). |
+ |
양수이더라도 결과 앞에 플러스 또는 마이너스 부호(+ 또는 - )를 강제로 배치합니다. 기본적으로 음수 앞에만 - 부호가 있습니다. |
<space> | 부호를 쓰지 않으려면 값 앞에 빈 공백을 삽입합니다. |
# |
|
0 |
패딩이 지정되면 공백 대신 0으로 숫자를 왼쪽으로 패딩합니다(너비 하위 지정자 참조). |
' |
적절한 그룹화 문자를 사용하여 정수 형식을 지정합니다. 예를 들면 다음과 같습니다.
이 플래그는 10진수, 16진수, 8진수 값에만 관련됩니다. |
플래그는 순서에 상관없이 지정할 수 있습니다. 중복 플래그는 오류가 아닙니다. 일부 요소 유형과 관련이 없는 플래그는 무시됩니다.
너비
너비 | 설명 |
<number> | 출력할 최소 문자 수입니다. 출력할 값이 이 숫자보다 짧으면 결과가 빈 공백으로 패딩됩니다. 결과가 더 크더라도 값은 잘리지 않습니다. |
* |
너비가 형식 문자열에서 지정되지 않고 형식을 지정해야 하는 인수 앞에 오는 추가 정수 값 인수로 지정됩니다. |
정밀도
정밀도 | 설명 |
. <number> |
|
.* |
정밀도는 형식 문자열에서 지정되지 않고 형식을 지정해야 하는 인수 앞에 오는 추가 정수 값 인수로 지정됩니다. |
%g 및 %G 동작
%g
및 %G
형식 지정자는 입력 값의 지수와 지정된 정밀도에 따라 10진수 표기법(예: %f
및 %F
지정자) 또는 과학적 표기법(예: %e
및 %E
지정자)을 선택합니다.
p는 지정된 정밀도를 의미합니다(기본값은 6, 지정된 정밀도가 1보다 작으면 1). 입력 값은 먼저 정밀도가 (p - 1)인 과학적 표기법으로 변환됩니다. 결과 지수 부분 x가 -4보다 작거나 p보다 작지 않으면 정밀도가 (p - 1)인 과학적 표기법이 사용됩니다. 그렇지 않은 경우 정밀도가 (p - 1 - x)인 10진수 표기법이 사용됩니다.
#
플래그가 없으면 소수점 이하 후행 0은 삭제되고 그 뒤에 남은 자릿수가 없는 경우 소수점도 삭제됩니다.
%t 및 %T 동작
%t
및 %T
형식 지정자는 모든 유형에 정의됩니다. 너비, 정밀도, 플래그는 %s
에 동작하는 것처럼 동작합니다. 너비는 최소 너비이고 STRING
은 이 크기로 패딩됩니다. 정밀도는 표시할 콘텐츠의 최대 너비이고 STRING
은 너비로 패딩되기 전에 이 크기로 잘립니다.
%t
지정자는 항상 읽을 수 있는 값 형식이어야 합니다.
%T
지정자는 항상 더 넓은 숫자 유형과 같은 비슷한 유형의 유효한 SQL 리터럴입니다.
유한하지 않은 부동 소수점 값의 특수한 경우를 제외하고 리터럴에는 변환 또는 유형 이름이 포함되지 않습니다.
STRING
형식은 다음과 같습니다.
유형 | %t | %T |
모든 유형의 NULL |
NULL |
NULL |
INT64 |
123 | 123 |
NUMERIC | 123.0(항상 .0 포함) | NUMERIC "123.0" |
FLOAT64 |
123.0 (항상 .0 포함) 123e+10 inf -inf NaN
|
123.0 (항상 .0 포함) 123e+10 CAST("inf" AS <type>) CAST("-inf" AS <type>) CAST("nan" AS <type>) |
STRING | 따옴표 없는 문자열 값 | 따옴표 붙은 문자열 리터럴 |
BYTES |
따옴표가 없는 이스케이프 처리된 바이트 예: abc\x01\x02 |
따옴표가 있는 바이트 리터럴 예: b"abc\x01\x02" |
DATE | 2011-02-03 | DATE "2011-02-03" |
TIMESTAMP | 2011-02-03 04:05:06+00 | TIMESTAMP "2011-02-03 04:05:06+00" |
ARRAY | [value, value, ...] 여기서 값은 %t로 형식 지정됩니다. |
[value, value, ...] 여기서 값은 %T로 형식 지정됩니다. |
오류 조건
형식 지정자가 유효하지 않거나 관련 인수 유형과 호환되지 않거나 잘못된 숫자 또는 인수가 제공되는 경우 오류가 생성됩니다. 예를 들어 다음 <format_string>
표현식은 유효하지 않습니다.
FORMAT('%s', 1)
FORMAT('%')
NULL 인수 처리
NULL
형식 문자열에서 NULL
출력 STRING
이 생성됩니다. 이 경우 다른 모든 인수는 무시됩니다.
함수는 NULL
인수가 있으면 일반적으로 NULL
값을 생성합니다.
예를 들어 FORMAT('%i', NULL_expression)
은 NULL STRING
을 출력으로 생성합니다.
하지만 몇 가지 예외가 있습니다. 형식 지정자가 %t 또는 %T(둘 다 CAST와 리터럴 값 시맨틱스를 효과적으로 일치시키는 STRING
생성)이면 NULL
값은 결과 STRING
에서 'NULL'(따옴표 없음)을 생성합니다. 다음 함수를 예로 들겠습니다.
FORMAT('00-%t-00', NULL_expression);
반환
00-NULL-00
추가 시맨틱 규칙
FLOAT64
값은 +/-inf
이거나 NaN
일 수 있습니다.
인수에 이 값 중 하나가 있으면 형식 지정자 %f
, %F
, %e
, %E
, %g
, %G
, %t
의 결과는 적절한 inf
, -inf
또는 nan
(또는 대문자로 된 동일한 결과)입니다. 이는 Cloud Spanner SQL이 이러한 값을 STRING
으로 변환하는 방법에 부합합니다. %T
의 경우 Cloud Spanner SQL은 문자열이 아닌 리터럴 표현이 없는 FLOAT64
값에 대해 따옴표 붙은 문자열을 반환합니다.
FROM_BASE32
FROM_BASE32(string_expr)
설명
base32로 인코딩된 입력 string_expr
을 BYTES
형식으로 변환합니다. BYTES
를 base32로 인코딩된 STRING
으로 변환하려면 TO_BASE32를 사용합니다.
반환 유형
BYTES
예시
SELECT FROM_BASE32('MFRGGZDF74======') AS byte_data;
-- Note that the result of FROM_BASE32 is of type BYTES, displayed as a base64-encoded string.
+-----------+
| byte_data |
+-----------+
| YWJjZGX/ |
+-----------+
FROM_BASE64
FROM_BASE64(string_expr)
설명
base64로 인코딩된 입력 string_expr
을 BYTES
형식으로 변환합니다. BYTES
를 base64로 인코딩된 STRING
으로 변환하려면 TO_BASE64를 사용합니다.
64자리와 패딩을 인코딩하는 데 사용되는 ASCII 알파벳 65자와 완전히 다른 일반적으로 사용되는 base64 인코딩이 여러 개 있습니다.
자세한 내용은 RFC 4648을 참조하세요. 이 함수는 알파벳 [A-Za-z0-9+/=]
을 예상합니다.
반환 유형
BYTES
예시
SELECT FROM_BASE64('/+A=') AS byte_data;
-- Note that the result of FROM_BASE64 is of type BYTES, displayed as a base64-encoded string.
+-----------+
| byte_data |
+-----------+
| /+A= |
+-----------+
다른 base64 알파벳을 사용하여 인코딩하려면 REPLACE
함수를 사용하여 FROM_BASE64
를 구성해야 할 수 있습니다. 예를 들어 웹 프로그래밍에서 일반적으로 사용되는 base64url
url-safe 및 filename-safe 인코딩은 마지막 문자로 +/=
이 아닌 -_=
를 사용합니다. base64url
로 인코딩된 문자열을 디코딩하려면 +
와 /
를 각각 -
와 _
로 바꿉니다.
SELECT FROM_BASE64(REPLACE(REPLACE("_-A=", "-", "+"), "_", "/")) AS binary;
-- Note that the result of FROM_BASE64 is of type BYTES, displayed as a base64-encoded string.
+--------+
| binary |
+--------+
| /+A= |
+--------+
FROM_HEX
FROM_HEX(string)
설명
16진수로 인코딩된 STRING
을 BYTES
형식으로 변환합니다. 입력 STRING
에 (0..9, A..F, a..f)
범위를 벗어난 문자가 있으면 오류를 반환합니다. 문자는 대소문자를 구분하지 않습니다. 입력 STRING
의 문자 수가 홀수이면 함수는 입력 앞부분에 0
이 추가된 것처럼 작동합니다. BYTES
를 16진수로 인코딩된 STRING
으로 변환하려면 TO_HEX를 사용합니다.
반환 유형
BYTES
예시
WITH Input AS (
SELECT '00010203aaeeefff' AS hex_str UNION ALL
SELECT '0AF' UNION ALL
SELECT '666f6f626172'
)
SELECT hex_str, FROM_HEX(hex_str) AS bytes_str
FROM Input;
-- Note that the result of FROM_HEX is of type BYTES, displayed as a base64-encoded string.
+------------------+--------------+
| hex_str | bytes_str |
+------------------+--------------+
| 0AF | AAECA6ru7/8= |
| 00010203aaeeefff | AK8= |
| 666f6f626172 | Zm9vYmFy |
+------------------+--------------+
LENGTH
LENGTH(value)
설명
STRING
또는 BYTES
값의 길이를 반환합니다. 반환되는 값은 STRING
인수의 경우 문자이고, BYTES
인수의 경우에는 바이트입니다.
반환 유형
INT64
예시
WITH example AS
(SELECT "абвгд" AS characters)
SELECT
characters,
LENGTH(characters) AS string_example,
LENGTH(CAST(characters AS BYTES)) AS bytes_example
FROM example;
+------------+----------------+---------------+
| characters | string_example | bytes_example |
+------------+----------------+---------------+
| абвгд | 5 | 10 |
+------------+----------------+---------------+
LPAD
LPAD(original_value, return_length[, pattern])
설명
original_value
로 구성되고 앞에 pattern
이 추가된 STRING
또는 BYTES
값을 반환합니다. return_length
는 반환된 값의 길이를 지정하는 INT64
입니다. original_value
가 BYTES
유형이면 return_length
는 바이트 수입니다. original_value
가 STRING
유형이면 return_length
는 문자 수입니다.
pattern
의 기본값은 빈 공백입니다.
original_value
와 pattern
은 같은 데이터 유형이어야 합니다.
return_length
가 original_value
길이 이하이면 이 함수는 return_length
값으로 잘린 original_value
값을 반환합니다. 예를 들어 LPAD("hello world", 7);
는 "hello w"
를 반환합니다.
original_value
, return_length
또는 pattern
이 NULL
이면 이 함수는 NULL
을 반환합니다.
이 함수는 다음과 같은 경우에 오류를 반환합니다.
return_length
가 음수인 경우pattern
이 비어 있는 경우
반환 유형
STRING
또는 BYTES
예시
SELECT t, len, FORMAT("%T", LPAD(t, len)) AS LPAD FROM UNNEST([
STRUCT('abc' AS t, 5 AS len),
('abc', 2),
('例子', 4)
]);
+------+-----+----------+
| t | len | LPAD |
|------|-----|----------|
| abc | 5 | " abc" |
| abc | 2 | "ab" |
| 例子 | 4 | " 例子" |
+------+-----+----------+
SELECT t, len, pattern, FORMAT("%T", LPAD(t, len, pattern)) AS LPAD FROM UNNEST([
STRUCT('abc' AS t, 8 AS len, 'def' AS pattern),
('abc', 5, '-'),
('例子', 5, '中文')
]);
+------+-----+---------+--------------+
| t | len | pattern | LPAD |
|------|-----|---------|--------------|
| abc | 8 | def | "defdeabc" |
| abc | 5 | - | "--abc" |
| 例子 | 5 | 中文 | "中文中例子" |
+------+-----+---------+--------------+
SELECT FORMAT("%T", t) AS t, len, FORMAT("%T", LPAD(t, len)) AS LPAD FROM UNNEST([
STRUCT(b'abc' AS t, 5 AS len),
(b'abc', 2),
(b'\xab\xcd\xef', 4)
]);
+-----------------+-----+------------------+
| t | len | LPAD |
|-----------------|-----|------------------|
| b"abc" | 5 | b" abc" |
| b"abc" | 2 | b"ab" |
| b"\xab\xcd\xef" | 4 | b" \xab\xcd\xef" |
+-----------------+-----+------------------+
SELECT
FORMAT("%T", t) AS t,
len,
FORMAT("%T", pattern) AS pattern,
FORMAT("%T", LPAD(t, len, pattern)) AS LPAD
FROM UNNEST([
STRUCT(b'abc' AS t, 8 AS len, b'def' AS pattern),
(b'abc', 5, b'-'),
(b'\xab\xcd\xef', 5, b'\x00')
]);
+-----------------+-----+---------+-------------------------+
| t | len | pattern | LPAD |
|-----------------|-----|---------|-------------------------|
| b"abc" | 8 | b"def" | b"defdeabc" |
| b"abc" | 5 | b"-" | b"--abc" |
| b"\xab\xcd\xef" | 5 | b"\x00" | b"\x00\x00\xab\xcd\xef" |
+-----------------+-----+---------+-------------------------+
LOWER
LOWER(value)
설명
STRING
인수의 경우 모든 알파벳 문자가 소문자인 원본 문자열을 반환합니다. 소문자와 대문자 간의 매핑은 계정 언어별 매핑을 고려하지 않고 유니코드 문자 데이터베이스에 따라 수행됩니다.
BYTES
인수에서 인수는 ASCII 텍스트로 취급되며 127보다 큰 모든 바이트는 그대로 유지됩니다.
반환 유형
STRING
또는 BYTES
예시
WITH items AS
(SELECT
"FOO" as item
UNION ALL
SELECT
"BAR" as item
UNION ALL
SELECT
"BAZ" as item)
SELECT
LOWER(item) AS example
FROM items;
+---------+
| example |
+---------+
| foo |
| bar |
| baz |
+---------+
LTRIM
LTRIM(value1[, value2])
설명
TRIM과 동일하지만 선행 문자만 제거합니다.
반환 유형
STRING
또는 BYTES
예시
WITH items AS
(SELECT " apple " as item
UNION ALL
SELECT " banana " as item
UNION ALL
SELECT " orange " as item)
SELECT
CONCAT("#", LTRIM(item), "#") as example
FROM items;
+-------------+
| example |
+-------------+
| #apple # |
| #banana # |
| #orange # |
+-------------+
WITH items AS
(SELECT "***apple***" as item
UNION ALL
SELECT "***banana***" as item
UNION ALL
SELECT "***orange***" as item)
SELECT
LTRIM(item, "*") as example
FROM items;
+-----------+
| example |
+-----------+
| apple*** |
| banana*** |
| orange*** |
+-----------+
WITH items AS
(SELECT "xxxapplexxx" as item
UNION ALL
SELECT "yyybananayyy" as item
UNION ALL
SELECT "zzzorangezzz" as item
UNION ALL
SELECT "xyzpearxyz" as item)
SELECT
LTRIM(item, "xyz") as example
FROM items;
+-----------+
| example |
+-----------+
| applexxx |
| bananayyy |
| orangezzz |
| pearxyz |
+-----------+
REGEXP_CONTAINS
REGEXP_CONTAINS(value, regexp)
설명
value
가 정규 표현식 regexp
와 부분적으로 일치하면 TRUE
를 반환합니다.
regexp
인수가 잘못되면 이 함수는 오류를 반환합니다.
^
(텍스트 시작) 및 $
(텍스트 종료)를 사용하여 완전 일치를 검색할 수 있습니다. 정규 표현식 연산자의 우선순위로 인해 ^
과 $
사이의 모든 문자를 괄호로 묶는 것이 좋습니다.
반환 유형
BOOL
예시
SELECT
email,
REGEXP_CONTAINS(email, r"@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+") AS is_valid
FROM
(SELECT
["foo@example.com", "bar@example.org", "www.example.net"]
AS addresses),
UNNEST(addresses) AS email;
+-----------------+----------+
| email | is_valid |
+-----------------+----------+
| foo@example.com | true |
| bar@example.org | true |
| www.example.net | false |
+-----------------+----------+
# Performs a full match, using ^ and $. Due to regular expression operator
# precedence, it is good practice to use parentheses around everything between ^
# and $.
SELECT
email,
REGEXP_CONTAINS(email, r"^([\w.+-]+@foo\.com|[\w.+-]+@bar\.org)$")
AS valid_email_address,
REGEXP_CONTAINS(email, r"^[\w.+-]+@foo\.com|[\w.+-]+@bar\.org$")
AS without_parentheses
FROM
(SELECT
["a@foo.com", "a@foo.computer", "b@bar.org", "!b@bar.org", "c@buz.net"]
AS addresses),
UNNEST(addresses) AS email;
+----------------+---------------------+---------------------+
| email | valid_email_address | without_parentheses |
+----------------+---------------------+---------------------+
| a@foo.com | true | true |
| a@foo.computer | false | true |
| b@bar.org | true | true |
| !b@bar.org | false | true |
| c@buz.net | false | false |
+----------------+---------------------+---------------------+
REGEXP_EXTRACT
REGEXP_EXTRACT(value, regexp)
설명
value
에서 정규 표현식 regexp
와 일치하는 첫 번째 하위 문자열을 반환합니다. 일치하는 항목이 없으면 NULL
을 반환합니다.
정규 표현식에 캡처 그룹이 포함되어 있는 경우, 이 함수는 그 캡처 그룹으로 일치되는 하위 문자열을 반환합니다. 정규 표현식에 캡처 그룹이 포함되어 있지 않은 경우, 이 함수는 일치하는 전체 하위 문자열을 반환합니다.
다음의 경우 오류를 반환합니다.
- 정규 표현식이 유효하지 않은 경우
- 정규 표현식에 캡처 그룹이 둘 이상 있는 경우
반환 유형
STRING
또는 BYTES
예시
WITH email_addresses AS
(SELECT "foo@example.com" as email
UNION ALL
SELECT "bar@example.org" as email
UNION ALL
SELECT "baz@example.net" as email)
SELECT
REGEXP_EXTRACT(email, r"^[a-zA-Z0-9_.+-]+")
AS user_name
FROM email_addresses;
+-----------+
| user_name |
+-----------+
| foo |
| bar |
| baz |
+-----------+
WITH email_addresses AS
(SELECT "foo@example.com" as email
UNION ALL
SELECT "bar@example.org" as email
UNION ALL
SELECT "baz@example.net" as email)
SELECT
REGEXP_EXTRACT(email, r"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.([a-zA-Z0-9-.]+$)")
AS top_level_domain
FROM email_addresses;
+------------------+
| top_level_domain |
+------------------+
| com |
| org |
| net |
+------------------+
REGEXP_EXTRACT_ALL
REGEXP_EXTRACT_ALL(value, regexp)
설명
정규 표현식 regexp
와 일치하는 value
의 모든 하위 문자열 배열을 반환합니다.
REGEXP_EXTRACT_ALL
함수는 중첩되지 않는 일치 항목만 반환합니다. 예를 들어 이 함수를 사용하여 banana
에서 ana
를 추출하면 하위 문자열이 2개가 아닌 1개만 반환됩니다.
반환 유형
STRING
또는 BYTES
의 ARRAY
입니다.
예시
WITH code_markdown AS
(SELECT "Try `function(x)` or `function(y)`" as code)
SELECT
REGEXP_EXTRACT_ALL(code, "`(.+?)`") AS example
FROM code_markdown;
+----------------------------+
| example |
+----------------------------+
| [function(x), function(y)] |
+----------------------------+
REGEXP_REPLACE
REGEXP_REPLACE(value, regexp, replacement)
설명
정규 표현식 regexp
와 일치하는 모든 value
하위 문자열이 replacement
로 바뀐 STRING
을 반환합니다.
replacement
인수 내에 백슬래시로 이스케이프 처리된 숫자(\1~\9)를 사용하여 regexp
패턴에서 괄호로 묶인 해당 그룹과 일치하는 텍스트를 삽입할 수 있습니다. 전체 일치 텍스트를 나타내려면 \0을 사용합니다.
REGEXP_REPLACE
함수는 중첩되지 않는 일치 항목만 바꿉니다. 예를 들어 banana
내의 ana
를 바꿀 때는 2개가 아니라 1개만 바뀝니다.
regexp
인수가 유효한 정규 표현식이 아니면 이 함수는 오류를 반환합니다.
반환 유형
STRING
또는 BYTES
예시
WITH markdown AS
(SELECT "# Heading" as heading
UNION ALL
SELECT "# Another heading" as heading)
SELECT
REGEXP_REPLACE(heading, r"^# ([a-zA-Z0-9\s]+$)", "<h1>\\1</h1>")
AS html
FROM markdown;
+--------------------------+
| html |
+--------------------------+
| <h1>Heading</h1> |
| <h1>Another heading</h1> |
+--------------------------+
REPLACE
REPLACE(original_value, from_value, to_value)
설명
original_value
에서 일치하는 모든 from_value
항목을 to_value
로 바꿉니다.
from_value
가 비어 있으면 값이 바뀌지 않습니다.
반환 유형
STRING
또는 BYTES
예시
WITH desserts AS
(SELECT "apple pie" as dessert
UNION ALL
SELECT "blackberry pie" as dessert
UNION ALL
SELECT "cherry pie" as dessert)
SELECT
REPLACE (dessert, "pie", "cobbler") as example
FROM desserts;
+--------------------+
| example |
+--------------------+
| apple cobbler |
| blackberry cobbler |
| cherry cobbler |
+--------------------+
반복
REPEAT(original_value, repetitions)
설명
반복되는 original_value
로 구성된 STRING
또는 BYTES
값을 반환합니다.
repetitions
매개변수는 original_value
반복 횟수를 지정합니다. original_value
또는 repetitions
가 NULL
이면 NULL
을 반환합니다.
repetitions
값이 음수이면 이 함수는 오류를 반환합니다.
반환 유형
STRING
또는 BYTES
예시
SELECT t, n, REPEAT(t, n) AS REPEAT FROM UNNEST([
STRUCT('abc' AS t, 3 AS n),
('例子', 2),
('abc', null),
(null, 3)
]);
+------+------+-----------+
| t | n | REPEAT |
|------|------|-----------|
| abc | 3 | abcabcabc |
| 例子 | 2 | 例子例子 |
| abc | NULL | NULL |
| NULL | 3 | NULL |
+------+------+-----------+
REVERSE
REVERSE(value)
설명
입력 STRING
또는 BYTES
를 역으로 반환합니다.
반환 유형
STRING
또는 BYTES
예시
WITH example AS (
SELECT "foo" AS sample_string, b"bar" AS sample_bytes UNION ALL
SELECT "абвгд" AS sample_string, b"123" AS sample_bytes
)
SELECT
sample_string,
REVERSE(sample_string) AS reverse_string,
sample_bytes,
REVERSE(sample_bytes) AS reverse_bytes
FROM example;
+---------------+----------------+--------------+---------------+
| sample_string | reverse_string | sample_bytes | reverse_bytes |
+---------------+----------------+--------------+---------------+
| foo | oof | bar | rab |
| абвгд | дгвба | 123 | 321 |
+---------------+----------------+--------------+---------------+
RPAD
RPAD(original_value, return_length[, pattern])
설명
original_value
로 구성되고 pattern
이 추가된 STRING
또는 BYTES
값을 반환합니다. return_length
매개변수는 반환되는 값의 길이를 지정하는 INT64
입니다. original_value
가 BYTES
이면 return_length
는 바이트 수입니다. original_value
가 STRING
이면 return_length
는 문자 수입니다.
pattern
의 기본값은 빈 공백입니다.
original_value
와 pattern
은 같은 데이터 유형이어야 합니다.
return_length
가 original_value
길이 이하이면 이 함수는 return_length
값으로 잘린 original_value
값을 반환합니다. 예를 들어 RPAD("hello world", 7);
는 "hello w"
를 반환합니다.
original_value
, return_length
또는 pattern
이 NULL
이면 이 함수는 NULL
을 반환합니다.
이 함수는 다음과 같은 경우에 오류를 반환합니다.
return_length
가 음수인 경우pattern
이 비어 있는 경우
반환 유형
STRING
또는 BYTES
예시
SELECT t, len, FORMAT("%T", RPAD(t, len)) AS RPAD FROM UNNEST([
STRUCT('abc' AS t, 5 AS len),
('abc', 2),
('例子', 4)
]);
+------+-----+----------+
| t | len | RPAD |
|------|-----|----------|
| abc | 5 | "abc " |
| abc | 2 | "ab" |
| 例子 | 4 | "例子 " |
+------+-----+----------+
SELECT t, len, pattern, FORMAT("%T", RPAD(t, len, pattern)) AS RPAD FROM UNNEST([
STRUCT('abc' AS t, 8 AS len, 'def' AS pattern),
('abc', 5, '-'),
('例子', 5, '中文')
]);
+------+-----+---------+--------------+
| t | len | pattern | RPAD |
|------|-----|---------|--------------|
| abc | 8 | def | "abcdefde" |
| abc | 5 | - | "abc--" |
| 例子 | 5 | 中文 | "例子中文中" |
+------+-----+---------+--------------+
SELECT FORMAT("%T", t) AS t, len, FORMAT("%T", RPAD(t, len)) AS RPAD FROM UNNEST([
STRUCT(b'abc' AS t, 5 AS len),
(b'abc', 2),
(b'\xab\xcd\xef', 4)
]);
+-----------------+-----+------------------+
| t | len | RPAD |
|-----------------|-----|------------------|
| b"abc" | 5 | b"abc " |
| b"abc" | 2 | b"ab" |
| b"\xab\xcd\xef" | 4 | b"\xab\xcd\xef " |
+-----------------+-----+------------------+
SELECT
FORMAT("%T", t) AS t,
len,
FORMAT("%T", pattern) AS pattern,
FORMAT("%T", RPAD(t, len, pattern)) AS RPAD
FROM UNNEST([
STRUCT(b'abc' AS t, 8 AS len, b'def' AS pattern),
(b'abc', 5, b'-'),
(b'\xab\xcd\xef', 5, b'\x00')
]);
+-----------------+-----+---------+-------------------------+
| t | len | pattern | RPAD |
|-----------------|-----|---------|-------------------------|
| b"abc" | 8 | b"def" | b"abcdefde" |
| b"abc" | 5 | b"-" | b"abc--" |
| b"\xab\xcd\xef" | 5 | b"\x00" | b"\xab\xcd\xef\x00\x00" |
+-----------------+-----+---------+-------------------------+
RTRIM
RTRIM(value1[, value2])
설명
TRIM과 동일하지만 후행 문자만 제거합니다.
반환 유형
STRING
또는 BYTES
예시
WITH items AS
(SELECT "***apple***" as item
UNION ALL
SELECT "***banana***" as item
UNION ALL
SELECT "***orange***" as item)
SELECT
RTRIM(item, "*") as example
FROM items;
+-----------+
| example |
+-----------+
| ***apple |
| ***banana |
| ***orange |
+-----------+
WITH items AS
(SELECT "applexxx" as item
UNION ALL
SELECT "bananayyy" as item
UNION ALL
SELECT "orangezzz" as item
UNION ALL
SELECT "pearxyz" as item)
SELECT
RTRIM(item, "xyz") as example
FROM items;
+---------+
| example |
+---------+
| apple |
| banana |
| orange |
| pear |
+---------+
SAFE_CONVERT_BYTES_TO_STRING
SAFE_CONVERT_BYTES_TO_STRING(value)
설명
BYTES
의 시퀀스를 STRING
으로 변환합니다. 잘못된 UTF-8 문자는 유니코드 대체 문자인 U+FFFD
로 대체됩니다.
반환 유형
STRING
예시
다음 문은 유니코드 대체 문자 �를 반환합니다.
SELECT SAFE_CONVERT_BYTES_TO_STRING(b'\xc2') as safe_convert;
분할
SPLIT(value[, delimiter])
설명
delimiter
인수를 사용하여 value
를 분할합니다.
STRING
에서 기본 구분 기호는 쉼표(,
)입니다.
BYTES
에서는 구분 기호를 지정해야 합니다.
비어 있는 구분 기호로 분할하면 STRING
값의 경우에는 UTF-8 문자 배열이, BYTES
값의 경우에는 BYTES
의 배열이 생성됩니다.
비어 있는 STRING
을 분할하면 비어 있는 STRING
이 하나 있는 ARRAY
가 반환됩니다.
반환 유형
STRING
유형의 ARRAY
또는 BYTES
유형의 ARRAY
예시
WITH letters AS
(SELECT "" as letter_group
UNION ALL
SELECT "a" as letter_group
UNION ALL
SELECT "b c d" as letter_group)
SELECT SPLIT(letter_group, " ") as example
FROM letters;
+----------------------+
| example |
+----------------------+
| [] |
| [a] |
| [b, c, d] |
+----------------------+
STARTS_WITH
STARTS_WITH(value1, value2)
설명
STRING
또는 BYTES
값 두 개를 사용합니다. 두 번째 값이 첫 번째 값의 프리픽스이면 TRUE
를 반환합니다.
반환 유형
BOOL
예시
WITH items AS
(SELECT "foo" as item
UNION ALL
SELECT "bar" as item
UNION ALL
SELECT "baz" as item)
SELECT
STARTS_WITH(item, "b") as example
FROM items;
+---------+
| example |
+---------+
| False |
| True |
| True |
+---------+
STRPOS
STRPOS(string, substring)
설명
string
내부에서 첫 번째 일치하는 substring
항목의 1로 시작하는 색인을 반환합니다. substring
을 찾을 수 없으면 0
을 반환합니다.
반환 유형
INT64
예시
WITH email_addresses AS
(SELECT
"foo@example.com" AS email_address
UNION ALL
SELECT
"foobar@example.com" AS email_address
UNION ALL
SELECT
"foobarbaz@example.com" AS email_address
UNION ALL
SELECT
"quxexample.com" AS email_address)
SELECT
STRPOS(email_address, "@") AS example
FROM email_addresses;
+---------+
| example |
+---------+
| 4 |
| 7 |
| 10 |
| 0 |
+---------+
SUBSTR
SUBSTR(value, position[, length])
설명
제공된 STRING
또는 BYTES
값의 하위 문자열을 반환합니다. position
인수는 하위 문자열의 시작 위치를 지정하는 정수이며 position = 1은 첫 번째 문자나 바이트를 나타냅니다. length
인수는 STRING
인수의 경우에는 최대 문자 수, BYTES
인수의 경우에는 최대 바이트 수입니다.
position
이 음수이면 함수는 value
의 끝에서부터 계산하며 -1은 마지막 문자를 나타냅니다.
position
이 STRING
의 왼쪽 끝이면(position
= 0 또는 position
< -LENGTH(value)
) 함수는 position = 1부터 시작합니다. length
가 value
의 길이를 초과하면 함수는 length
문자보다 작은 값을 반환합니다.
length
가 0보다 작으면 함수는 오류를 반환합니다.
반환 유형
STRING
또는 BYTES
예시
WITH items AS
(SELECT "apple" as item
UNION ALL
SELECT "banana" as item
UNION ALL
SELECT "orange" as item)
SELECT
SUBSTR(item, 2) as example
FROM items;
+---------+
| example |
+---------+
| pple |
| anana |
| range |
+---------+
WITH items AS
(SELECT "apple" as item
UNION ALL
SELECT "banana" as item
UNION ALL
SELECT "orange" as item)
SELECT
SUBSTR(item, 2, 2) as example
FROM items;
+---------+
| example |
+---------+
| pp |
| an |
| ra |
+---------+
WITH items AS
(SELECT "apple" as item
UNION ALL
SELECT "banana" as item
UNION ALL
SELECT "orange" as item)
SELECT
SUBSTR(item, -2) as example
FROM items;
+---------+
| example |
+---------+
| le |
| na |
| ge |
+---------+
TO_BASE32
TO_BASE32(bytes_expr)
설명
BYTES
의 시퀀스를 base32로 인코딩된 STRING
으로 변환합니다. base32로 인코딩된 STRING
을 BYTES
로 변환하려면 FROM_BASE32를 사용합니다.
반환 유형
STRING
예시
SELECT TO_BASE32(b'abcde\xFF') AS base32_string;
+------------------+
| base32_string |
+------------------+
| MFRGGZDF74====== |
+------------------+
TO_BASE64
TO_BASE64(bytes_expr)
설명
BYTES
의 시퀀스를 base64로 인코딩된 STRING
으로 변환합니다. base64로 인코딩된 STRING
을 BYTES
로 변환하려면 FROM_BASE64를 사용합니다.
64자리와 패딩을 인코딩하는 데 사용되는 ASCII 알파벳 65자와 완전히 다른 일반적으로 사용되는 base64 인코딩이 여러 개 있습니다.
자세한 내용은 RFC 4648을 참조하세요. 이 함수는 패딩을 추가하고 알파벳 [A-Za-z0-9+/=]
을 사용합니다.
반환 유형
STRING
예시
SELECT TO_BASE64(b'\377\340') AS base64_string;
+---------------+
| base64_string |
+---------------+
| /+A= |
+---------------+
다른 base64 알파벳을 사용하여 인코딩하려면 REPLACE
함수를 사용하여 TO_BASE64
를 구성해야 할 수 있습니다. 예를 들어 웹 프로그래밍에서 일반적으로 사용되는 base64url
url-safe 및 filename-safe 인코딩은 마지막 문자로 +/=
이 아닌 -_=
를 사용합니다. base64url
로 인코딩된 문자열을 인코딩하려면 -
와 _
를 각각 +
와 /
로 바꿉니다.
SELECT REPLACE(REPLACE(TO_BASE64(b"\377\340"), "+", "-"), "/", "_") as websafe_base64;
+----------------+
| websafe_base64 |
+----------------+
| _-A= |
+----------------+
TO_CODE_POINTS
TO_CODE_POINTS(value)
설명
값을 사용하여 INT64
배열을 반환합니다.
value
가STRING
이면 반환되는 배열의 각 요소는 코드 포인트를 나타냅니다. 각 코드 포인트는 [0, 0xD7FF] 및 [0xE000, 0x10FFFF] 범위에 속합니다.value
가BYTES
이면 배열의 각 요소는 [0, 255] 범위의 확장된 ASCII 문자 값입니다.
코드 포인트 배열을 STRING
또는 BYTES
로 변환하려면 CODE_POINTS_TO_STRING 또는 CODE_POINTS_TO_BYTES를 참조하세요.
반환 유형
ARRAY
/INT64
예시
다음 예시에서는 단어 배열에 있는 각 요소의 코드 포인트를 가져옵니다.
SELECT word, TO_CODE_POINTS(word) AS code_points
FROM UNNEST(['foo', 'bar', 'baz', 'giraffe', 'llama']) AS word;
+---------+------------------------------------+
| word | code_points |
+---------+------------------------------------+
| foo | [102, 111, 111] |
| bar | [98, 97, 114] |
| baz | [98, 97, 122] |
| giraffe | [103, 105, 114, 97, 102, 102, 101] |
| llama | [108, 108, 97, 109, 97] |
+---------+------------------------------------+
다음 예시에서는 BYTES
의 정수 표현을 해당 ASCII 문자 값으로 변환합니다.
SELECT word, TO_CODE_POINTS(word) AS bytes_value_as_integer
FROM UNNEST([b'\x00\x01\x10\xff', b'\x66\x6f\x6f']) AS word;
+------------------+------------------------+
| word | bytes_value_as_integer |
+------------------+------------------------+
| \x00\x01\x10\xff | [0, 1, 16, 255] |
| foo | [102, 111, 111] |
+------------------+------------------------+
다음 예시에서는 BYTES
결과와 STRING
결과 간의 차이를 보여줍니다.
SELECT TO_CODE_POINTS(b'Ā') AS b_result, TO_CODE_POINTS('Ā') AS s_result;
+------------+----------+
| b_result | s_result |
+------------+----------+
| [196, 128] | [256] |
+------------+----------+
문자 Ā는 2바이트 유니코드 시퀀스로 표현됩니다. 따라서 TO_CODE_POINTS
의 BYTES
버전은 요소가 두 개 있는 배열을 반환하며 STRING
버전은 요소가 한 개 있는 배열을 반환합니다.
TO_HEX
TO_HEX(bytes)
설명
BYTES
의 시퀀스를 16진수 STRING
으로 변환합니다. STRING
의 각 바이트를 (0..9, a..f)
범위 내 16진수 문자 두 개로 변환합니다. 16진수로 인코딩된 STRING
을 BYTES
로 변환하려면 FROM_HEX를 사용합니다.
반환 유형
STRING
예시
WITH Input AS (
SELECT b'\x00\x01\x02\x03\xAA\xEE\xEF\xFF' AS byte_str UNION ALL
SELECT b'foobar'
)
SELECT byte_str, TO_HEX(byte_str) AS hex_str
FROM Input;
+----------------------------------+------------------+
| byte_string | hex_string |
+----------------------------------+------------------+
| \x00\x01\x02\x03\xaa\xee\xef\xff | 00010203aaeeefff |
| foobar | 666f6f626172 |
+----------------------------------+------------------+
TRIM
TRIM(value1[, value2])
설명
value2
와 일치하는 모든 선행 및 후행 문자를 제거합니다. value2
가 지정되지 않으면 모든 선행 및 후행 공백 문자(유니코드 표준의 정의에 따름)가 삭제됩니다. 첫 번째 인수의 유형이 BYTES
이면 두 번째 인수가 필요합니다.
value2
에 문자나 바이트가 두 개 이상 포함되어 있으면 함수는 value2
에 포함된 모든 선행 또는 후행 문자나 바이트를 삭제합니다.
반환 유형
STRING
또는 BYTES
예시
WITH items AS
(SELECT " apple " as item
UNION ALL
SELECT " banana " as item
UNION ALL
SELECT " orange " as item)
SELECT
CONCAT("#", TRIM(item), "#") as example
FROM items;
+----------+
| example |
+----------+
| #apple# |
| #banana# |
| #orange# |
+----------+
WITH items AS
(SELECT "***apple***" as item
UNION ALL
SELECT "***banana***" as item
UNION ALL
SELECT "***orange***" as item)
SELECT
TRIM(item, "*") as example
FROM items;
+---------+
| example |
+---------+
| apple |
| banana |
| orange |
+---------+
WITH items AS
(SELECT "xxxapplexxx" as item
UNION ALL
SELECT "yyybananayyy" as item
UNION ALL
SELECT "zzzorangezzz" as item
UNION ALL
SELECT "xyzpearxyz" as item)
SELECT
TRIM(item, "xyz") as example
FROM items;
+---------+
| example |
+---------+
| apple |
| banana |
| orange |
| pear |
+---------+
UPPER
UPPER(value)
설명
STRING
인수의 경우 모든 알파벳 문자가 대문자인 원본 문자열을 반환합니다. 소문자와 대문자 간의 매핑은 계정 언어별 매핑을 고려하지 않고 유니코드 문자 데이터베이스에 따라 수행됩니다.
BYTES
인수에서 인수는 ASCII 텍스트로 취급되며 127보다 큰 모든 바이트는 그대로 유지됩니다.
반환 유형
STRING
또는 BYTES
예시
WITH items AS
(SELECT
"foo" as item
UNION ALL
SELECT
"bar" as item
UNION ALL
SELECT
"baz" as item)
SELECT
UPPER(item) AS example
FROM items;
+---------+
| example |
+---------+
| FOO |
| BAR |
| BAZ |
+---------+
JSON 함수
Cloud Spanner SQL은 JSON 형식의 문자열에 저장된 데이터를 검색하는 데 도움이 되는 함수와 데이터를 JSON 형식의 문자열로 변환하는 데 도움이 되는 함수를 지원합니다.
JSON_QUERY 또는 JSON_VALUE
JSON_QUERY(json_string_expr, json_path_format)
는 JSON 값을 STRING으로 반환합니다.
JSON_VALUE(json_string_expr, json_path_format)
는 스칼라 JSON 값을 STRING으로 반환합니다.
설명
JSON 값 또는 JSON 스칼라 값을 문자열로 추출합니다.
json_string_expr
: JSON 형식의 문자열입니다. 예를 들면 다음과 같습니다.{"class" : {"students" : [{"name" : "Jane"}]}}
json_path_format
: JSONpath 형식입니다. JSON 형식 문자열에서 가져오려는 값을 식별합니다.json_path_format
이 JSONnull
을 반환하면 SQLNULL
로 변환됩니다.
JSON 키가 잘못된 JSONPath 문자를 사용하는 경우, 큰따옴표를 사용하여 해당 문자를 이스케이프할 수 있습니다.
예시
SELECT JSON_QUERY(json_text, '$') AS json_text_string
FROM UNNEST([
'{"class" : {"students" : [{"name" : "Jane"}]}}',
'{"class" : {"students" : []}}',
'{"class" : {"students" : [{"name" : "John"}, {"name": "Jamie"}]}}'
]) AS json_text;
+-----------------------------------------------------------+
| json_text_string |
+-----------------------------------------------------------+
| {"class":{"students":[{"name":"Jane"}]}} |
| {"class":{"students":[]}} |
| {"class":{"students":[{"name":"John"},{"name":"Jamie"}]}} |
+-----------------------------------------------------------+
SELECT JSON_QUERY(json_text, '$.class.students[0]') AS first_student
FROM UNNEST([
'{"class" : {"students" : [{"name" : "Jane"}]}}',
'{"class" : {"students" : []}}',
'{"class" : {"students" : [{"name" : "John"}, {"name": "Jamie"}]}}'
]) AS json_text;
+-----------------+
| first_student |
+-----------------+
| {"name":"Jane"} |
| NULL |
| {"name":"John"} |
+-----------------+
SELECT JSON_QUERY(json_text, '$.class.students[1].name') AS second_student_name
FROM UNNEST([
'{"class" : {"students" : [{"name" : "Jane"}]}}',
'{"class" : {"students" : []}}',
'{"class" : {"students" : [{"name" : "John"}, {"name" : null}]}}',
'{"class" : {"students" : [{"name" : "John"}, {"name": "Jamie"}]}}'
]) AS json_text;
+-------------------+
| second_student |
+-------------------+
| NULL |
| NULL |
| NULL |
| "Jamie" |
+-------------------+
SELECT JSON_QUERY(json_text, '$.class."students"') AS student_names
FROM UNNEST([
'{"class" : {"students" : [{"name" : "Jane"}]}}',
'{"class" : {"students" : []}}',
'{"class" : {"students" : [{"name" : "John"}, {"name": "Jamie"}]}}'
]) AS json_text;
+------------------------------------+
| student_names |
+------------------------------------+
| [{"name":"Jane"}] |
| [] |
| [{"name":"John"},{"name":"Jamie"}] |
+------------------------------------+
SELECT JSON_QUERY('{ "name" : "Jakob", "age" : "6" }', '$.name') as json_name,
JSON_VALUE('{ "name" : "Jakob", "age" : "6" }', '$.name') as scalar_name,
JSON_QUERY('{ "name" : "Jakob", "age" : "6" }', '$.age') as json_age,
JSON_VALUE('{ "name" : "Jakob", "age" : "6" }', '$.age') as scalar;
+-----------+-------------+----------+--------+
| json_name | scalar_name | json_age | scalar |
+-----------+-------------+----------+--------+
| "Jakob" | Jakob | "6" | 6 |
+-----------+-------------+----------+--------+
JSON 키가 잘못된 JSONPath 문자를 사용하는 경우, 큰따옴표를 사용하여 해당 문자를 이스케이프할 수 있습니다. 예를 들면 다음과 같습니다.
SELECT JSON_VALUE('{"a.b": {"c": "world"}}', '$."a.b".c') as hello;
+-------+
| hello |
+-------+
| world |
+-------+
JSONPath 형식
대부분의 JSON 함수는 json_string_expr
및 json_path_format
매개 변수를 전달합니다. json_string_expr
매개 변수는 JSON 형식의 문자열로 전달되며 json_path_format
매개 변수는 JSON 형식의 문자열에서 가져오려는 값을 식별합니다.
json_string_expr
매개 변수는 다음과 같은 형식의 JSON 문자열이어야 합니다.
{"class" : {"students" : [{"name" : "Jane"}]}}
JSONPath 형식을 사용하여 json_path_format
매개 변수를 구성합니다. 이 형식의 일부로 이 매개변수는 JSON 형식 문자열의 가장 바깥쪽 레벨을 참조하는 $
기호로 시작해야 합니다. 하위 값은 점을 사용하여 식별할 수 있습니다. JSON 객체가 배열인 경우에는 대괄호를 사용하여 배열 색인을 지정할 수 있습니다. 키에 $
, 점, 대괄호가 있는 경우 이를 이스케이프하는 방법은 각 JSON 함수를 참조하세요.
JSONPath | 설명 | 예시 | 위의 json_string_expr 를 사용한 결과 |
---|---|---|---|
$ | 루트 객체 또는 요소 | '$' | {"class":{"students":[{"name":"Jane"}]}} |
. | 하위 연산자 | '$.class.students' | [{"name":"Jane"}] |
[] | 아래 첨자 연산자 | '$.class.students[0]' | {"name":"Jane"} |
json_path_format
매개 변수가 json_string_expr
값과 일치하지 않으면 JSON 함수에서 NULL
을 반환합니다. 스칼라 함수에 선택된 값이 스칼라가 아닌 경우(예: 객체 또는 배열) 이 함수는 NULL
를 반환합니다.
JSONPath가 잘못된 경우 함수에서 오류가 발생합니다.
배열 함수
ARRAY
ARRAY(subquery)
설명
ARRAY
함수는 서브 쿼리의 행마다 요소 한 개가 있는 ARRAY
를 반환합니다.
subquery
가 SQL 테이블을 생성할 경우 이 테이블에는 열이 정확히 한 개 있어야 합니다. 출력 ARRAY
의 각 요소는 테이블에 있는 행의 단일 열 값입니다.
subquery
가 값 테이블을 생성할 경우 출력 ARRAY
의 각 요소는 값 테이블의 해당 행 전체입니다.
제약조건
- 서브 쿼리는 정렬되지 않으므로 서브 쿼리의 소스 테이블에서 출력
ARRAY
의 요소 순서가 지켜진다는 보장은 없습니다. 그러나 서브 쿼리에ORDER BY
절이 포함되어 있는 경우ARRAY
함수는 해당 절을 반영하는ARRAY
를 반환합니다. - 서브 쿼리가 둘 이상의 열을 반환하면
ARRAY
함수는 오류를 반환합니다. - 서브 쿼리가
ARRAY
유형의 열 또는ARRAY
유형의 행을 반환하면ARRAY
함수는 오류를 반환합니다. Cloud Spanner SQL은ARRAY
유형의 요소가 있는ARRAY
를 지원하지 않습니다. - 서브 쿼리가 0개의 행을 반환하면
ARRAY
함수는 빈ARRAY
를 반환합니다. 절대NULL
ARRAY
를 반환하지 않습니다.
반환 유형
ARRAY
예
SELECT ARRAY
(SELECT 1 UNION ALL
SELECT 2 UNION ALL
SELECT 3) AS new_array;
+-----------+
| new_array |
+-----------+
| [1, 2, 3] |
+-----------+
여러 개의 열이 포함된 서브 쿼리에서 ARRAY
를 구성하려면 SELECT AS STRUCT
를 사용하도록 서브 쿼리를 변경합니다. 그러면 ARRAY
함수가 STRUCT
의 ARRAY
를 반환합니다. ARRAY
는 서브 쿼리의 각 행에 하나의 STRUCT
를 포함하며, 각각의 STRUCT
는 해당 행의 각 열당 필드 1개를 포함합니다.
SELECT
ARRAY
(SELECT AS STRUCT 1, 2, 3
UNION ALL SELECT AS STRUCT 4, 5, 6) AS new_array;
+------------------------+
| new_array |
+------------------------+
| [{1, 2, 3}, {4, 5, 6}] |
+------------------------+
마찬가지로, 하나 이상의 ARRAY
를 포함하는 서브 쿼리에서 ARRAY
를 구성하려면 SELECT AS STRUCT
를 사용하도록 서브 쿼리를 변경합니다.
SELECT ARRAY
(SELECT AS STRUCT [1, 2, 3] UNION ALL
SELECT AS STRUCT [4, 5, 6]) AS new_array;
+----------------------------+
| new_array |
+----------------------------+
| [{[1, 2, 3]}, {[4, 5, 6]}] |
+----------------------------+
ARRAY_CONCAT
ARRAY_CONCAT(array_expression_1 [, array_expression_n])
설명
요소 유형이 같은 하나 이상의 배열을 단일 배열로 연결합니다.
반환 유형
ARRAY
예시
SELECT ARRAY_CONCAT([1, 2], [3, 4], [5, 6]) as count_to_six;
+--------------------------------------------------+
| count_to_six |
+--------------------------------------------------+
| [1, 2, 3, 4, 5, 6] |
+--------------------------------------------------+
ARRAY_LENGTH
ARRAY_LENGTH(array_expression)
설명
배열의 크기를 반환합니다. 빈 배열에는 0을 반환합니다. array_expression
이 NULL
인 경우 NULL
을 반환합니다.
반환 유형
INT64
예시
WITH items AS
(SELECT ["coffee", NULL, "milk" ] as list
UNION ALL
SELECT ["cake", "pie"] as list)
SELECT ARRAY_TO_STRING(list, ', ', 'NULL'), ARRAY_LENGTH(list) AS size
FROM items
ORDER BY size DESC;
+---------------------------------+------+
| list | size |
+---------------------------------+------+
| [coffee, NULL, milk] | 3 |
| [cake, pie] | 2 |
+---------------------------------+------+
ARRAY_TO_STRING
ARRAY_TO_STRING(array_expression, delimiter[, null_text])
설명
array_expression
에 있는 요소의 연결을 STRING으로 반환합니다. array_expression
값은 STRING 또는 BYTES 데이터 유형의 배열일 수 있습니다.
null_text
매개변수가 사용되면 이 함수는 배열에 있는 모든 NULL
값을 null_text
값으로 바꿉니다.
null_text
매개변수가 사용되지 않으면 이 함수는 NULL
값과 앞의 구분 기호를 생략합니다.
예시
WITH items AS
(SELECT ["coffee", "tea", "milk" ] as list
UNION ALL
SELECT ["cake", "pie", NULL] as list)
SELECT ARRAY_TO_STRING(list, '--') AS text
FROM items;
+--------------------------------+
| text |
+--------------------------------+
| coffee--tea--milk |
| cake--pie |
+--------------------------------+
WITH items AS
(SELECT ["coffee", "tea", "milk" ] as list
UNION ALL
SELECT ["cake", "pie", NULL] as list)
SELECT ARRAY_TO_STRING(list, '--', 'MISSING') AS text
FROM items;
+--------------------------------+
| text |
+--------------------------------+
| coffee--tea--milk |
| cake--pie--MISSING |
+--------------------------------+
GENERATE_ARRAY
GENERATE_ARRAY(start_expression, end_expression[, step_expression])
설명
값 배열을 반환합니다. start_expression
및 end_expression
매개변수는 배열의 시작과 끝을 결정합니다(해당 값 포함).
GENERATE_ARRAY
함수에는 다음 데이터 유형을 입력할 수 있습니다.
- INT64
- NUMERIC
- FLOAT64
step_expression
매개변수는 배열 값을 생성하는 데 사용되는 증분을 결정합니다. 이 매개변수의 기본값은 1
입니다.
step_expression
이 0으로 설정된 경우 또는 입력이 NaN
인 경우 이 함수는 오류를 반환합니다.
NULL
인 인수가 있는 경우 함수는 NULL
배열을 반환합니다.
반환 데이터 유형
ARRAY
예시
다음은 기본 단계가 1인 정수 배열을 반환합니다.
SELECT GENERATE_ARRAY(1, 5) AS example_array;
+-----------------+
| example_array |
+-----------------+
| [1, 2, 3, 4, 5] |
+-----------------+
다음은 사용자가 지정한 단계 크기를 사용하여 배열을 반환합니다.
SELECT GENERATE_ARRAY(0, 10, 3) AS example_array;
+---------------+
| example_array |
+---------------+
| [0, 3, 6, 9] |
+---------------+
다음은 단계 크기로 음수 값 -3
을 사용하여 배열을 반환합니다.
SELECT GENERATE_ARRAY(10, 0, -3) AS example_array;
+---------------+
| example_array |
+---------------+
| [10, 7, 4, 1] |
+---------------+
다음은 start_expression
과 end_expression
에 같은 값을 사용하여 배열을 반환합니다.
SELECT GENERATE_ARRAY(4, 4, 10) AS example_array;
+---------------+
| example_array |
+---------------+
| [4] |
+---------------+
다음은 빈 배열을 반환합니다. start_expression
이 end_expression
보다 크고 step_expression
값이 양수이기 때문입니다.
SELECT GENERATE_ARRAY(10, 0, 3) AS example_array;
+---------------+
| example_array |
+---------------+
| [] |
+---------------+
end_expression
이 NULL
이므로 다음은 NULL
배열을 반환합니다.
SELECT GENERATE_ARRAY(5, NULL, 1) AS example_array;
+---------------+
| example_array |
+---------------+
| NULL |
+---------------+
다음은 여러 배열을 반환합니다.
SELECT GENERATE_ARRAY(start, 5) AS example_array
FROM UNNEST([3, 4, 5]) AS start;
+---------------+
| example_array |
+---------------+
| [3, 4, 5] |
| [4, 5] |
| [5] |
+---------------+
GENERATE_DATE_ARRAY
GENERATE_DATE_ARRAY(start_date, end_date[, INTERVAL INT64_expr date_part])
설명
날짜 배열을 반환합니다. start_date
및 end_date
매개변수는 배열의 시작과 끝을 결정합니다(해당 값 포함).
GENERATE_DATE_ARRAY
함수에는 다음 데이터 유형을 입력할 수 있습니다.
start_date
는 DATE여야 합니다.end_date
는 DATE여야 합니다.INT64_expr
은 INT64여야 합니다.date_part
는 DAY, WEEK, MONTH, QUARTER 또는 YEAR여야 합니다.
INT64_expr
매개변수는 날짜를 생성하는 데 사용되는 증분을 결정합니다. 이 매개변수의 기본값은 1일입니다.
INT64_expr
이 0으로 설정된 경우 이 함수는 오류를 반환합니다.
반환 데이터 유형
0 이상의 DATE 값이 포함된 ARRAY.
예시
다음은 기본 단계가 1인 날짜의 배열을 반환합니다.
SELECT GENERATE_DATE_ARRAY('2016-10-05', '2016-10-08') AS example;
+--------------------------------------------------+
| example |
+--------------------------------------------------+
| [2016-10-05, 2016-10-06, 2016-10-07, 2016-10-08] |
+--------------------------------------------------+
다음은 사용자가 지정한 단계 크기를 사용하여 배열을 반환합니다.
SELECT GENERATE_DATE_ARRAY(
'2016-10-05', '2016-10-09', INTERVAL 2 DAY) AS example;
+--------------------------------------+
| example |
+--------------------------------------+
| [2016-10-05, 2016-10-07, 2016-10-09] |
+--------------------------------------+
다음은 단계 크기로 음수 값 -3
을 사용하여 배열을 반환합니다.
SELECT GENERATE_DATE_ARRAY('2016-10-05',
'2016-10-01', INTERVAL -3 DAY) AS example;
+--------------------------+
| example |
+--------------------------+
| [2016-10-05, 2016-10-02] |
+--------------------------+
다음은 start_date
와 end_date
에 같은 값을 사용하여 배열을 반환합니다.
SELECT GENERATE_DATE_ARRAY('2016-10-05',
'2016-10-05', INTERVAL 8 DAY) AS example;
+--------------+
| example |
+--------------+
| [2016-10-05] |
+--------------+
다음은 빈 배열을 반환합니다. start_date
이 end_date
보다 크고 step
값이 양수이기 때문입니다.
SELECT GENERATE_DATE_ARRAY('2016-10-05',
'2016-10-01', INTERVAL 1 DAY) AS example;
+---------+
| example |
+---------+
| [] |
+---------+
입력 중 하나가 NULL
이므로 다음은 NULL
배열을 반환합니다.
SELECT GENERATE_DATE_ARRAY('2016-10-05', NULL) AS example;
+---------+
| example |
+---------+
| NULL |
+---------+
다음은 MONTH를 date_part
간격으로 사용하여 날짜 배열을 반환합니다.
SELECT GENERATE_DATE_ARRAY('2016-01-01',
'2016-12-31', INTERVAL 2 MONTH) AS example;
+--------------------------------------------------------------------------+
| example |
+--------------------------------------------------------------------------+
| [2016-01-01, 2016-03-01, 2016-05-01, 2016-07-01, 2016-09-01, 2016-11-01] |
+--------------------------------------------------------------------------+
다음은 상수가 아닌 날짜를 사용하여 배열을 생성합니다.
SELECT GENERATE_DATE_ARRAY(date_start, date_end, INTERVAL 1 WEEK) AS date_range
FROM (
SELECT DATE '2016-01-01' AS date_start, DATE '2016-01-31' AS date_end
UNION ALL SELECT DATE "2016-04-01", DATE "2016-04-30"
UNION ALL SELECT DATE "2016-07-01", DATE "2016-07-31"
UNION ALL SELECT DATE "2016-10-01", DATE "2016-10-31"
) AS items;
+--------------------------------------------------------------+
| date_range |
+--------------------------------------------------------------+
| [2016-01-01, 2016-01-08, 2016-01-15, 2016-01-22, 2016-01-29] |
| [2016-04-01, 2016-04-08, 2016-04-15, 2016-04-22, 2016-04-29] |
| [2016-07-01, 2016-07-08, 2016-07-15, 2016-07-22, 2016-07-29] |
| [2016-10-01, 2016-10-08, 2016-10-15, 2016-10-22, 2016-10-29] |
+--------------------------------------------------------------+
OFFSET 및 ORDINAL
array_expression[OFFSET(zero_based_offset)]
array_expression[ORDINAL(one_based_offset)]
설명
위치별로 ARRAY 요소에 액세스하고 해당 요소를 반환합니다. OFFSET
은 0부터 번호가 시작된다는 뜻이고, ORDINAL
은 1부터 번호가 시작된다는 뜻입니다.
주어진 배열은 0이나 1부터 시작되는 것으로 해석될 수 있습니다. 배열 요소에 액세스할 때 배열 위치를 각각 OFFSET
또는 ORDINAL
로 시작해야 합니다. 기본 설정된 동작은 없습니다.
색인이 범위를 벗어날 경우 OFFSET
과 ORDINAL
모두 오류를 생성합니다.
반환 유형
ARRAY 내의 요소에 따라 다릅니다.
예시
WITH items AS
(SELECT ["apples", "bananas", "pears", "grapes"] as list
UNION ALL
SELECT ["coffee", "tea", "milk" ] as list
UNION ALL
SELECT ["cake", "pie"] as list)
SELECT list, list[OFFSET(1)] as offset_1, list[ORDINAL(1)] as ordinal_1
FROM items;
+----------------------------------+-----------+-----------+
| list | offset_1 | ordinal_1 |
+----------------------------------+-----------+-----------+
| [apples, bananas, pears, grapes] | bananas | apples |
| [coffee, tea, milk] | tea | coffee |
| [cake, pie] | pie | cake |
+----------------------------------+-----------+-----------+
ARRAY_REVERSE
ARRAY_REVERSE(value)
설명
요소가 있는 입력 ARRAY를 역순으로 반환합니다.
반환 유형
ARRAY
예시
WITH example AS (
SELECT [1, 2, 3] AS arr UNION ALL
SELECT [4, 5] AS arr UNION ALL
SELECT [] AS arr
)
SELECT
arr,
ARRAY_REVERSE(arr) AS reverse_arr
FROM example;
+-----------+-------------+
| arr | reverse_arr |
+-----------+-------------+
| [1, 2, 3] | [3, 2, 1] |
| [4, 5] | [5, 4] |
| [] | [] |
+-----------+-------------+
ARRAY_IS_DISTINCT
ARRAY_IS_DISTINCT(value)
설명
SELECT DISTINCT
와 동일한 동등 비교 로직을 사용하여 배열에 반복 요소가 없으면 true를 반환합니다.
반환 유형
BOOL
예시
WITH example AS (
SELECT [1, 2, 3] AS arr UNION ALL
SELECT [1, 1, 1] AS arr UNION ALL
SELECT [1, 2, NULL] AS arr UNION ALL
SELECT [1, 1, NULL] AS arr UNION ALL
SELECT [1, NULL, NULL] AS arr UNION ALL
SELECT [] AS arr UNION ALL
SELECT CAST(NULL AS ARRAY<INT64>) AS arr
)
SELECT
arr,
ARRAY_IS_DISTINCT(arr) as is_distinct
FROM example;
+-----------------+-------------+
| arr | is_distinct |
+-----------------+-------------+
| [1, 2, 3] | true |
| [1, 1, 1] | false |
| [1, 2, NULL] | true |
| [1, 1, NULL] | false |
| [1, NULL, NULL] | false |
| [] | true |
| NULL | NULL |
+-----------------+-------------+
SAFE_OFFSET 및 SAFE_ORDINAL
array_expression[SAFE_OFFSET(zero_based_offset)]
array_expression[SAFE_ORDINAL(one_based_offset)]
설명
OFFSET
및 ORDINAL
과 동일하지만 색인이 범위를 벗어나면 NULL
을 반환한다는 점이 다릅니다.
반환 유형
ARRAY 내의 요소에 따라 다릅니다.
예시
WITH items AS
(SELECT ["apples", "bananas", "pears", "grapes"] as list
UNION ALL
SELECT ["coffee", "tea", "milk" ] as list
UNION ALL
SELECT ["cake", "pie"] as list)
SELECT list,
list[SAFE_OFFSET(3)] as safe_offset_3,
list[SAFE_ORDINAL(3)] as safe_ordinal_3
FROM items;
+----------------------------------+---------------+----------------+
| list | safe_offset_3 | safe_ordinal_3 |
+----------------------------------+---------------+----------------+
| [apples, bananas, pears, grapes] | grapes | pears |
| [coffee, tea, milk] | NULL | milk |
| [cake, pie] | NULL | NULL |
+----------------------------------+---------------+----------------+
날짜 함수
Cloud Spanner SQL은 다음과 같은 DATE
함수를 지원합니다.
CURRENT_DATE
CURRENT_DATE([time_zone])
설명
지정된 시간대 또는 기본 시간대를 기준으로 현재 날짜를 반환합니다.
이 함수는 선택적 time_zone
매개변수를 지원합니다. 이 매개변수는 사용할 시간대를 나타내는 문자열입니다. 시간대를 지정하지 않으면 기본 시간대인 America/Los_Angeles가 사용됩니다. 시간대를 지정하는 방법에 대한 자세한 내용은 시간대 정의를 참조하세요.
time_zone
매개변수가 NULL
로 평가되면 이 함수는 NULL
을 반환합니다.
반환 데이터 유형
DATE
예시
SELECT CURRENT_DATE() as the_date;
+--------------+
| the_date |
+--------------+
| 2016-12-25 |
+--------------+
EXTRACT
EXTRACT(part FROM date_expression)
설명
지정된 날짜 부분에 해당하는 값을 반환합니다. part
는 다음 중 하나여야 합니다.
DAYOFWEEK
: 한 주의 첫날이 일요일인 [1,7] 범위의 값을 반환합니다.DAY
DAYOFYEAR
WEEK
: [0, 53] 범위에서 날짜의 주 번호를 반환합니다. 주는 일요일부터 시작되며 그 해의 첫 번째 일요일 이전 날짜는 0번째 주에 속합니다.ISOWEEK
:date_expression
의 ISO 8601 주 번호를 반환합니다.ISOWEEK
는 월요일에 시작됩니다. 반환 값은 [1, 53] 범위에 속합니다. 각 ISO 연도의 첫 번째ISOWEEK
는 태양력 연도의 첫 번째 목요일 이전의 월요일에 시작됩니다.MONTH
QUARTER
: [1,4] 범위의 값을 반환합니다.YEAR
ISOYEAR
:date_expression
이 속한 주의 목요일을 포함하는 태양력 연도인 ISO 8601 주 번호 지정 연도를 반환합니다.
반환 데이터 유형
INT64
예시
다음 예시에서 EXTRACT
는 DAY
날짜 부분에 해당하는 값을 반환합니다.
SELECT EXTRACT(DAY FROM DATE '2013-12-25') as the_day;
+---------+
| the_day |
+---------+
| 25 |
+---------+
다음 예시에서 EXTRACT
는 연말에 가까운 날짜 열에서 다른 날짜 부분에 해당하는 값을 반환합니다.
SELECT
date,
EXTRACT(ISOYEAR FROM date) AS isoyear,
EXTRACT(ISOWEEK FROM date) AS isoweek,
EXTRACT(YEAR FROM date) AS year,
EXTRACT(WEEK FROM date) AS week
FROM UNNEST(GENERATE_DATE_ARRAY('2015-12-23', '2016-01-09')) AS date
ORDER BY date;
+------------+---------+---------+------+------+
| date | isoyear | isoweek | year | week |
+------------+---------+---------+------+------+
| 2015-12-23 | 2015 | 52 | 2015 | 51 |
| 2015-12-24 | 2015 | 52 | 2015 | 51 |
| 2015-12-25 | 2015 | 52 | 2015 | 51 |
| 2015-12-26 | 2015 | 52 | 2015 | 51 |
| 2015-12-27 | 2015 | 52 | 2015 | 52 |
| 2015-12-28 | 2015 | 53 | 2015 | 52 |
| 2015-12-29 | 2015 | 53 | 2015 | 52 |
| 2015-12-30 | 2015 | 53 | 2015 | 52 |
| 2015-12-31 | 2015 | 53 | 2015 | 52 |
| 2016-01-01 | 2015 | 53 | 2016 | 0 |
| 2016-01-02 | 2015 | 53 | 2016 | 0 |
| 2016-01-03 | 2015 | 53 | 2016 | 1 |
| 2016-01-04 | 2016 | 1 | 2016 | 1 |
| 2016-01-05 | 2016 | 1 | 2016 | 1 |
| 2016-01-06 | 2016 | 1 | 2016 | 1 |
| 2016-01-07 | 2016 | 1 | 2016 | 1 |
| 2016-01-08 | 2016 | 1 | 2016 | 1 |
| 2016-01-09 | 2016 | 1 | 2016 | 1 |
+------------+---------+---------+------+------+
DATE
1. DATE(year, month, day)
2. DATE(timestamp_expression[, timezone])
설명
- 연도, 월, 일을 나타내는 INT64 값에서 DATE를 구성합니다.
- TIMESTAMP 표현식에서 DATE를 추출합니다. 시간대를 지정하는 선택적 매개변수를 지원합니다. 시간대를 지정하지 않으면 기본 시간대인 America/Los_Angeles가 사용됩니다.
반환 데이터 유형
DATE
예시
SELECT
DATE(2016, 12, 25) as date_ymd,
DATE(TIMESTAMP "2016-12-25 05:30:00+07", "America/Los_Angeles") as date_tstz;
+------------+------------+
| date_ymd | date_tstz |
+------------+------------+
| 2016-12-25 | 2016-12-24 |
+------------+------------+
DATE_ADD
DATE_ADD(date_expression, INTERVAL int64_expression date_part)
설명
DATE에 지정된 시간 간격을 추가합니다.
DATE_ADD
는 다음과 같은 date_part
값을 지원합니다.
DAY
WEEK
. 7DAY
에 해당합니다.MONTH
QUARTER
YEAR
월말이거나 월말과 가까운 날짜는 MONTH, QUARTER, YEAR 부분을 특수하게 처리해야 합니다. 달의 결과값이 원본 날짜의 일수보다 적을 경우, 일의 결과값은 새달의 마지막 날입니다.
반환 데이터 유형
DATE
예시
SELECT DATE_ADD(DATE "2008-12-25", INTERVAL 5 DAY) as five_days_later;
+--------------------+
| five_days_later |
+--------------------+
| 2008-12-30 |
+--------------------+
DATE_SUB
DATE_SUB(date_expression, INTERVAL int64_expression date_part)
설명
DATE에서 지정된 시간 간격을 뺍니다.
DATE_SUB
는 다음과 같은 date_part
값을 지원합니다.
DAY
WEEK
. 7DAY
에 해당합니다.MONTH
QUARTER
YEAR
월말이거나 월말과 가까운 날짜는 MONTH, QUARTER, YEAR 부분을 특수하게 처리해야 합니다. 달의 결과값이 원본 날짜의 일수보다 적을 경우, 일의 결과값은 새달의 마지막 날입니다.
반환 데이터 유형
DATE
예시
SELECT DATE_SUB(DATE "2008-12-25", INTERVAL 5 DAY) as five_days_ago;
+---------------+
| five_days_ago |
+---------------+
| 2008-12-20 |
+---------------+
DATE_DIFF
DATE_DIFF(date_expression_a, date_expression_b, date_part)
설명
두 DATE
객체(date_expression_a
- date_expression_b
) 간에 지정된 전체 date_part
간격의 수를 반환합니다. 첫 번째 DATE
가 두 번째 객체보다 이전이면 출력이 음수입니다.
DATE_DIFF
는 다음과 같은 date_part
값을 지원합니다.
DAY
WEEK
이 날짜 부분은 일요일에 시작합니다.ISOWEEK
: ISO 8601 주 경계를 사용합니다. ISO 주는 월요일에 시작됩니다.MONTH
QUARTER
YEAR
ISOYEAR
: ISO 8601 주 번호 지정 연도 경계를 사용합니다. ISO 연도 경계는 목요일이 해당 태양력 연도에 속하는 첫 번째 주의 월요일입니다.
반환 데이터 유형
INT64
예시
SELECT DATE_DIFF(DATE '2010-07-07', DATE '2008-12-25', DAY) as days_diff;
+-----------+
| days_diff |
+-----------+
| 559 |
+-----------+
SELECT
DATE_DIFF(DATE '2017-10-15', DATE '2017-10-14', DAY) as days_diff,
DATE_DIFF(DATE '2017-10-15', DATE '2017-10-14', WEEK) as weeks_diff;
+-----------+------------+
| days_diff | weeks_diff |
+-----------+------------+
| 1 | 1 |
+-----------+------------+
위의 예시는 연속되는 두 날짜의 DATE_DIFF
결과를 보여줍니다.
날짜 부분 WEEK
가 있는 DATE_DIFF
는 1을 반환하는데, DATE_DIFF
가 이 날짜 범위에 있는 날짜 부분 경계의 수를 세기 때문입니다. 각각의 WEEK
는 일요일에 시작하므로 2017-10-14 토요일과 2017-10-15 일요일 사이에는 하나의 날짜 부분 경계가 있습니다.
다음 예시는 연도가 서로 다른 두 날짜의 DATE_DIFF
결과를 보여줍니다. 날짜 부분 YEAR
가 있는 DATE_DIFF
는 3을 반환하는데, 두 날짜 사이에 있는 태양력 연도 경계의 수를 세기 때문입니다. 날짜 부분 ISOYEAR
가 있는 DATE_DIFF
는 2를 반환하는데, 두 번째 날짜가 ISO 2015 연도에 속하기 때문입니다. 2015 달력 연도의 첫 번째 목요일은 2015-01-01이었으므로 ISO 2015 연도는 이전 월요일인 2014-12-29에 시작합니다.
SELECT
DATE_DIFF('2017-12-30', '2014-12-30', YEAR) AS year_diff,
DATE_DIFF('2017-12-30', '2014-12-30', ISOYEAR) AS isoyear_diff;
+-----------+--------------+
| year_diff | isoyear_diff |
+-----------+--------------+
| 3 | 2 |
+-----------+--------------+
다음 예시는 연속되는 두 날짜의 DATE_DIFF
결과를 보여줍니다. 첫 번째 날짜는 월요일이고 두 번째 날짜는 일요일입니다. 날짜 부분 DATE_DIFF
가 있는 WEEK
는 0을 반환하는데, 이 날짜 부분이 일요일에 시작하는 주를 사용하기 때문입니다. 날짜 부분 ISOWEEK
가 있는 DATE_DIFF
는 ISO 주가 월요일에 시작하므로 1을 반환합니다.
SELECT
DATE_DIFF('2017-12-18', '2017-12-17', WEEK) AS week_diff,
DATE_DIFF('2017-12-18', '2017-12-17', ISOWEEK) AS isoweek_diff;
+-----------+--------------+
| week_diff | isoweek_diff |
+-----------+--------------+
| 0 | 1 |
+-----------+--------------+
DATE_TRUNC
DATE_TRUNC(date_expression, date_part)
설명
날짜를 지정한 단위로 자릅니다.
DATE_TRUNC
는 date_part
에 다음 값을 지원합니다.
DAY
WEEK
ISOWEEK
:date_expression
을 이전 ISO 8601 주 경계로 자릅니다.ISOWEEK
는 월요일에 시작됩니다. 각 ISO 연도의 첫 번째ISOWEEK
는 해당 그레고리력 연도의 첫 번째 목요일을 포함합니다. 이보다 이전의 모든date_expression
은 이전 월요일로 자릅니다.MONTH
QUARTER
YEAR
ISOYEAR
:date_expression
을 이전 ISO 8601 주 번호 지정 연도 경계로 자릅니다. ISO 연도 경계는 목요일이 해당 태양력 연도에 속하는 첫 번째 주의 월요일입니다.
반환 데이터 유형
DATE
예시
SELECT DATE_TRUNC(DATE '2008-12-25', MONTH) as month;
+------------+
| month |
+------------+
| 2008-12-01 |
+------------+
다음 예시에서 원본 date_expression
은 태양력 2015 연도에 속합니다. 하지만 ISOYEAR
날짜 부분이 있는 DATE_TRUNC
는 태양력 연도가 아니라 ISO 연도의 시작으로 date_expression
을 자릅니다. 2015 달력 연도의 첫 번째 목요일은 2015-01-01이었으므로 ISO 2015 연도는 이전 월요일인 2014-12-29에 시작합니다.
따라서 date_expression
2015-06-15 이전의 ISO 연도 경계는 2014-12-29입니다.
SELECT
DATE_TRUNC('2015-06-15', ISOYEAR) AS isoyear_boundary,
EXTRACT(ISOYEAR FROM DATE '2015-06-15') AS isoyear_number;
+------------------+----------------+
| isoyear_boundary | isoyear_number |
+------------------+----------------+
| 2014-12-29 | 2015 |
+------------------+----------------+
DATE_FROM_UNIX_DATE
DATE_FROM_UNIX_DATE(int64_expression)
설명
int64_expression
을 1970-01-01 이후의 일수로 해석합니다.
반환 데이터 유형
DATE
예시
SELECT DATE_FROM_UNIX_DATE(14238) as date_from_epoch;
+-----------------+
| date_from_epoch |
+-----------------+
| 2008-12-25 |
+-----------------+
FORMAT_DATE
FORMAT_DATE(format_string, date_expr)
설명
지정된 format_string
에 따라 date_expr
의 형식을 지정합니다.
이 함수가 지원하는 형식 요소 목록은 DATE에 지원되는 형식 요소를 참조하세요.
반환 데이터 유형
STRING
예시
SELECT FORMAT_DATE("%x", DATE "2008-12-25") as US_format;
+------------+
| US_format |
+------------+
| 12/25/08 |
+------------+
SELECT FORMAT_DATE("%b-%d-%Y", DATE "2008-12-25") AS formatted;
+-------------+
| formatted |
+-------------+
| Dec-25-2008 |
+-------------+
SELECT FORMAT_DATE("%b %Y", DATE "2008-12-25") AS formatted;
+-------------+
| formatted |
+-------------+
| Dec 2008 |
+-------------+
PARSE_DATE
PARSE_DATE(format_string, date_string)
설명
날짜의 문자열 표현을 DATE
객체로 변환합니다.
format_string
에는 date_string
형식을 지정하는 방법을 정의하는 형식 요소가 포함됩니다. date_string
의 각 요소는 format_string
에 해당하는 요소가 있어야 합니다. format_string
에 있는 각 요소의 위치는 date_string
에 있는 각 요소의 위치와 일치해야 합니다.
-- This works because elements on both sides match.
SELECT PARSE_DATE("%A %b %e %Y", "Thursday Dec 25 2008")
-- This doesn't work because the year element is in different locations.
SELECT PARSE_DATE("%Y %A %b %e", "Thursday Dec 25 2008")
-- This doesn't work because one of the year elements is missing.
SELECT PARSE_DATE("%A %b %e", "Thursday Dec 25 2008")
-- This works because %F can find all matching elements in date_string.
SELECT PARSE_DATE("%F", "2000-12-30")
형식 문자열은 %a
, %A
, %g
, %G
, %j
, %u
, %U
, %V
, %w
, %W
를 제외한 대부분의 형식 요소를 완벽하게 지원합니다.
PARSE_DATE
를 사용할 때는 다음 사항에 유의하세요.
- 미지정 필드. 지정하지 않은 필드는
1970-01-01
부터 초기화됩니다. - 대소문자를 구분하지 않는 이름.
Monday
,February
등의 이름은 대소문자를 구분하지 않습니다. - 공백. 형식 문자열에 하나 이상의 공백이 연달아 있는 경우는 날짜 문자열에 0개 이상의 공백이 연달아 있는 것에 해당합니다. 또한 날짜 문자열의 선행 및 후행 공백은 형식 문자열에 없더라도 언제나 허용됩니다.
- 형식 우선순위. 2개(또는 그 이상)의 형식 요소에 중첩되는 정보가 있을 경우(예:
%F
와%Y
가 모두 연도에 적용되는 경우), 일반적으로 마지막 요소가 앞의 요소보다 우선합니다.
반환 데이터 유형
DATE
예시
다음 예시는 MM/DD/YY
형식 문자열을 DATE
객체로 변환합니다.
SELECT PARSE_DATE("%x", "12/25/08") as parsed;
+------------+
| parsed |
+------------+
| 2008-12-25 |
+------------+
다음 예시는 YYYYMMDD
형식 문자열을 DATE
객체로 변환합니다.
SELECT PARSE_DATE("%Y%m%d", "20081225") as parsed;
+------------+
| parsed |
+------------+
| 2008-12-25 |
+------------+
UNIX_DATE
UNIX_DATE(date_expression)
설명
1970-01-01 이후의 일수를 반환합니다.
반환 데이터 유형
INT64
예시
SELECT UNIX_DATE(DATE "2008-12-25") as days_from_epoch;
+-----------------+
| days_from_epoch |
+-----------------+
| 14238 |
+-----------------+
DATE에 지원되는 형식 요소
달리 명시되지 않는 한, 형식 문자열을 사용하는 DATE 함수는 다음 요소를 지원합니다.
형식 요소 | 설명 |
%A | 요일 이름입니다. |
%a | 요일 이름의 약어입니다. |
%B | 월 이름입니다. |
%b 또는 %h | 월 이름의 약어입니다. |
%C | 10진수(00~99)로 표현한 세기(연도를 100으로 나누어 정수로 자른 것)입니다. |
%D | %m/%d/%y 형식으로 표현한 날짜입니다. |
%d | 한 달의 일을 10진수(01~31)로 표현한 것입니다. |
%e | 한 달의 일을 10진수(1~31)로 표현한 것입니다. 한 자릿수 앞에는 공백이 옵니다. |
%F | %Y-%m-%d 형식으로 표현한 날짜입니다. |
%G | ISO 8601 연도를 세기와 함께 10진수로 표현한 것입니다. 각 ISO 연도는 태양력 연도의 첫 번째 목요일 전 월요일에 시작됩니다. 그레고리력 연도와 ISO 연도가 달라질 수 있는 그레고리력 연도 경계 근처에서 %G와 %Y가 서로 다른 결과를 생성할 수 있습니다. |
%g | ISO 8601 연도를 세기 없이 10진수(00~99)로 표현한 것입니다. 각 ISO 연도는 태양력 연도의 첫 번째 목요일 전 월요일에 시작됩니다. 태양력 연도와 ISO 연도가 달라질 수 있는 그레고리력 연도 경계 근처에서 %g와 %y가 서로 다른 결과를 생성할 수 있습니다. |
%j | 한 해의 일을 10진수(001~366)로 표현한 것입니다. |
%m | 월을 10진수(01~12)로 표현한 것입니다. |
%n | 줄바꿈 문자입니다. |
%t | 탭 문자입니다. |
%U | 한 해의 주 번호(일요일이 일주일의 첫 번째 날임)를 10진수(00~53)로 표현한 것입니다. |
%u | 요일(월요일이 일주일의 첫 번째 날임)을 10진수(1~7)로 표현한 것입니다. |
%V | ISO 8601 한 해의 주 번호(월요일이 일주일의 첫 번째 날임)를 10진수(01~53)로 표현한 것입니다. 새해에 1월 1일이 포함된 주의 일수가 4일 이상인 경우, 그 주가 첫 번째 주이고, 그렇지 않은 경우에는 그 주가 이전 연도의 53번째 주이고 그 다음 주가 첫 번째 주입니다. |
%W | 한 해의 주 번호(월요일이 일주일의 첫 번째 날임)를 10진수(00~53)로 표현한 것입니다. |
%w | 요일(일요일이 일주일의 첫 번째 날임)을 10진수(0~6)로 표현한 것입니다. |
%x | 날짜를 MM/DD/YY 형식으로 표현한 것입니다. |
%Y | 연도를 세기와 함께 10진수로 표현한 것입니다. |
%y | 연도를 세기 없이 10진수(00~99)로 표현한 것입니다. 앞의 0 표기 여부는 선택할 수 있습니다. %C와 함께 사용할 수 있습니다. %C를 지정하지 않으면, 00~68년은 2000년대이고 69~99년은 1900년대입니다. |
%E4Y | 4자릿수 연도(0001~9999). %Y는 연도를 완전히 렌더링하는 데 필요한 만큼 문자를 생성합니다. |
타임스탬프 함수
Cloud Spanner SQL은 다음과 같은 TIMESTAMP
함수를 지원합니다.
참고: 이 함수는 오버플로가 발생할 경우 런타임 오류를 반환합니다. 결과값은 정의된 날짜와 타임스탬프 최솟값/최댓값으로 제한됩니다.
CURRENT_TIMESTAMP
CURRENT_TIMESTAMP()
설명
괄호는 선택사항입니다. 이 함수는 삽입된 윤초의 전후 20시간에 걸쳐 윤초를 분산하는 방식으로 처리합니다.
CURRENT_TIMESTAMP()
는 연속적이고 모호하지 않으며 분당 정확히 60초이고 윤초 동안 값을 반복하지 않는 TIMESTAMP 값을 생성합니다.
지원되는 입력 유형
해당 없음
결과 데이터 유형
TIMESTAMP
예시
SELECT CURRENT_TIMESTAMP() as now;
+--------------------------------+
| now |
+--------------------------------+
| 2020-06-02T23:58:40.347847393Z |
+--------------------------------+
EXTRACT
EXTRACT(part FROM timestamp_expression [AT TIME ZONE timezone])
설명
제공된 timestamp_expression
에서 지정된 part
에 해당하는 값을 반환합니다. 이 함수는 선택적 timezone
매개변수를 지원합니다. 시간대를 지정하는 방법에 대한 자세한 내용은 시간대 정의를 참조하세요.
허용되는 part
값은 다음과 같습니다.
NANOSECOND
MICROSECOND
MILLISECOND
SECOND
MINUTE
HOUR
DAYOFWEEK
DAY
DAYOFYEAR
WEEK
: [0, 53] 범위에서 날짜의 주 번호를 반환합니다. 주는 일요일부터 시작되며 그 해의 첫 번째 일요일 이전 날짜는 0번째 주에 속합니다.ISOWEEK
:datetime_expression
의 ISO 8601 주 번호를 반환합니다.ISOWEEK
는 월요일에 시작됩니다. 반환 값은 [1, 53] 범위에 속합니다. 각 ISO 연도의 첫 번째ISOWEEK
는 태양력 연도의 첫 번째 목요일 이전의 월요일에 시작됩니다.MONTH
QUARTER
YEAR
ISOYEAR
:date_expression
이 속한 주의 목요일을 포함하는 태양력 연도인 ISO 8601 주 번호 지정 연도를 반환합니다.DATE
반환되는 값은 하위의 기간을 자릅니다. 예를 들어 초를 추출할 경우 EXTRACT
는 밀리초와 마이크로초 값을 자릅니다.
반환 데이터 유형
다음 경우를 제외한 INT64입니다.
part
가DATE
이면DATE
객체를 반환합니다.
예시
다음 예시에서 EXTRACT
는 DAY
시간 부분에 해당하는 값을 반환합니다.
WITH Input AS (SELECT TIMESTAMP("2008-12-25 05:30:00+00") AS timestamp_value)
SELECT
EXTRACT(DAY FROM timestamp_value AT TIME ZONE "UTC") AS the_day_utc,
EXTRACT(DAY FROM timestamp_value AT TIME ZONE "America/Los_Angeles") AS the_day_california
FROM Input
+-------------+--------------------+
| the_day_utc | the_day_california |
+-------------+--------------------+
| 25 | 24 |
+-------------+--------------------+
다음 예시에서 EXTRACT
는 타임스탬프 열의 다양한 시간 부분에 해당하는 값을 반환합니다.
WITH Timestamps AS (
SELECT TIMESTAMP("2005-01-03 12:34:56+00") AS timestamp_value UNION ALL
SELECT TIMESTAMP("2007-12-31 12:00:00+00") UNION ALL
SELECT TIMESTAMP("2009-01-01 12:00:00+00") UNION ALL
SELECT TIMESTAMP("2009-12-31 12:00:00+00") UNION ALL
SELECT TIMESTAMP("2017-01-02 12:00:00+00") UNION ALL
SELECT TIMESTAMP("2017-05-26 12:00:00+00")
)
SELECT
timestamp_value,
EXTRACT(ISOYEAR FROM timestamp_value) AS isoyear,
EXTRACT(ISOWEEK FROM timestamp_value) AS isoweek,
EXTRACT(YEAR FROM timestamp_value) AS year,
EXTRACT(WEEK FROM timestamp_value) AS week
FROM Timestamps
ORDER BY timestamp_value;
-- Results may differ, depending upon the environment and time zone where this query was executed.
+------------------------+---------+---------+------+------+
| timestamp_value | isoyear | isoweek | year | week |
+------------------------+---------+---------+------+------+
| 2005-01-03T12:34:56Z | 2005 | 1 | 2005 | 1 |
| 2007-12-31T12:00:00Z | 2008 | 1 | 2007 | 52 |
| 2009-01-01T12:00:00Z | 2009 | 1 | 2009 | 0 |
| 2009-12-31T12:00:00Z | 2009 | 53 | 2009 | 52 |
| 2017-01-02T12:00:00Z | 2017 | 1 | 2017 | 1 |
| 2017-05-26T12:00:00Z | 2017 | 21 | 2017 | 21 |
+------------------------+---------+---------+------+------+
STRING
STRING(timestamp_expression[, timezone])
설명
timestamp_expression
을 STRING 데이터 유형으로 변환합니다. 시간대를 지정하는 선택적 매개변수를 지원합니다. 시간대를 지정하는 방법에 대한 자세한 내용은 시간대 정의를 참조하세요.
반환 데이터 유형
STRING
예시
SELECT STRING(TIMESTAMP "2008-12-25 15:30:00+00", "UTC") AS string;
+-------------------------------+
| string |
+-------------------------------+
| 2008-12-25 15:30:00+00 |
+-------------------------------+
TIMESTAMP
TIMESTAMP(string_expression[, timezone])
TIMESTAMP(date_expression[, timezone])
설명
string_expression[, timezone]
: STRING 표현식을 TIMESTAMP 데이터 유형으로 변환합니다.string_expression
은 타임스탬프 리터럴을 포함해야 합니다.string_expression
에 타임스탬프 리터럴의 시간대가 포함된 경우 명시적인timezone
인수를 포함하지 마세요.date_expression[, timezone]
: DATE 객체를 TIMESTAMP 데이터 유형으로 변환합니다.
이 함수는 시간대를 지정하는 선택적 매개변수를 지원합니다. 시간대를 지정하지 않으면 기본 시간대인 America/Los_Angeles가 사용됩니다.
반환 데이터 유형
TIMESTAMP
예시
SELECT TIMESTAMP("2008-12-25 15:30:00+00") AS timestamp_str;
-- Results may differ, depending upon the environment and time zone where this query was executed.
+----------------------+
| timestamp_str |
+----------------------+
| 2008-12-25T15:30:00Z |
+----------------------+
SELECT TIMESTAMP("2008-12-25 15:30:00", "America/Los_Angeles") AS timestamp_str;
-- Results may differ, depending upon the environment and time zone where this query was executed.
+----------------------+
| timestamp_str |
+----------------------+
| 2008-12-25T23:30:00Z |
+----------------------+
SELECT TIMESTAMP("2008-12-25 15:30:00 UTC") AS timestamp_str;
-- Results may differ, depending upon the environment and time zone where this query was executed.
+----------------------+
| timestamp_str |
+----------------------+
| 2008-12-25T15:30:00Z |
+----------------------+
SELECT TIMESTAMP(DATE "2008-12-25") AS timestamp_date;
-- Results may differ, depending upon the environment and time zone where this query was executed.
+----------------------+
| timestamp_date |
+----------------------+
| 2008-12-25T08:00:00Z |
+----------------------+
TIMESTAMP_ADD
TIMESTAMP_ADD(timestamp_expression, INTERVAL int64_expression date_part)
설명
시간대와 관계없이 date_part
의 int64_expression
단위를 타임스탬프에 추가합니다.
TIMESTAMP_ADD
는 date_part
에 다음 값을 지원합니다.
NANOSECOND
MICROSECOND
MILLISECOND
SECOND
MINUTE
HOUR
: 60MINUTE
에 해당합니다.DAY
: 24HOUR
에 해당합니다.
반환 데이터 유형
TIMESTAMP
예시
SELECT
TIMESTAMP("2008-12-25 15:30:00+00") AS original,
TIMESTAMP_ADD(TIMESTAMP "2008-12-25 15:30:00+00", INTERVAL 10 MINUTE) AS later;
-- Results may differ, depending upon the environment and time zone where this query was executed.
+------------------------+------------------------+
| original | later |
+------------------------+------------------------+
| 2008-12-25T15:30:00Z | 2008-12-25T15:40:00Z |
+------------------------+------------------------+
TIMESTAMP_SUB
TIMESTAMP_SUB(timestamp_expression, INTERVAL int64_expression date_part)
설명
시간대와 관계없이 타임스탬프에서 date_part
의 int64_expression
단위를 뺍니다.
TIMESTAMP_SUB
는 date_part
에 다음 값을 지원합니다.
NANOSECOND
MICROSECOND
MILLISECOND
SECOND
MINUTE
HOUR
: 60MINUTE
에 해당합니다.DAY
: 24HOUR
에 해당합니다.
반환 데이터 유형
TIMESTAMP
예시
SELECT
TIMESTAMP("2008-12-25 15:30:00+00") AS original,
TIMESTAMP_SUB(TIMESTAMP "2008-12-25 15:30:00+00", INTERVAL 10 MINUTE) AS earlier;
-- Results may differ, depending upon the environment and time zone where this query was executed.
+------------------------+------------------------+
| original | earlier |
+------------------------+------------------------+
| 2008-12-25T15:30:00Z | 2008-12-25T15:20:00Z |
+------------------------+------------------------+
TIMESTAMP_DIFF
TIMESTAMP_DIFF(timestamp_expression_a, timestamp_expression_b, date_part)
설명
두 TIMESTAMP
객체(timestamp_expression_a
- timestamp_expression_b
) 간에 지정된 전체 date_part
간격의 수를 반환합니다. 첫 번째 TIMESTAMP
가 두 번째 객체보다 이전이면 출력이 음수입니다. 두 TIMESTAMP
객체 간 나노초의 차이가 INT64
값을 오버플로하는 경우처럼 계산이 결과 유형을 오버플로하는 경우 오류가 발생합니다.
TIMESTAMP_DIFF
는 date_part
에 다음 값을 지원합니다.
NANOSECOND
MICROSECOND
MILLISECOND
SECOND
MINUTE
HOUR
: 60MINUTE
에 해당합니다.DAY
: 24HOUR
에 해당합니다.
반환 데이터 유형
INT64
예시
SELECT
TIMESTAMP("2010-07-07 10:20:00+00") AS later_timestamp,
TIMESTAMP("2008-12-25 15:30:00+00") AS earlier_timestamp,
TIMESTAMP_DIFF(TIMESTAMP "2010-07-07 10:20:00+00", TIMESTAMP "2008-12-25 15:30:00+00", HOUR) AS hours;
-- Results may differ, depending upon the environment and time zone where this query was executed.
+------------------------+------------------------+-------+
| later_timestamp | earlier_timestamp | hours |
+------------------------+------------------------+-------+
| 2010-07-07T10:20:00Z | 2008-12-25T15:30:00Z | 13410 |
+------------------------+------------------------+-------+
다음 예시에서 첫 번째 타임스탬프가 두 번째 타임스탬프보다 먼저 발생하면 음수 출력이 생성됩니다.
SELECT TIMESTAMP_DIFF(TIMESTAMP "2018-08-14", TIMESTAMP "2018-10-14", DAY);
+---------------+
| negative_diff |
+---------------+
| -61 |
+---------------+
이 예시에서는 지정된 전체 HOUR
간격의 수만 포함되므로 결과가 0입니다.
SELECT TIMESTAMP_DIFF("2001-02-01 01:00:00", "2001-02-01 00:00:01", HOUR)
+---------------+
| negative_diff |
+---------------+
| 0 |
+---------------+
TIMESTAMP_TRUNC
TIMESTAMP_TRUNC(timestamp_expression, date_part[, timezone])
설명
타임스탬프를 date_part
의 단위로 자릅니다.
TIMESTAMP_TRUNC
는 date_part
에 다음 값을 지원합니다.
NANOSECOND
MICROSECOND
MILLISECOND
SECOND
MINUTE
HOUR
DAY
WEEK
ISOWEEK
:timestamp_expression
을 이전 ISO 8601 주 경계로 자릅니다.ISOWEEK
는 월요일에 시작됩니다. 각 ISO 연도의 첫 번째ISOWEEK
는 해당 그레고리력 연도의 첫 번째 목요일을 포함합니다. 이보다 이전의 모든date_expression
은 이전 월요일로 자릅니다.MONTH
QUARTER
YEAR
ISOYEAR
:timestamp_expression
을 이전 ISO 8601 주 번호 지정 연도 경계로 자릅니다. ISO 연도 경계는 목요일이 해당 태양력 연도에 속하는 첫 번째 주의 월요일입니다.
TIMESTAMP_TRUNC
함수는 선택적 timezone
매개변수를 지원합니다. 이 매개변수는 다음 date_parts
에 적용됩니다.
MINUTE
HOUR
DAY
WEEK
ISOWEEK
MONTH
QUARTER
YEAR
ISOYEAR
자르기 작업의 일환으로 기본 시간대인 America/Los_Angeles 이외의 시간대를 사용하려면 이 매개변수를 사용합니다.
TIMESTAMP
를 MINUTE
또는 HOUR
로 자르면 TIMESTAMP_TRUNC
는 지정된(또는 기본값) 시간대에서 TIMESTAMP
의 상용시를 결정하고, 해당 TIMESTAMP
에서 분과 초(HOUR로 자를 경우) 또는 초(MINUTE로 자를 경우)를 뺍니다.
이렇게 하면 대부분의 경우 직관적인 결과가 제공되지만, 순차적 시간으로 나열되지 않는 일광 절약 시간 전환 무렵에는 직관적이지 않은 결과를 얻게 됩니다.
반환 데이터 유형
TIMESTAMP
예시
SELECT
TIMESTAMP_TRUNC(TIMESTAMP "2008-12-25 15:30:00+00", DAY, "UTC") AS utc,
TIMESTAMP_TRUNC(TIMESTAMP "2008-12-25 15:30:00+00", DAY, "America/Los_Angeles") AS la;
-- Results may differ, depending upon the environment and time zone where this query was executed.
+------------------------+------------------------+
| utc | la |
+------------------------+------------------------+
| 2008-12-25T00:00:00Z | 2008-12-25T08:00:00Z |
+------------------------+------------------------+
다음 예시에서 원본 timestamp_expression
은 태양력 2015 연도에 속합니다. 하지만 ISOYEAR
날짜 부분이 있는 TIMESTAMP_TRUNC
는 그레고리력 연도가 아니라 ISO 연도의 시작으로 timestamp_expression
을 자릅니다. 2015 달력 연도의 첫 번째 목요일은 2015-01-01이었으므로 ISO 2015 연도는 이전 월요일인 2014-12-29에 시작합니다.
따라서 timestamp_expression
2015-06-15 00:00:00+00 이전의 ISO 연도 경계는 2014-12-29입니다.
SELECT
TIMESTAMP_TRUNC("2015-06-15 00:00:00+00", ISOYEAR) AS isoyear_boundary,
EXTRACT(ISOYEAR FROM TIMESTAMP "2015-06-15 00:00:00+00") AS isoyear_number;
-- Results may differ, depending upon the environment and time zone where this query was executed.
+------------------------+----------------+
| parsed | isoyear_number |
+------------------------+----------------+
| 2014-12-29T08:00:00Z | 2015 |
+------------------------+----------------+
FORMAT_TIMESTAMP
FORMAT_TIMESTAMP(format_string, timestamp[, timezone])
설명
지정된 format_string
에 따라 타임스탬프의 형식을 지정합니다.
이 함수가 지원하는 형식 요소 목록은 TIMESTAMP에 지원되는 형식 요소를 참조하세요.
반환 데이터 유형
STRING
예시
SELECT FORMAT_TIMESTAMP("%c", TIMESTAMP "2008-12-25 15:30:00+00", "UTC") AS formatted;
+--------------------------+
| formatted |
+--------------------------+
| Thu Dec 25 15:30:00 2008 |
+--------------------------+
SELECT FORMAT_TIMESTAMP("%b-%d-%Y", TIMESTAMP "2008-12-25 15:30:00+00") AS formatted;
+-------------+
| formatted |
+-------------+
| Dec-25-2008 |
+-------------+
SELECT FORMAT_TIMESTAMP("%b %Y", TIMESTAMP "2008-12-25 15:30:00+00")
AS formatted;
+-------------+
| formatted |
+-------------+
| Dec 2008 |
+-------------+
PARSE_TIMESTAMP
PARSE_TIMESTAMP(format_string, timestamp_string[, timezone])
설명
타임스탬프의 문자열 표현을 TIMESTAMP
객체로 변환합니다.
format_string
에는 timestamp_string
형식을 지정하는 방법을 정의하는 형식 요소가 포함됩니다. timestamp_string
의 각 요소는 format_string
에 해당하는 요소가 있어야 합니다. format_string
에 있는 각 요소의 위치는 timestamp_string
에 있는 각 요소의 위치와 일치해야 합니다.
-- This works because elements on both sides match.
SELECT PARSE_TIMESTAMP("%a %b %e %I:%M:%S %Y", "Thu Dec 25 07:30:00 2008")
-- This doesn't work because the year element is in different locations.
SELECT PARSE_TIMESTAMP("%a %b %e %Y %I:%M:%S", "Thu Dec 25 07:30:00 2008")
-- This doesn't work because one of the year elements is missing.
SELECT PARSE_TIMESTAMP("%a %b %e %I:%M:%S", "Thu Dec 25 07:30:00 2008")
-- This works because %c can find all matching elements in timestamp_string.
SELECT PARSE_TIMESTAMP("%c", "Thu Dec 25 07:30:00 2008")
형식 문자열은 %a
, %A
, %g
, %G
, %j
, %P
, %u
, %U
, %V
, %w
, %W
를 제외한 대부분의 형식 요소를 완벽하게 지원합니다.
PARSE_TIMESTAMP
를 사용할 때는 다음 사항에 유의하세요.
- 미지정 필드. 지정되지 않은 필드는
1970-01-01 00:00:00.0
부터 초기화됩니다. 함수의 시간대 인수가 있으면 지정된 시간대가 이 초기화 값에 사용됩니다. 그렇지 않으면 초기화 값은 기본 시간대인 America/Los_Angeles를 사용합니다. 예를 들어 연도가 지정되지 않으면1970
이 기본값이 되고 나머지도 마찬가지입니다. - 대소문자를 구분하지 않는 이름.
Monday
,February
등의 이름은 대소문자를 구분하지 않습니다. - 공백. 형식 문자열에 하나 이상의 공백이 연달아 있는 경우는 날짜 문자열에 0개 이상의 공백이 연달아 있는 것과 같습니다. 또한 날짜 문자열의 선행 및 후행 공백은 형식 문자열에 없더라도 언제나 허용됩니다.
- 형식 우선순위. 2개(또는 그 이상)의 형식 요소에 겹치는 정보가 있을 경우(예:
%F
와%Y
가 모두 연도에 적용되는 경우), 일반적으로 마지막 요소가 앞의 요소보다 우선하며 몇 가지 예외가 있습니다(%s
,%C
,%y
설명 참조).
반환 데이터 유형
TIMESTAMP
예시
SELECT PARSE_TIMESTAMP("%c", "Thu Dec 25 07:30:00 2008") AS parsed;
-- Results may differ, depending upon the environment and time zone where this query was executed.
+------------------------+
| parsed |
+------------------------+
| 2008-12-25T15:30:00Z |
+------------------------+
TIMESTAMP_SECONDS
TIMESTAMP_SECONDS(int64_expression)
설명
int64_expression
을 1970-01-01 00:00:00 UTC 이후의 초 수로 해석합니다.
반환 데이터 유형
TIMESTAMP
예시
SELECT TIMESTAMP_SECONDS(1230219000) AS timestamp_value;
-- Results may differ, depending upon the environment and time zone where this query was executed.
+------------------------+
| timestamp_value |
+------------------------+
| 2008-12-25T15:30:00Z |
+------------------------+
TIMESTAMP_MILLIS
TIMESTAMP_MILLIS(int64_expression)
설명
int64_expression
을 1970-01-01 00:00:00 UTC 이후의 밀리초 수로 해석합니다.
반환 데이터 유형
TIMESTAMP
예시
SELECT TIMESTAMP_MILLIS(1230219000000) AS timestamp_value;
-- Results may differ, depending upon the environment and time zone where this query was executed.
+------------------------+
| timestamp_value |
+------------------------+
| 2008-12-25T15:30:00Z |
+------------------------+
TIMESTAMP_MICROS
TIMESTAMP_MICROS(int64_expression)
설명
int64_expression
을 1970-01-01 00:00:00 UTC 이후의 마이크로초 수로 해석합니다.
반환 데이터 유형
TIMESTAMP
예시
SELECT TIMESTAMP_MICROS(1230219000000000) AS timestamp_value;
-- Results may differ, depending upon the environment and time zone where this query was executed.
+------------------------+
| timestamp_value |
+------------------------+
| 2008-12-25T15:30:00Z |
+------------------------+
UNIX_SECONDS
UNIX_SECONDS(timestamp_expression)
설명
1970-01-01 00:00:00 UTC 이후의 초 수를 반환합니다. 나머지 단위는 자릅니다.
반환 데이터 유형
INT64
예시
SELECT UNIX_SECONDS(TIMESTAMP "2008-12-25 15:30:00+00") AS seconds;
+------------+
| seconds |
+------------+
| 1230219000 |
+------------+
UNIX_MILLIS
UNIX_MILLIS(timestamp_expression)
설명
1970-01-01 00:00:00 UTC 이후의 밀리초 수를 반환합니다. 나머지 단위는 자릅니다.
반환 데이터 유형
INT64
예시
SELECT UNIX_MILLIS(TIMESTAMP "2008-12-25 15:30:00+00") AS millis;
+---------------+
| millis |
+---------------+
| 1230219000000 |
+---------------+
UNIX_MICROS
UNIX_MICROS(timestamp_expression)
설명
1970-01-01 00:00:00 UTC 이후의 마이크로초 수를 반환합니다. 나머지 단위는 자릅니다.
반환 데이터 유형
INT64
예시
SELECT UNIX_MICROS(TIMESTAMP "2008-12-25 15:30:00+00") AS micros;
+------------------+
| micros |
+------------------+
| 1230219000000000 |
+------------------+
PENDING_COMMIT_TIMESTAMP
PENDING_COMMIT_TIMESTAMP()
설명
DML INSERT
또는 UPDATE
문에서 PENDING_COMMIT_TIMESTAMP()
함수를 사용하여 대기 중인 커밋 타임스탬프, 즉 커밋 시 쓰기의 커밋 타임스탬프를 유형 TIMESTAMP
의 열에 입력합니다.
Cloud Spanner SQL은 트랜잭션이 커밋될 때 커밋 타임스탬프를 선택합니다. PENDING_COMMIT_TIMESTAMP
함수는 적절하게 유형이 지정된 열의 INSERT 또는 UPDATE 값으로만 사용할 수 있습니다. 이 함수를 SELECT에서 사용하거나 다른 스칼라 표현식의 입력으로 사용할 수 없습니다.
반환 데이터 유형
TIMESTAMP
예시
다음 DML 문은 Singers 테이블의 LastUpdated
열을 커밋 타임스탬프로 업데이트합니다.
UPDATE Performances SET LastUpdated = PENDING_COMMIT_TIMESTAMP()
WHERE SingerId=1 AND VenueId=2 AND EventDate="2015-10-21"
TIMESTAMP에 지원되는 형식 요소
달리 명시되지 않는 한, 형식 문자열을 사용하는 TIMESTAMP 함수는 다음 요소를 지원합니다.
형식 요소 | 설명 |
%A | 요일 이름입니다. |
%a | 요일 이름의 약어입니다. |
%B | 월 이름입니다. |
%b 또는 %h | 월 이름의 약어입니다. |
%C | 10진수(00~99)로 표현한 세기(연도를 100으로 나누어 정수로 자른 것)입니다. |
%c | %a %b %e %T %Y 형식의 날짜 및 시간 표현입니다. |
%D | %m/%d/%y 형식으로 표현한 날짜입니다. |
%d | 한 달의 일을 10진수(01~31)로 표현한 것입니다. |
%e | 한 달의 일을 10진수(1~31)로 표현한 것입니다. 한 자릿수 앞에는 공백이 옵니다. |
%F | %Y-%m-%d 형식으로 표현한 날짜입니다. |
%G | ISO 8601 연도를 세기와 함께 10진수로 표현한 것입니다. 각 ISO 연도는 태양력 연도의 첫 번째 목요일 전 월요일에 시작됩니다. 그레고리력 연도와 ISO 연도가 달라질 수 있는 그레고리력 연도 경계 근처에서 %G와 %Y가 서로 다른 결과를 생성할 수 있습니다. |
%g | ISO 8601 연도를 세기 없이 10진수(00~99)로 표현한 것입니다. 각 ISO 연도는 태양력 연도의 첫 번째 목요일 전 월요일에 시작됩니다. 태양력 연도와 ISO 연도가 달라질 수 있는 그레고리력 연도 경계 근처에서 %g와 %y가 서로 다른 결과를 생성할 수 있습니다. |
%H | 시간(24시간제)을 10진수(00~23)로 표현한 것입니다. |
%I | 시간(12시간제)을 10진수(01~12)로 표현한 것입니다. |
%j | 한 해의 일을 10진수(001~366)로 표현한 것입니다. |
%k | 시간(24시간제)을 10진수(0~23)로 표현한 것입니다. 한 자릿수 앞에는 공백이 옵니다. |
%l | 시간(12시간제)을 10진수(1~12)로 표현한 것입니다. 한 자릿수 앞에는 공백이 옵니다. |
%M | 분을 10진수(00~59)로 표현한 것입니다. |
%m | 월을 10진수(01~12)로 표현한 것입니다. |
%n | 줄바꿈 문자입니다. |
%P | am 또는 pm입니다. |
%p | AM 또는 PM입니다. |
%R | %H:%M 형식으로 표현한 시간입니다. |
%r | AM/PM 표기법을 사용한 12시간제 시간입니다. |
%S | 초를 10진수(00~60)로 표현한 것입니다. |
%s | 1970-01-01 00:00:00 UTC 이후의 초 수입니다. 문자열에서 %s가 나타나는 위치에 상관없이 항상 다른 모든 형식 요소보다 우선합니다. 여러 개의 %s 요소가 나타날 경우, 마지막 요소가 우선합니다. |
%T | %H:%M:%S 형식으로 표현한 시간입니다. |
%t | 탭 문자입니다. |
%U | 한 해의 주 번호(일요일이 일주일의 첫 번째 날임)를 10진수(00~53)로 표현한 것입니다. |
%u | 요일(월요일이 일주일의 첫 번째 날임)을 10진수(1~7)로 표현한 것입니다. |
%V | ISO 8601 한 해의 주 번호(월요일이 일주일의 첫 번째 날임)를 10진수(01~53)로 표현한 것입니다. 새해에 1월 1일이 포함된 주의 일수가 4일 이상인 경우, 그 주가 첫 번째 주이고, 그렇지 않은 경우에는 그 주가 이전 연도의 53번째 주이고 그 다음 주가 첫 번째 주입니다. |
%W | 한 해의 주 번호(월요일이 일주일의 첫 번째 날임)를 10진수(00~53)로 표현한 것입니다. |
%w | 요일(일요일이 일주일의 첫 번째 날임)을 10진수(0~6)로 표현한 것입니다. |
%X | 시간을 HH:MM:SS 형식으로 표현한 것입니다. |
%x | 날짜를 MM/DD/YY 형식으로 표현한 것입니다. |
%Y | 연도를 세기와 함께 10진수로 표현한 것입니다. |
%y | 연도를 세기 없이 10진수(00~99)로 표현한 것입니다. 앞의 0 표기 여부는 선택할 수 있습니다. %C와 함께 사용할 수 있습니다. %C를 지정하지 않으면, 00~68년은 2000년대이고 69~99년은 1900년대입니다. |
%Z | 시간대 이름입니다. |
%z | +HHMM 또는 -HHMM 형식에서 본초자오선을 기준으로 한 오프셋입니다. 양의 값은 그리니치 동쪽 지역을 나타냅니다. |
%% | 단일 % 문자입니다. |
%Ez | RFC 3339 호환 숫자 시간대입니다(+HH:MM 또는 -HH:MM). |
%E#S | 초를 #자리 소수의 정밀도로 표현한 것입니다. |
%E*S | 초를 전체 소수 자릿수로 표현한 것입니다(리터럴 '*'). |
%E4Y | 4자릿수 연도(0001~9999). %Y는 연도를 완전히 렌더링하는 데 필요한 만큼의 문자 수를 생성하니 유의하세요. |
시간대 정의
특정 날짜 및 타임스탬프 함수를 사용하면 기본 시간대를 재정의하여 다른 시간대를 지정할 수 있습니다. 시간대 이름(예: America/Los_Angeles
) 또는 UTC로부터의 시간대 오프셋(예: -08) 중 하나를 제공하여 시간대를 지정할 수 있습니다.
시간대 오프셋을 사용하는 경우 다음 형식을 사용합니다.
(+|-)H[H][:M[M]]
지정된 날짜 및 시간에 America/Los_Angeles
의 시간대 오프셋이 -08
이므로 다음 타임스탬프는 동일합니다.
SELECT UNIX_MILLIS(TIMESTAMP "2008-12-25 15:30:00 America/Los_Angeles") as millis;
SELECT UNIX_MILLIS(TIMESTAMP "2008-12-25 15:30:00-08:00") as millis;
Net 함수
NET.IP_FROM_STRING
NET.IP_FROM_STRING(addr_str)
설명
IPv4 또는 IPv6 주소를 텍스트(STRING) 형식에서 네트워크 바이트 순서의 이진(BYTES) 형식으로 변환합니다.
이 함수는 addr_str
에 다음 형식을 지원합니다.
- IPv4: 점으로 구분된 네 자리 형식.
10.1.2.3
). - IPv6: 콜론으로 구분된 형식.
1234:5678:90ab:cdef:1234:5678:90ab:cdef
). 더 많은 예시는 IP 버전 6 주소 지정 아키텍처를 참조하세요.
이 함수는 10.1.2.3/32
와 같은 CIDR 표기법을 지원하지 않습니다.
이 함수는 NULL
입력을 받으면 NULL
을 반환합니다. 입력이 잘못된 것으로 간주되는 경우 OUT_OF_RANGE
오류가 발생합니다.
반환 데이터 유형
BYTES
예시
SELECT
addr_str, FORMAT("%T", NET.IP_FROM_STRING(addr_str)) AS ip_from_string
FROM UNNEST([
'48.49.50.51',
'::1',
'3031:3233:3435:3637:3839:4041:4243:4445',
'::ffff:192.0.2.128'
]) AS addr_str;
addr_str | ip_from_string |
---|---|
48.49.50.51 | b"0123" |
::1 | b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01" |
3031:3233:3435:3637:3839:4041:4243:4445 | b"0123456789@ABCDE" |
::ffff:192.0.2.128 | b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xc0\x00\x02\x80" |
NET.SAFE_IP_FROM_STRING
NET.SAFE_IP_FROM_STRING(addr_str)
설명
NET.IP_FROM_STRING
과 비슷하지만 입력이 유효하지 않으면 오류를 생성하지 않고 NULL
을 반환합니다.
반환 데이터 유형
BYTES
예시
SELECT
addr_str,
FORMAT("%T", NET.SAFE_IP_FROM_STRING(addr_str)) AS safe_ip_from_string
FROM UNNEST([
'48.49.50.51',
'::1',
'3031:3233:3435:3637:3839:4041:4243:4445',
'::ffff:192.0.2.128',
'48.49.50.51/32',
'48.49.50',
'::wxyz'
]) AS addr_str;
addr_str | safe_ip_from_string |
---|---|
48.49.50.51 | b"0123" |
::1 | b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01" |
3031:3233:3435:3637:3839:4041:4243:4445 | b"0123456789@ABCDE" |
::ffff:192.0.2.128 | b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xc0\x00\x02\x80" |
48.49.50.51/32 | NULL |
48.49.50 | NULL |
::wxyz | NULL |
NET.IP_TO_STRING
NET.IP_TO_STRING(addr_bin)
설명 IPv4 또는 IPv6 주소를 네트워크 바이트 순서의 이진(BYTES) 형식에서 텍스트(STRING) 형식으로 변환합니다.
입력이 4바이트면 이 함수는 IPv4 주소를 STRING으로 반환하고, 입력이 16바이트면 IPv6 주소를 STRING으로 반환합니다.
이 함수는 NULL
입력을 받으면 NULL
을 반환합니다. 입력의 길이가 4 또는 16과 다를 경우, OUT_OF_RANGE
오류가 발생합니다.
반환 데이터 유형
STRING
예시
SELECT FORMAT("%T", x) AS addr_bin, NET.IP_TO_STRING(x) AS ip_to_string
FROM UNNEST([
b"0123",
b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01",
b"0123456789@ABCDE",
b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xc0\x00\x02\x80"
]) AS x;
addr_bin | ip_to_string |
---|---|
b"0123" | 48.49.50.51 |
b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01" | ::1 |
b"0123456789@ABCDE" | 3031:3233:3435:3637:3839:4041:4243:4445 |
b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xc0\x00\x02\x80" | ::ffff:192.0.2.128 |
NET.IP_NET_MASK
NET.IP_NET_MASK(num_output_bytes, prefix_length)
설명
네트워크 마스크, 즉 길이가 num_output_bytes
와 동일한 바이트 시퀀스를 반환합니다. 여기서 첫 prefix_length
비트는 1로 설정되고 다른 비트는 0으로 설정됩니다. num_output_bytes
와 prefix_length
는 INT64입니다.
이 함수는 num_output_bytes
가 4(IPv4인 경우) 또는 16(IPv6인 경우)이 아니면 오류를 생성합니다. 또한 prefix_length
가 음수이거나 8 * num_output_bytes
보다 커도 오류가 발생합니다.
반환 데이터 유형
BYTES
예시
SELECT x, y, FORMAT("%T", NET.IP_NET_MASK(x, y)) AS ip_net_mask
FROM UNNEST([
STRUCT(4 as x, 0 as y),
(4, 20),
(4, 32),
(16, 0),
(16, 1),
(16, 128)
]);
x | y | ip_net_mask |
---|---|---|
4 | 0 | b"\x00\x00\x00\x00" |
4 | 20 | b"\xff\xff\xf0\x00" |
4 | 32 | b"\xff\xff\xff\xff" |
16 | 0 | b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" |
16 | 1 | b"\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" |
16 | 128 | b"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" |
NET.IP_TRUNC
NET.IP_TRUNC(addr_bin, prefix_length)
설명
네트워크 바이트 순서로 된 바이너리(BYTES) 형식의 IPv4 또는 IPv6 주소인 addr_bin
을 취해 같은 형식의 서브넷 주소를 반환합니다. 결과는 addr_bin
과 길이가 같습니다. 여기서 첫 prefix_length
비트는 addr_bin
의 비트와 같고 나머지 비트는 0입니다.
LENGTH(addr_bin)
가 4 또는 16이 아니거나 prefix_len
이 음수이거나 LENGTH(addr_bin) * 8
보다 큰 경우, 이 함수는 오류를 생성합니다.
반환 데이터 유형
BYTES
예시
SELECT
FORMAT("%T", x) as addr_bin, prefix_length,
FORMAT("%T", NET.IP_TRUNC(x, prefix_length)) AS ip_trunc
FROM UNNEST([
STRUCT(b"\xAA\xBB\xCC\xDD" as x, 0 as prefix_length),
(b"\xAA\xBB\xCC\xDD", 11), (b"\xAA\xBB\xCC\xDD", 12),
(b"\xAA\xBB\xCC\xDD", 24), (b"\xAA\xBB\xCC\xDD", 32),
(b'0123456789@ABCDE', 80)
]);
addr_bin | prefix_length | ip_trunc |
---|---|---|
b"\xaa\xbb\xcc\xdd" | 0 | b"\x00\x00\x00\x00" |
b"\xaa\xbb\xcc\xdd" | 11 | b"\xaa\xa0\x00\x00" |
b"\xaa\xbb\xcc\xdd" | 12 | b"\xaa\xb0\x00\x00" |
b"\xaa\xbb\xcc\xdd" | 24 | b"\xaa\xbb\xcc\x00" |
b"\xaa\xbb\xcc\xdd" | 32 | b"\xaa\xbb\xcc\xdd" |
b"0123456789@ABCDE" | 80 | b"0123456789\x00\x00\x00\x00\x00\x00" |
NET.IPV4_FROM_INT64
NET.IPV4_FROM_INT64(integer_value)
설명
IPv4 주소를 정수 형식에서 네트워크 바이트 순서의 이진(BYTES) 형식으로 변환합니다. 정수 입력에서 IP 주소의 최하위 비트는 호스트 또는 클라이언트 아키텍처에 상관없이 정수의 최하위 비트에 저장됩니다. 예를 들어 1
은 0.0.0.1
을 뜻하며, 0x1FF
는 0.0.1.255
를 뜻합니다.
이 함수는 모든 최상위 32비트가 0인지 또는 모든 최상위 33비트가 1인지(32비트 정수에서 부호 확장) 검사합니다.
다시 말해 입력이 [-0x80000000, 0xFFFFFFFF]
범위에 있어야 하며, 그렇지 않으면 이 함수는 오류를 생성합니다.
이 함수는 IPv6를 지원하지 않습니다.
반환 데이터 유형
BYTES
예시
SELECT x, x_hex, FORMAT("%T", NET.IPV4_FROM_INT64(x)) AS ipv4_from_int64
FROM (
SELECT CAST(x_hex AS INT64) x, x_hex
FROM UNNEST(["0x0", "0xABCDEF", "0xFFFFFFFF", "-0x1", "-0x2"]) AS x_hex
);
x | x_hex | ipv4_from_int64 |
---|---|---|
0 | 0x0 | b"\x00\x00\x00\x00" |
11259375 | 0xABCDEF | b"\x00\xab\xcd\xef" |
4294967295 | 0xFFFFFFFF | b"\xff\xff\xff\xff" |
-1 | -0x1 | b"\xff\xff\xff\xff" |
-2 | -0x2 | b"\xff\xff\xff\xfe" |
NET.IPV4_TO_INT64
NET.IPV4_TO_INT64(addr_bin)
설명
IPv4 주소를 네트워크 바이트 순서의 이진(BYTES) 형식에서 정수 형식으로 변환합니다. 정수 출력에서 IP 주소의 최하위 비트는 호스트 또는 클라이언트 아키텍처에 상관없이 정수의 최하위 비트에 저장됩니다. 예를 들어 1
은 0.0.0.1
을 뜻하며, 0x1FF
는 0.0.1.255
를 뜻합니다. 출력은 [0, 0xFFFFFFFF]
범위 이내입니다.
입력 길이가 4가 아니면 이 함수는 오류를 생성합니다.
이 함수는 IPv6를 지원하지 않습니다.
반환 데이터 유형
INT64
예시
SELECT
FORMAT("%T", x) AS addr_bin,
FORMAT("0x%X", NET.IPV4_TO_INT64(x)) AS ipv4_to_int64
FROM
UNNEST([b"\x00\x00\x00\x00", b"\x00\xab\xcd\xef", b"\xff\xff\xff\xff"]) AS x;
addr_bin | ipv4_to_int64 |
---|---|
b"\x00\x00\x00\x00" | 0x0 |
b"\x00\xab\xcd\xef" | 0xABCDEF |
b"\xff\xff\xff\xff" | 0xFFFFFFFF |
NET.HOST
NET.HOST(url)
설명
URL을 STRING으로 취해 호스트를 STRING으로 반환합니다. 최상의 결과를 위해서는 URL 값이 RFC 3986에 정의된 형식을 준수해야 합니다. URL 값이 RFC 3986 형식 지정을 준수하지 않는 경우, 이 함수는 입력을 파싱하여 관련된 결과를 반환하기 위해 최선을 다합니다. 함수에서 입력을 파싱하지 못할 경우 NULL을 반환합니다.
참고: 이 함수는 정규화를 수행하지 않습니다.
반환 데이터 유형
STRING
예시
SELECT
FORMAT("%T", input) AS input,
description,
FORMAT("%T", NET.HOST(input)) AS host,
FORMAT("%T", NET.PUBLIC_SUFFIX(input)) AS suffix,
FORMAT("%T", NET.REG_DOMAIN(input)) AS domain
FROM (
SELECT "" AS input, "invalid input" AS description
UNION ALL SELECT "http://abc.xyz", "standard URL"
UNION ALL SELECT "//user:password@a.b:80/path?query",
"standard URL with relative scheme, port, path and query, but no public suffix"
UNION ALL SELECT "https://[::1]:80", "standard URL with IPv6 host"
UNION ALL SELECT "http://例子.卷筒纸.中国", "standard URL with internationalized domain name"
UNION ALL SELECT " www.Example.Co.UK ",
"non-standard URL with spaces, upper case letters, and without scheme"
UNION ALL SELECT "mailto:?to=&subject=&body=", "URI rather than URL--unsupported"
);
input | description | host | suffix | domain |
---|---|---|---|---|
"" | invalid input | NULL | NULL | NULL |
"http://abc.xyz" | standard URL | "abc.xyz" | "xyz" | "abc.xyz" |
"//user:password@a.b:80/path?query" | 상대 스키마, 포트, 경로, 쿼리는 있지만 공개 서픽스는 없는 표준 URL | "a.b" | NULL | NULL |
"https://[::1]:80" | IPv6 호스트가 있는 표준 URL | "[::1]" | NULL | NULL |
"http://例子.卷筒纸.中国" | 국제화된 도메인 이름이 있는 표준 URL | "例子.卷筒纸.中国" | "中国" | "卷筒纸.中国" |
" www.Example.Co.UK " | 공백과 대문자가 있고 스키마는 없는 비표준 URL | "www.Example.Co.UK" | "Co.UK" | "Example.Co.UK" |
"mailto:?to=&subject=&body=" | URL이 아니라 URI -- 지원되지 않음 | "mailto" | NULL | NULL |
NET.PUBLIC_SUFFIX
NET.PUBLIC_SUFFIX(url)
설명
URL을 STRING으로 취해 공개 서픽스(예: com
, org
, net
)를 STRING으로 반환합니다. 공개 서픽스는 publicsuffix.org에 등록된 ICANN 도메인입니다. 최상의 결과를 위해서는 URL 값이 RFC 3986에 정의된 형식을 준수해야 합니다. URL 값이 RFC 3986 형식 지정을 준수하지 않는 경우, 이 함수는 입력을 파싱하여 관련된 결과를 반환하기 위해 최선을 다합니다.
이 함수는 다음 중 어느 하나라도 참인 경우 NULL을 반환합니다.
- 입력에서 호스트를 파싱할 수 없습니다.
- 파싱된 호스트의 중간에(선행 또는 후행이 아니라) 인접한 점이 포함되어 있습니다.
- 파싱된 호스트에 공개 서픽스가 포함되어 있지 않습니다.
이 함수는 공개 서픽스를 찾기 전에 대문자를 소문자로 변환하고 모든 비 ASCII 문자를 Punycode로 인코딩하여 호스트를 임시로 정규화합니다. 그런 다음 정규화된 호스트 대신 원본 호스트의 일부로 공개 서픽스를 반환합니다.
참고: 이 함수는 유니코드 정규화를 수행하지 않습니다.
참고: publicsuffix.org에 있는 공개 서픽스 데이터에는 비공개 도메인도 포함되어 있습니다. 이 함수는 비공개 도메인을 무시합니다.
참고: 공개 서픽스 데이터는 시간이 지나면 변경될 수 있습니다. 따라서 지금은 NULL 결과를 생성하는 입력이 이후에는 NULL이 아닌 값을 생성할 수도 있습니다.
반환 데이터 유형
STRING
예시
SELECT
FORMAT("%T", input) AS input,
description,
FORMAT("%T", NET.HOST(input)) AS host,
FORMAT("%T", NET.PUBLIC_SUFFIX(input)) AS suffix,
FORMAT("%T", NET.REG_DOMAIN(input)) AS domain
FROM (
SELECT "" AS input, "invalid input" AS description
UNION ALL SELECT "http://abc.xyz", "standard URL"
UNION ALL SELECT "//user:password@a.b:80/path?query",
"standard URL with relative scheme, port, path and query, but no public suffix"
UNION ALL SELECT "https://[::1]:80", "standard URL with IPv6 host"
UNION ALL SELECT "http://例子.卷筒纸.中国", "standard URL with internationalized domain name"
UNION ALL SELECT " www.Example.Co.UK ",
"non-standard URL with spaces, upper case letters, and without scheme"
UNION ALL SELECT "mailto:?to=&subject=&body=", "URI rather than URL--unsupported"
);
input | description | host | suffix | domain |
---|---|---|---|---|
"" | invalid input | NULL | NULL | NULL |
"http://abc.xyz" | standard URL | "abc.xyz" | "xyz" | "abc.xyz" |
"//user:password@a.b:80/path?query" | 상대 스키마, 포트, 경로, 쿼리는 있지만 공개 서픽스는 없는 표준 URL | "a.b" | NULL | NULL |
"https://[::1]:80" | IPv6 호스트가 있는 표준 URL | "[::1]" | NULL | NULL |
"http://例子.卷筒纸.中国" | 국제화된 도메인 이름이 있는 표준 URL | "例子.卷筒纸.中国" | "中国" | "卷筒纸.中国" |
" www.Example.Co.UK " | 공백과 대문자가 있고 스키마는 없는 비표준 URL | "www.Example.Co.UK" | "Co.UK" | "Example.Co.UK |
"mailto:?to=&subject=&body=" | URL이 아니라 URI -- 지원되지 않음 | "mailto" | NULL | NULL |
NET.REG_DOMAIN
NET.REG_DOMAIN(url)
설명
URL을 STRING으로 취해 등록되어 있거나 등록 가능한 도메인(공개 서픽스 더하기 앞의 라벨 한 개)을 STRING으로 반환합니다. 최상의 결과를 위해서는 URL 값이 RFC 3986에 정의된 형식을 준수해야 합니다. URL 값이 RFC 3986 형식 지정을 준수하지 않는 경우, 이 함수는 입력을 파싱하여 관련된 결과를 반환하기 위해 최선을 다합니다.
이 함수는 다음 중 어느 하나라도 참인 경우 NULL을 반환합니다.
- 입력에서 호스트를 파싱할 수 없습니다.
- 파싱된 호스트의 중간에(선행 또는 후행이 아니라) 인접한 점이 포함되어 있습니다.
- 파싱된 호스트에 공개 서픽스가 포함되어 있지 않습니다.
- 파싱된 호스트가 앞에 라벨이 없는 공개 서픽스만 포함합니다.
이 함수는 공개 서픽스를 찾기 전에 대문자를 소문자로 변환하고 모든 비 ASCII 문자를 Punycode로 인코딩하여 호스트를 임시로 정규화합니다. 그런 다음 정규화된 호스트 대신 원본 호스트의 일부로 등록되어 있거나 등록 가능한 도메인을 반환합니다.
참고: 이 함수는 유니코드 정규화를 수행하지 않습니다.
참고: publicsuffix.org에 있는 공개 서픽스 데이터에는 비공개 도메인도 포함되어 있습니다. 이 함수는 비공개 도메인을 공개 서픽스로 취급하지 않습니다. 예를 들어 "us.com"이 공개 서픽스 데이터에 있는 비공개 도메인인 경우, NET.REG_DOMAIN("foo.us.com")은 "foo.us.com"(비공개 도메인 "us.com" 더하기 앞의 라벨 "foo")이 아니라 "us.com"(공개 서픽스 "com" 더하기 앞의 라벨 "us")을 반환합니다.
참고: 공개 서픽스 데이터는 시간이 지나면 변경될 수 있습니다. 따라서 지금은 NULL 결과를 생성하는 입력이 이후에는 NULL이 아닌 값을 생성할 수도 있습니다.
반환 데이터 유형
STRING
예시
SELECT
FORMAT("%T", input) AS input,
description,
FORMAT("%T", NET.HOST(input)) AS host,
FORMAT("%T", NET.PUBLIC_SUFFIX(input)) AS suffix,
FORMAT("%T", NET.REG_DOMAIN(input)) AS domain
FROM (
SELECT "" AS input, "invalid input" AS description
UNION ALL SELECT "http://abc.xyz", "standard URL"
UNION ALL SELECT "//user:password@a.b:80/path?query",
"standard URL with relative scheme, port, path and query, but no public suffix"
UNION ALL SELECT "https://[::1]:80", "standard URL with IPv6 host"
UNION ALL SELECT "http://例子.卷筒纸.中国", "standard URL with internationalized domain name"
UNION ALL SELECT " www.Example.Co.UK ",
"non-standard URL with spaces, upper case letters, and without scheme"
UNION ALL SELECT "mailto:?to=&subject=&body=", "URI rather than URL--unsupported"
);
input | description | host | suffix | domain |
---|---|---|---|---|
"" | invalid input | NULL | NULL | NULL |
"http://abc.xyz" | standard URL | "abc.xyz" | "xyz" | "abc.xyz" |
"//user:password@a.b:80/path?query" | 상대 스키마, 포트, 경로, 쿼리는 있지만 공개 서픽스는 없는 표준 URL | "a.b" | NULL | NULL |
"https://[::1]:80" | IPv6 호스트가 있는 표준 URL | "[::1]" | NULL | NULL |
"http://例子.卷筒纸.中国" | 국제화된 도메인 이름이 있는 표준 URL | "例子.卷筒纸.中国" | "中国" | "卷筒纸.中国" |
" www.Example.Co.UK " | 공백과 대문자가 있고 스키마는 없는 비표준 URL | "www.Example.Co.UK" | "Co.UK" | "Example.Co.UK" |
"mailto:?to=&subject=&body=" | URL이 아니라 URI -- 지원되지 않음 | "mailto" | NULL | NULL |
연산자
연산자는 특수문자나 키워드로 표현되며 함수 호출 구문을 사용하지 않습니다. 연산자는 피연산자라고도 불리는 임의 수의 데이터 입력을 조작하여 결과를 반환합니다.
일반 규칙:
- 달리 명시되지 않는 한, 피연산자 중 하나가
NULL
이면 모든 연산자가NULL
을 반환합니다. - 계산 결과가 오버플로인 경우 모든 연산자가 오류를 생성합니다.
- 모든 부동 소수점 연산에서
+/-inf
와NaN
은 피연산자 중 하나가+/-inf
또는NaN
일 때만 반환될 수 있습니다. 그 이외의 경우에는 오류가 반환됩니다.
다음 표는 모든 Cloud Spanner SQL 연산자를 우선순위(즉, 문 내에서 평가되는 순서)대로 나열한 것입니다.
우선순위 | 연산자 | 입력 데이터 유형 | 이름 | 연산자 항 |
---|---|---|---|---|
1 | . | STRUCT |
멤버 필드 액세스 연산자 | 이항 |
[ ] | ARRAY | 배열 위치. OFFSET 또는 ORDINAL과 함께 사용해야 함. ARRAY 함수 참조. | 이항 | |
2 | - | 모든 숫자 유형 | 단항 뺄셈 | 단항 |
~ | 정수 또는 BYTES | 비트 NOT | 단항 | |
3 | * | 모든 숫자 유형 | 곱셈 | 이항 |
/ | 모든 숫자 유형 | 나눗셈 | 이항 | |
|| | STRING, BYTES, ARRAY<T> | 연결 연산자 | 이항 | |
4 | + | 모든 숫자 유형 | 덧셈 | 이항 |
- | 모든 숫자 유형 | 뺄셈 | 이항 | |
5 | << | 정수 또는 BYTES | 비트 왼쪽 시프트 | 이항 |
>> | 정수 또는 BYTES | 비트 오른쪽 시프트 | 이항 | |
6 | & | 정수 또는 BYTES | 비트 AND | 이항 |
7 | ^ | 정수 또는 BYTES | 비트 XOR | 이항 |
8 | | | 정수 또는 BYTES | 비트 OR | 이항 |
9(비교 연산자) | = | 비교 가능한 모든 유형. 전체 목록은 데이터 유형을 참조하세요. | 같음 | 이항 |
< | 비교 가능한 모든 유형. 전체 목록은 데이터 유형을 참조하세요. | 미만 | 이항 | |
> | 비교 가능한 모든 유형. 전체 목록은 데이터 유형을 참조하세요. | 초과 | 이항 | |
<= | 비교 가능한 모든 유형. 전체 목록은 데이터 유형을 참조하세요. | 이하 | 이항 | |
>= | 비교 가능한 모든 유형. 전체 목록은 데이터 유형을 참조하세요. | 이상 | 이항 | |
!=, <> | 비교 가능한 모든 유형. 전체 목록은 데이터 유형을 참조하세요. | 같지 않음 | 이항 | |
[NOT] LIKE | STRING 및 바이트 | 지정한 패턴과 일치하지 [않는] 값 | 이항 | |
[NOT] BETWEEN | 비교 가능한 모든 유형. 전체 목록은 데이터 유형을 참조하세요. | 지정한 범위 내에 있지 [않은] 값 | 이항 | |
[NOT] IN | 비교 가능한 모든 유형. 전체 목록은 데이터 유형을 참조하세요. | 지정한 값의 집합에 있지 [않은] 값 | 이항 | |
IS [NOT] NULL |
전체 | 값이 NULL 이 [아님] |
단항 | |
IS [NOT] TRUE | BOOL | 값이 TRUE가 [아님]. | 단항 | |
IS [NOT] FALSE | BOOL | 값이 FALSE가 [아님]. | 단항 | |
10 | NOT | BOOL | 논리 부정 | 단항 |
11 | AND | BOOL | 논리곱 | 이항 |
12 | OR | BOOL | 논리합 | 이항 |
우선순위가 같은 연산자는 결합된 상태로 유지됩니다. 즉, 이러한 연산자는 그룹화되어 왼쪽에서 시작해서 오른쪽으로 이동합니다. 예를 들어 표현식은 다음과 같습니다.
x AND y AND z
위 표현식의 해석 결과는 다음과 같습니다.
( ( x AND y ) AND z )
표현식:
x * y / z
위 표현식의 해석 결과는 다음과 같습니다.
( ( x * y ) / z )
모든 비교 연산자는 우선순위가 동일하지만 서로 연결되지 않습니다. 따라서 모호해지지 않도록 괄호를 사용해야 합니다. 예를 들면 다음과 같습니다.
(x < y) IS FALSE
요소 액세스 연산자
연산자 | 구문 | 입력 데이터 유형 | 결과 데이터 유형 | 설명 |
---|---|---|---|---|
. | expression.fieldname1... | STRUCT |
fieldname1에 저장된 유형 T | 점 연산자입니다. 중첩 필드에 액세스하는 데 사용할 수 있습니다(예: e.g.expression.fieldname1.fieldname2...). |
[ ] | array_expression [position_keyword (int_expression ) ] | ARRAY 함수를 참조하세요. | ARRAY에 저장된 유형 T | position_keyword는 OFFSET 또는 ORDINAL입니다. 이 연산자를 사용하는 두 함수에 대해서는 ARRAY 함수를 참조하세요. |
산술 연산자
모든 산술 연산자는 숫자 유형 T의 입력을 허용하며 결과 유형은 아래의 설명에서 달리 명시하지 않는 한 유형 T에 해당합니다.
이름 | 구문 |
---|---|
덧셈 | X + Y |
뺄셈 | X - Y |
곱셈 | X * Y |
나눗셈 | X / Y |
단항 뺄셈 | - X |
참고: 0으로 나누는 연산은 오류를 반환합니다. 다른 결과를 반환하려면 IEEE_DIVIDE 또는 SAFE_DIVIDE 함수를 사용해 보세요.
덧셈과 곱셈의 결과 유형:
입력 | INT64 | NUMERIC | FLOAT64 |
---|---|---|---|
INT64 | INT64 | NUMERIC | FLOAT64 |
NUMERIC | NUMERIC | NUMERIC | FLOAT64 |
FLOAT64 | FLOAT64 | FLOAT64 | FLOAT64 |
나눗셈의 결과 유형:
입력 | INT64 | NUMERIC | FLOAT64 |
---|---|---|---|
INT64 | FLOAT64 | NUMERIC | FLOAT64 |
NUMERIC | NUMERIC | NUMERIC | FLOAT64 |
FLOAT64 | FLOAT64 | FLOAT64 | FLOAT64 |
단항 뺄셈의 결과 유형:
입력 | INT64 | NUMERIC | FLOAT64 |
---|---|---|---|
출력 | INT64 | NUMERIC | FLOAT64 |
비트 연산자
모든 비트 연산자는 첫 번째 피연산자와 동일한 유형과 동일한 길이를 반환합니다.
이름 | 구문 | 입력 데이터 유형 | 설명 |
---|---|---|---|
비트 NOT | ~ X | 정수 또는 BYTES | 각 비트에 대해 논리 부정을 수행하며 주어진 2진수 값의 여집합을 형성합니다. |
비트 OR | X | Y | X: 정수 또는 BYTES Y: X와 동일한 유형 |
길이가 같은 비트 패턴 두 개를 취하며 해당 비트의 각 쌍에 포괄적 논리합 연산을 수행합니다. 이 연산자는 X와 Y의 BYTES 길이가 다른 경우 오류를 생성합니다. |
비트 XOR | X ^ Y | X: 정수 또는 BYTES Y: X와 동일한 유형 |
길이가 같은 비트 패턴 두 개를 취하며 해당 비트의 각 쌍에 배타적 논리합 연산을 수행합니다. 이 연산자는 X와 Y의 BYTES 길이가 다른 경우 오류를 생성합니다. |
비트 AND | X & Y | X: 정수 또는 BYTES Y: X와 동일한 유형 |
길이가 같은 비트 패턴 두 개를 취하며 해당 비트의 각 쌍에 논리곱 연산을 수행합니다. 이 연산자는 X와 Y의 BYTES 길이가 다른 경우 오류를 생성합니다. |
왼쪽 시프트 | X << Y | X: 정수 또는 BYTES
Y: INT64 |
첫 번째 피연산자 X를 왼쪽으로 옮깁니다. 이 연산자는 두 번째 피연산자 Y가 첫 번째 피연산자 X의 비트 길이보다 크거나 같으면 0 또는 바이트 시퀀스 b'\x00'을 반환합니다(예: X에 유형 INT64가 있으면 64). 이 연산자는 Y가 음수이면 오류를 생성합니다. |
오른쪽 시프트 | X >> Y | X: 정수 또는 BYTES
Y: INT64 |
첫 번째 피연산자 X를 오른쪽으로 옮깁니다. 이 연산자는 부호가 있는 유형으로 부호 비트 확장을 수행하지 않습니다(즉, 왼쪽에 비어 있는 비트를 0으로 채움). 이 연산자는 두 번째 피연산자 Y가 첫 번째 피연산자 X의 비트 길이보다 크거나 같으면 0 또는 바이트 시퀀스 b'\x00'을 반환합니다(예: X에 유형 INT64가 있으면 64). 이 연산자는 Y가 음수이면 오류를 생성합니다. |
논리 연산자
Cloud Spanner SQL은 AND
, OR
, NOT
논리 연산자를 지원합니다.
논리 연산자는 BOOL 또는 NULL
입력만 허용하고 3치 논리를 사용하여 결과를 생성합니다. 결과는 TRUE
, FALSE
, 또는 NULL
일 수 있습니다.
x | y | x AND y | x OR y |
---|---|---|---|
TRUE | TRUE | TRUE | TRUE |
TRUE | FALSE | FALSE | TRUE |
TRUE | NULL | NULL | TRUE |
FALSE | TRUE | FALSE | TRUE |
FALSE | FALSE | FALSE | FALSE |
FALSE | NULL | FALSE | NULL |
NULL | TRUE | NULL | TRUE |
NULL | FALSE | FALSE | NULL |
NULL | NULL | NULL | NULL |
x | NOT x |
---|---|
TRUE | FALSE |
FALSE | TRUE |
NULL | NULL |
예시
이 섹션의 예시는 entry_table
이라는 테이블을 참조합니다.
+-------+
| entry |
+-------+
| a |
| b |
| c |
| NULL |
+-------+
SELECT 'a' FROM entry_table WHERE entry = 'a'
-- a => 'a' = 'a' => TRUE
-- b => 'b' = 'a' => FALSE
-- NULL => NULL = 'a' => NULL
+-------+
| entry |
+-------+
| a |
+-------+
SELECT entry FROM entry_table WHERE NOT (entry = 'a')
-- a => NOT('a' = 'a') => NOT(TRUE) => FALSE
-- b => NOT('b' = 'a') => NOT(FALSE) => TRUE
-- NULL => NOT(NULL = 'a') => NOT(NULL) => NULL
+-------+
| entry |
+-------+
| b |
| c |
+-------+
SELECT entry FROM entry_table WHERE entry IS NULL
-- a => 'a' IS NULL => FALSE
-- b => 'b' IS NULL => FALSE
-- NULL => NULL IS NULL => TRUE
+-------+
| entry |
+-------+
| NULL |
+-------+
비교 연산자
비교는 항상 BOOL을 반환합니다. 비교를 하려면 일반적으로 두 피연산자가 같은 유형이어야 합니다. 피연산자 유형이 다르고 Cloud Spanner SQL이 정밀도를 유지하면서 해당 유형의 값을 공통된 유형으로 변환할 수 있는 경우, 일반적으로 Cloud Spanner SQL은 비교를 위해 값을 공통된 유형으로 강제 변환합니다.Cloud Spanner SQL은 일반적으로 리터럴을 비 리터럴 유형으로 강제 변환합니다(존재하는 경우). 비교할 수 있는 데이터 유형은 데이터 유형에 정의되어 있습니다.
STRUCT는 같음(=), 같지 않음(!= 및 <>), IN과 같은 4가지 비교 연산자만 지원합니다.
이러한 데이터 유형을 비교할 때는 다음 규칙이 적용됩니다.
- FLOAT64: NaN이 포함된 모든 비교는 FALSE를 반환합니다. 단,
!=
및<>
은 TRUE를 반환합니다. - BOOL: FALSE가 TRUE보다 작습니다.
- STRING: 코드 포인트별로 문자열을 비교합니다. 즉, 규범적 등가 문자열은 먼저 정규화된 경우에 한해 비교 결과가 같음으로 보장됩니다.
NULL
: 이 경우에는 입력이NULL
인 모든 연산은NULL
을 반환한다는 규칙이 적용됩니다.
이름 | 구문 | 설명 |
---|---|---|
미만 | X < Y | X가 Y보다 작으면 TRUE를 반환합니다. |
이하 | X <= Y | X가 Y보다 작거나 같으면 TRUE를 반환합니다. |
초과 | X > Y | X가 Y보다 크면 TRUE를 반환합니다. |
이상 | X >= Y | X가 Y보다 크거나 같으면 TRUE를 반환합니다. |
같음 | X = Y | X가 Y와 같으면 TRUE를 반환합니다. |
같지 않음 | X != Y X <> Y |
X가 Y와 같지 않으면 TRUE를 반환합니다. |
BETWEEN | X [NOT] BETWEEN Y AND Z | X가 지정한 범위 내에 있지 [않으면] TRUE를 반환합니다. 'X BETWEEN Y AND Z'의 결과는 'Y <= X AND X <= Z'와 같지만, 전자의 경우 X가 한 번만 평가됩니다. |
LIKE | X [NOT] LIKE Y | 첫 번째 피연산자 X의 STRING이 두 번째 피연산자 Y에서 지정한 패턴과 일치하는지 확인합니다. 표현식에 다음과 같은 문자를 포함할 수 있습니다.
|
IN | 다양함 - 아래 참조 | 오른쪽 피연산자가 비어 있으면 FALSE를 반환합니다. 왼쪽 피연산자가 NULL 이면 NULL 을 반환합니다. 오른쪽 피연산자에 NULL 이 포함되어 있으면 TRUE 또는 NULL 을 반환하고 절대 FALSE를 반환하지 않습니다. IN의 양쪽에 있는 인수는 일반적인 표현식입니다. 어느 쪽 피연산자도 리터럴일 필요는 없지만 오른쪽에 리터럴을 사용하는 것이 가장 일반적입니다. X는 한 번만 평가됩니다. |
STRUCT 데이터 유형의 값이 서로 같은지 테스트할 때, 하나 이상의 필드가 NULL
인 경우가 있습니다. 이 경우,
- NULL이 아닌 모든 필드 값이 같다면 비교 후 NULL이 반환됩니다.
- NULL이 아닌 필드 값이 같지 않다면 비교 후 false가 반환됩니다.
아래 표는 NULL
값의 필드를 가진 STRUCT 데이터 유형이 어떻게 비교되는지 보여줍니다.
Struct1 | Struct2 | Struct1 = Struct2 |
---|---|---|
STRUCT(1, NULL) |
STRUCT(1, NULL) |
NULL |
STRUCT(1, NULL) |
STRUCT(2, NULL) |
FALSE |
STRUCT(1,2) |
STRUCT(1, NULL) |
NULL |
IN 연산자
IN
연산자는 다음과 같은 구문을 지원합니다.
x [NOT] IN (y, z, ... ) # Requires at least one element
x [NOT] IN (<subquery>)
x [NOT] IN UNNEST(<array expression>) # analysis error if the expression
# does not return an ARRAY type.
IN
연산자 양쪽의 인수는 일반적인 표현식입니다.
오른쪽 표현식에 리터럴을 사용하는 것이 일반적이지만 필수는 아닙니다.
다음 표현식의 의미 체계는
x IN (y, z, ...)
다음과 동일한 것으로 정의되며
(x = y) OR (x = z) OR ...
서브 쿼리와 배열 형식은 유사하게 정의됩니다.
x NOT IN ...
이 값은 다음과 동일합니다.
NOT(x IN ...)
UNNEST 형식은 배열 스캔을 FROM 절의 UNNEST
처럼 취급합니다.
x [NOT] IN UNNEST(<array expression>)
이 형식은 종종 ARRAY 매개변수와 함께 사용됩니다. 예를 들면 다음과 같습니다.
x IN UNNEST(@array_parameter)
참고: NULL
ARRAY는 빈 ARRAY와 동일하게 취급됩니다.
이 구문을 사용하는 방법에 대한 자세한 내용은 배열 항목을 참조하세요.
IN
연산자를 사용할 때는 다음과 같은 시맨틱스가 적용됩니다.
- 오른쪽의 표현식이 비어 있는
IN
은 항상 FALSE입니다. - 왼쪽 표현식이
NULL
이고 오른쪽 표현식이 비어 있지 않은IN
은 항상NULL
입니다. IN
목록에서NULL
인IN
은 TRUE 또는NULL
만 반환할 수 있으며 절대 FALSE를 반환하지 않습니다.NULL IN (NULL)
은NULL
을 반환합니다.IN UNNEST(<NULL array>)
는NULL
이 아닌 FALSE를 반환합니다.IN
목록에서NULL
인NOT IN
은 FALSE 또는NULL
만 반환할 수 있으며 절대 TRUE를 반환하지 않습니다.
구조체 생성자 구문을 사용하여 IN
을 멀티 파트 키와 함께 사용할 수 있습니다.
예를 들면 다음과 같습니다.
(Key1, Key2) IN ( (12,34), (56,78) )
(Key1, Key2) IN ( SELECT (table.a, table.b) FROM table )
이 구문에 대한 자세한 내용은 데이터 유형 항목의 구조체 유형 섹션을 참조하세요.
IS 연산자
IS 연산자는 테스트하는 조건에 대해 TRUE 또는 FALSE를 반환합니다. 이 연산자는 수학 함수에서 정의된 IS_INF 및 IS_NAN 함수와 달리 입력이 NULL
이어도 절대로 NULL
을 반환하지 않습니다. NOT이 있으면 출력 BOOL 값이 반전됩니다.
함수 구문 | 입력 데이터 유형 | 결과 데이터 유형 | 설명 |
---|---|---|---|
X IS [NOT] NULL |
모든 값 유형 | BOOL | 피연산자 X가 NULL 로 평가될 경우 TRUE를 반환하고, 그렇지 않은 경우 FALSE를 반환합니다. |
X IS [NOT] TRUE |
BOOL | BOOL | BOOL 피연산자가 TRUE로 평가될 경우 TRUE를 반환하고 그렇지 않은 경우 FALSE를 반환합니다. |
X IS [NOT] FALSE |
BOOL | BOOL | BOOL 피연산자가 FALSE로 평가될 경우 TRUE를 반환하고 그렇지 않은 경우 FALSE를 반환합니다. |
연결 연산자
연결 연산자는 여러 값을 하나로 연결합니다.
함수 구문 | 입력 데이터 유형 | 결과 데이터 유형 |
---|---|---|
STRING || STRING [ || ... ] |
STRING | STRING |
BYTES || BYTES [ || ... ] |
BYTES | STRING |
ARRAY<T> || ARRAY<T> [ || ... ] |
ARRAY<T> | ARRAY<T> |
조건식
조건식은 입력의 평가 순서에 제약을 적용하며 기본적으로 단락을 통해 왼쪽에서 오른쪽으로 평가되며 선택된 출력 값만을 평가합니다. 반대로, 정규 함수의 모든 입력은 함수를 호출하기 전에 평가됩니다. 조건식의 단락은 오류 처리나 성능 조정에 유용합니다.
CASE expr
CASE expr
WHEN expr_to_match THEN result
[ ... ]
[ ELSE else_result ]
END
설명
expr
과 연속된 각 WHEN
절의 expr_to_match
를 비교하여 이 비교에서 true를 반환하는 첫 번째 결과를 반환합니다. 나머지 WHEN
절과 else_result
는 평가되지 않습니다. expr = expr_to_match
비교가 모든 WHEN
절에 대해 false 또는 NULL을 반환하는 경우 else_result
를 반환합니다. 없는 경우 NULL을 반환합니다.
expr
및 expr_to_match
은 모든 유형이 될 수 있습니다. 공통 상위 유형으로 묵시적으로 강제 변환이 가능해야 합니다. 강제된 값에서 동등 비교가 수행됩니다. 여러 result
유형이 있을 수 있습니다. result
및 else_result
표현식은 공통 상위 유형으로 강제 변환이 가능해야 합니다.
반환 데이터 유형
result
[, ...] 및 else_result
의 상위 유형입니다.
예시
WITH Numbers AS
(SELECT 90 as A, 2 as B UNION ALL
SELECT 50, 8 UNION ALL
SELECT 60, 6 UNION ALL
SELECT 50, 10)
SELECT A, B,
CASE A
WHEN 90 THEN 'red'
WHEN 50 THEN 'blue'
ELSE 'green'
END
AS result
FROM Numbers
+------------------+
| A | B | result |
+------------------+
| 90 | 2 | red |
| 50 | 8 | blue |
| 60 | 6 | green |
| 50 | 10 | blue |
+------------------+
CASE
CASE
WHEN condition THEN result
[ ... ]
[ ELSE else_result ]
END
설명
연속된 각 WHEN
절의 조건을 평가하고 조건이 true인 첫 번째 결과를 반환합니다. 나머지 WHEN
절과 else_result
는 평가되지 않습니다. 모든 조건이 false 또는 NULL이면 else_result
를 반환합니다. 존재하지 않으면 NULL을 반환합니다.
condition
은 부울 표현식이어야 합니다. 여러 result
유형이 있을 수 있습니다.
result
및 else_result
표현식은 공통 상위 유형으로 묵시적 강제 변환이 가능해야 합니다.
반환 데이터 유형
result
[, ...] 및 else_result
의 상위 유형입니다.
예시
WITH Numbers AS
(SELECT 90 as A, 2 as B UNION ALL
SELECT 50, 6 UNION ALL
SELECT 20, 10)
SELECT A, B,
CASE
WHEN A > 60 THEN 'red'
WHEN A > 30 THEN 'blue'
ELSE 'green'
END
AS result
FROM Numbers
+------------------+
| A | B | result |
+------------------+
| 90 | 2 | red |
| 50 | 6 | blue |
| 20 | 10 | green |
+------------------+
COALESCE
COALESCE(expr[, ...])
설명
null이 아닌 첫 번째 표현식의 값을 반환합니다. 나머지 표현식은 평가되지 않습니다. 입력 표현식은 모든 유형이 될 수 있습니다. 입력 표현식 유형이 여러 개 있을 수 있습니다. 모든 입력 표현식은 공통 상위 유형으로 묵시적 강제 변환이 가능해야 합니다.
반환 데이터 유형
expr
[, ...]의 상위 유형입니다.
예시
SELECT COALESCE('A', 'B', 'C') as result
+--------+
| result |
+--------+
| A |
+--------+
SELECT COALESCE(NULL, 'B', 'C') as result
+--------+
| result |
+--------+
| B |
+--------+
IF
IF(expr, true_result, else_result)
설명
expr
이 true인 경우 true_result
를 반환하고, 그 밖의 경우 else_result
를 반환합니다.
expr
이 true인 경우 else_result
가 평가되지 않습니다. expr
이 false이거나 NULL이면 true_result
가 평가되지 않습니다.
expr
은 부울 표현식이어야 합니다. true_result
및 else_result
는 공통 상위 유형으로 강제 변환이 가능해야 합니다.
반환 데이터 유형
true_result
및 else_result
의 상위 유형입니다.
예시
WITH Numbers AS
(SELECT 10 as A, 20 as B UNION ALL
SELECT 50, 30 UNION ALL
SELECT 60, 60)
SELECT
A, B,
IF( A<B, 'true', 'false') as result
FROM Numbers
+------------------+
| A | B | result |
+------------------+
| 10 | 20 | true |
| 50 | 30 | false |
| 60 | 60 | false |
+------------------+
IFNULL
IFNULL(expr, null_result)
설명
expr
이 NULL이면 null_result
를 반환합니다. 그렇지 않은 경우 expr
을 반환합니다. expr
이 NULL이 아니면 null_result
가 평가되지 않습니다.
expr
및 null_result
는 모든 유형이 될 수 있으며 암시적으로 공통 상위 유형으로 강제 변환될 수 있어야 합니다. COALESCE(expr, null_result)
의 동의어입니다.
반환 데이터 유형
expr
또는 null_result
의 상위 유형입니다.
예시
SELECT IFNULL(NULL, 0) as result
+--------+
| result |
+--------+
| 0 |
+--------+
SELECT IFNULL(10, 0) as result
+--------+
| result |
+--------+
| 10 |
+--------+
NULLIF
NULLIF(expr, expr_to_match)
설명
expr = expr_to_match
가 true이면 NULL을 반환하고, 그렇지 않으면 expr
을 반환합니다.
expr
및 expr_to_match
는 암시적으로 공통 상위 유형으로 강제 변환이 가능해야 하며 비교 가능해야 합니다.
NULLIF
는 STRUCT
유형을 지원하지 않습니다.
반환 데이터 유형
expr
및 expr_to_match
의 상위 유형입니다.
예시
SELECT NULLIF(0, 0) as result
+--------+
| result |
+--------+
| NULL |
+--------+
SELECT NULLIF(10, 0) as result
+--------+
| result |
+--------+
| 10 |
+--------+
표현식 서브 쿼리
표현식 서브 쿼리, 즉 표현식으로 사용되는 서브 쿼리에는 4가지 유형이 있습니다. 표현식 서브 쿼리는 열이나 테이블이 아닌 NULL
또는 단일 값을 반환하며 괄호로 묶여야 합니다. 서브 쿼리에 대한 자세한 내용은 서브 쿼리를 참조하세요.
서브 쿼리 유형 | 결과 데이터 유형 | 설명 |
---|---|---|
Scalar | 모든 T 유형 | 표현식 안에 괄호로 묶인 서브 쿼리(예: SELECT 목록 또는 WHERE 절 내)는 스칼라 서브 쿼리로 해석됩니다. 스칼라 서브 쿼리의 SELECT 목록에는 필드가 정확하게 한 개만 있어야 합니다. 서브 쿼리가 정확하게 행 한 개만 반환할 경우 이 단일 값이 스칼라 서브 쿼리 결과입니다. 서브 쿼리가 행 0개를 반환할 경우 스칼라 서브 쿼리 값은 NULL 입니다. 서브 쿼리가 행을 두 개 이상 반환할 경우 쿼리가 런타임 오류와 함께 실패합니다. 서브 쿼리가 SELECT AS
STRUCT 와 함께 작성된 경우에는 열을 여러 개 포함할 수 있으며, 반환되는 값은 생성된 STRUCT입니다. SELECT AS 를 사용하지 않고 열을 여러 개 선택하면 오류가 발생합니다. |
ARRAY | ARRAY | SELECT AS STRUCT 를 사용하여 구조체의 배열을 빌드할 수 있으며, SELECT AS 를 사용하지 않고 열을 여러 개 선택하면 오류가 발생합니다. 서브 쿼리가 행을 0개 반환할 경우 빈 ARRAY를 반환합니다. 절대 NULL ARRAY를 반환하지 않습니다. |
IN | BOOL | IN 연산자 다음에 오는 표현식에서 발생합니다. 이 서브 쿼리는 IN 연산자의 왼쪽에 있는 표현식과 동등성이 호환되는 유형의 단일 열을 생성해야 합니다. 서브 쿼리가 행을 0개 반환할 경우 FALSE를 반환합니다.
x IN () 은 x IN (value, value, ...) 과 동일합니다. 전체 시맨틱스는 비교 연산자 중 IN 연산자를 참조하세요. |
EXISTS | BOOL | 서브 쿼리가 하나 이상의 행을 생성한 경우 TRUE를 반환합니다. 서브 쿼리가 0개의 행을 생성하는 경우 FALSE를 반환합니다. 절대 NULL 을 반환하지 않습니다. 다른 모든 표현식 서브 쿼리와 달리, 열 목록에 대한 규칙이 없습니다. 원하는 개수의 열을 선택할 수 있으며, 쿼리 결과는 이에 영향을 받지 않습니다. |
예시
표현식 서브 쿼리에 대한 다음 예시에서는 t.int_array
가 ARRAY<INT64>
유형이라고 가정합니다.
유형 | 서브 쿼리 | 결과 데이터 유형 | 참고 |
---|---|---|---|
Scalar | (SELECT COUNT(*) FROM t.int_array) |
INT64 | |
(SELECT DISTINCT i FROM t.int_array i) |
INT64, 런타임 오류 발생 가능 | ||
(SELECT i FROM t.int_array i WHERE i=5) |
INT64, 런타임 오류 발생 가능 | ||
(SELECT ARRAY_AGG(i) FROM t.int_array i) |
ARRAY | ARRAY_AGG 집계 함수를 사용하여 ARRAY를 반환합니다. | |
(SELECT 'xxx' a) |
STRING | ||
(SELECT 'xxx' a, 123 b) |
오류 | 둘 이상의 열이 있기 때문에 오류를 반환합니다. | |
(SELECT AS STRUCT 'xxx' a, 123 b) |
STRUCT | ||
(SELECT AS STRUCT 'xxx' a) |
STRUCT | ||
ARRAY | ARRAY(SELECT COUNT(*) FROM t.int_array) |
크기가 1인 ARRAY | |
ARRAY(SELECT x FROM t) |
ARRAY | ||
ARRAY(SELECT 5 a, COUNT(*) b FROM t.int_array) |
오류 | 둘 이상의 열이 있기 때문에 오류를 반환합니다. | |
ARRAY(SELECT AS STRUCT 5 a, COUNT(*) b FROM t.int_array) |
ARRAY | ||
ARRAY(SELECT AS STRUCT i FROM t.int_array i) |
ARRAY | 필드가 1개인 여러 개의 STRUCT로 구성된 ARRAY를 만듭니다. | |
ARRAY(SELECT AS STRUCT 1 x, 2, 3 x) |
ARRAY | 익명 또는 중복된 필드를 가진 여러 개의 STRUCT로 구성된 ARRAY를 반환합니다. | |
ARRAY(SELECT AS TypeName SUM(x) a, SUM(y) b, SUM(z) c from t) |
array<TypeName> | 명명된 유형을 선택합니다. TypeName이 필드 a, b, c가 있는 STRUCT 유형이라고 가정합니다. | |
STRUCT | (SELECT AS STRUCT 1 x, 2, 3 x) |
STRUCT | 익명 또는 중복된 필드가 있는 STRUCT를 생성합니다. |
EXISTS | EXISTS(SELECT x,y,z FROM table WHERE y=z) |
BOOL | |
NOT EXISTS(SELECT x,y,z FROM table WHERE y=z) |
BOOL | ||
IN | x IN (SELECT y FROM table WHERE z) |
BOOL | |
x NOT IN (SELECT y FROM table WHERE z) |
BOOL |
디버깅 함수
Cloud Spanner SQL은 다음과 같은 디버깅 함수를 지원합니다.
ERROR
ERROR(error_message)
설명
오류를 반환합니다. error_message
인수는 STRING
입니다.
Cloud Spanner SQL은 오류를 발생시킬 수 있는 표현식을 처리할 때와 동일한 방식으로 ERROR
를 처리합니다. 특별히 보장되는 평가 순서는 없습니다.
반환 데이터 유형
Cloud Spanner SQL은 컨텍스트에서 반환 유형을 추론합니다.
예시
다음 예시의 쿼리는 행 값이 정의된 두 값 중 하나와 일치하지 않으면 오류 메시지를 반환합니다.
SELECT
CASE
WHEN value = 'foo' THEN 'Value is foo.'
WHEN value = 'bar' THEN 'Value is bar.'
ELSE ERROR(concat('Found unexpected value: ', value))
END AS new_value
FROM (
SELECT 'foo' AS value UNION ALL
SELECT 'bar' AS value UNION ALL
SELECT 'baz' AS value);
Found unexpected value: baz
다음 예시에서 Cloud Spanner SQL은 x > 0
ERROR
함수를 평가할 수 있습니다. 일반적으로 Cloud Spanner SQL은 WHERE
절 조건 간의 순서를 보장하지 않고 ERROR
함수에 특별한 보장을 하지 않기 때문입니다.
SELECT *
FROM (SELECT -1 AS x)
WHERE x > 0 AND ERROR('Example error');
다음 예시에서 WHERE
절은 IF
조건을 평가하여 조건이 충족되지 않는 경우에만 Cloud Spanner SQL이 ERROR
함수를 평가하도록 합니다.
SELECT *
FROM (SELECT -1 AS x)
WHERE IF(x > 0, true, ERROR(FORMAT('Error: x must be positive but is %t', x)));'
Error: x must be positive but is -1