표준 SQL 함수 및 연산자

이 페이지에서는 함수와 연산자를 비롯한 BigQuery 표현식을 설명합니다.

함수 호출 규칙

함수 설명에 달리 명시되어 있지 않는 한 모든 함수에는 다음 규칙이 적용됩니다.

  • 숫자 유형을 허용하는 함수의 경우, 한 피연산자가 부동 소수점 피연산자이고 다른 피연산자가 다른 숫자 유형이라면 함수가 평가되기 전에 두 피연산자 모두 FLOAT64로 변환됩니다.
  • 피연산자가 NULL이면 결과도 NULL입니다(IS 연산자 제외).

  • 시간대를 구분하는 함수의 경우(함수 설명에 나와 있음) 시간대를 지정하지 않으면 기본 시간대인 UTC가 사용됩니다.

SAFE. 접두사

구문:

SAFE.function_name()

설명

함수를 SAFE. 접두사로 시작하면 오류 대신 NULL을 반환합니다. SAFE. 접두사는 접두사가 붙은 함수 자체의 오류만 방지하며 인수 표현식을 평가하는 동안 발생하는 오류는 방지하지 않습니다. SAFE. 접두사는 '값이 범위를 벗어남' 오류 같은 함수 입력 값 때문에 발생하는 오류만 방지하며, 내부 오류나 시스템 오류 같은 다른 오류는 여전히 발생할 수 있습니다. 함수가 오류를 반환하지 않으면 SAFE.는 출력에 영향을 미치지 않습니다. 함수가 RAND와 같은 오류를 반환하지 않으면 SAFE.는 아무런 영향이 없습니다.

+=과 같은 연산자SAFE. 프리픽스를 지원하지 않습니다. 나누기 연산 오류를 방지하려면 SAFE_DIVIDE를 사용합니다. IN, ARRAY, UNNEST와 같은 일부 연산자는 함수와 비슷하지만 SAFE. 프리픽스를 지원하지 않습니다. CASTEXTRACT 함수도 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          |
+-------------+

지원되는 함수

BigQuery는 STRING 함수, 수학 함수, DATE 함수, DATETIME 함수, TIMESTAMP 함수를 비롯하여 오류가 발생할 수 있는 대부분의 스칼라 함수에서 SAFE. 프리픽스 사용을 지원하며, 집계 함수, 분석 함수 또는 사용자 정의 함수에서는 SAFE. 프리픽스 사용을 지원하지 않습니다.

영구 사용자 정의 함수(UDF) 호출

참고: BigQuery의 영구 UDF 지원은 베타 버전입니다. 자세한 내용은 제품 출시 단계를 참조하세요.

영구 UDF를 만든 후 정의된 데이터세트의 이름을 프리픽스로 앞에 붙여서 다른 함수처럼 호출할 수 있습니다.

구문

[`project_name`].dataset_name.function_name([parameter_value[, ...]])

쿼리를 실행하는 데 사용 중인 프로젝트 이외의 프로젝트에서 UDF를 호출하려면 project_name이 필요합니다.

예시

다음 예시에서는 multiply_by_three라는 UDF를 만들고 동일한 프로젝트에서 호출합니다.

CREATE FUNCTION my_dataset.multiply_by_three(x INT64) AS (x * 3);

SELECT my_dataset.multiply_by_three(5) AS result; -- returns 15

다음 예시에서는 다른 프로젝트에서 영구 UDF를 호출합니다.

CREATE `other_project`.other_dataset.other_function(x INT64, y INT64)
  AS (x * y * 2);

SELECT `other_project`.other_dataset.other_function(3, 4); --returns 24

변환 규칙

'변환'에는 변환과 강제 변환이 포함되며 이에 국한되지 않습니다.

  • Cast 변환은 명시적 변환으로, CAST() 함수를 사용합니다.
  • 강제는 암시적 변환으로, 아래 설명된 조건에 따라 BigQuery가 자동으로 수행합니다.
  • UNIX_DATE()와 같은 자체 함수 이름을 가진 세 번째 변환 함수 그룹이 있습니다.

아래 표에는 BigQuery 데이터 유형에 사용할 수 있는 모든 CAST 및 강제 변환이 요약되어 있습니다. '강제 변환 대상'은 특정 데이터 유형(예: 열)의 모든 표현식에 적용되지만 리터럴과 매개변수도 강제 변환될 수 있습니다. 자세한 내용은 리터럴 강제 변환매개변수 강제 변환을 참조하세요.

원본 유형 CAST 대상 강제 변환 대상
INT64 BOOL
INT64
NUMERIC
FLOAT64
STRING
FLOAT64
NUMERIC
NUMERIC INT64
NUMERIC
FLOAT64
STRING
FLOAT64
FLOAT64 INT64
NUMERIC
FLOAT64
STRING
 
BOOL BOOL
INT64
STRING
 
STRING BOOL
INT64
NUMERIC
FLOAT64
STRING
BYTES
DATE
DATETIME
TIME
TIMESTAMP
 
BYTES BYTES
STRING
 
DATE DATE
DATETIME
STRING
TIMESTAMP
 
DATETIME DATE
DATETIME
STRING
TIME
TIMESTAMP
 
TIME STRING
TIME
 
TIMESTAMP DATE
DATETIME
STRING
TIME
TIMESTAMP
 
ARRAY ARRAY  
STRUCT STRUCT  

변환

구문:

CAST(expr AS typename)

쿼리에서 사용되는 Cast 구문은 표현식의 결과 유형이 다른 유형으로 변환되어야 함을 나타냅니다.

예:

CAST(x=1 AS STRING)

x1이면 "true"이고, NULL 외의 값이면 "false"이고, xNULL이면 NULL입니다.

원본 값에서 대상 도메인으로 성공적으로 매핑되지 못하는 지원 유형 간의 변환은 런타임 오류를 유발합니다. 예를 들어 BYTES를 STRING으로 변환하는데 바이트 시퀀스가 유효한 UTF-8이 아닌 경우에는 런타임 오류가 발생합니다.

다음 유형의 x 표현식을 변환할 때는 다음과 같은 규칙이 적용됩니다.

원본 대상 x 변환 시 규칙
INT64 FLOAT64 가깝지만 정확하지 않을 수 있는 FLOAT64 값을 반환합니다.
INT64 BOOL x0이면 FALSE, 그렇지 않으면 TRUE를 반환합니다.
NUMERIC 부동 소수점 NUMERIC은 가장 가까운 부동 소수점 수로 변환되며 정밀도가 떨어질 수 있습니다.
FLOAT64 INT64 가장 가까운 INT64 값을 반환합니다.
1.5나 -0.5와 같은 중간 값은 0에서 멀어지는 방향으로 반올림됩니다.
FLOAT64 STRING 근사치의 문자열 표시를 반환합니다.
FLOAT64 NUMERIC 부동 소수점 수의 소수점 이하 자릿수가 9자리를 넘으면 0에서 멀어지는 방향으로 반올림됩니다. NaN, +inf 또는 -inf 변환은 오류를 반환합니다. NUMERIC의 범위를 벗어난 값을 변환하면 오버플로 오류가 반환됩니다.
BOOL INT64 xTRUE이면 1, 그렇지 않으면 0을 반환합니다.
BOOL STRING xTRUE이면 "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 다음 조건이 충족될 경우에 허용됩니다.
  1. 두 STRUCT의 필드 개수가 같습니다.
  2. 원본 STRUCT 필드 유형을 해당 대상 STRUCT 필드 유형으로 명시적으로 변환할 수 있습니다(필드 이름이 아니라 필드 순서에 의해 정의된 대로).

Safe casting

CAST 사용 시 BigQuery가 변환을 수행할 수 없으면 쿼리가 실패할 수 있습니다. 예를 들어 다음 쿼리는 오류를 생성합니다.

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       |
+-----------+------------+

날짜 유형 변환

BigQuery는 다음과 같이 날짜 유형과 문자열 간의 변환을 지원합니다.

CAST(date_expression AS STRING)
CAST(string_expression AS DATE)

날짜 유형을 문자열로 변환하는 것은 시간대와 관계가 없으며 YYYY-MM-DD 형태를 갖습니다. 문자열에서 날짜로 변환할 경우, 문자열이 지원되는 날짜 리터럴 형식과 일치해야 하며, 이는 시간대와 관계가 없습니다. 문자열 표현식이 유효하지 않거나 지원되는 최소/최대 범위 밖의 날짜를 나타낼 경우, 오류가 발생합니다.

타임스탬프 유형 변환

BigQuery는 다음과 같이 타임스탬프 유형과 문자열 간의 변환을 지원합니다.

CAST(timestamp_expression AS STRING)
CAST(string_expression AS TIMESTAMP)

타임스탬프 유형에서 문자열로 변환할 경우, 타임스탬프가 기본 시간대인 UTC를 사용하여 해석됩니다. 생성되는 1초 미만 자릿수의 개수는 1초 미만 단위에 따라오는 0의 개수에 따라 결정됩니다. CAST 함수는 0, 3 또는 6자릿수를 잘라냅니다.

문자열에서 타임스탬프로 변환할 경우, string_expression이 지원되는 타임스탬프 리터럴 형식과 일치해야 하며, 그렇지 않은 경우 런타임 오류가 발생합니다. string_expressiontime_zone이 포함될 수 있습니다. 시간대를 참조하세요. string_expression에 시간대가 있으면 해당 시간대가 변환에 사용되고, 그렇지 않으면 기본 시간대인 UTC가 사용됩니다. 문자열이 6자리 미만이면 암시적으로 확장됩니다.

string_expression이 유효하지 않거나 1초 미만 자릿수가 6개보다 많거나(즉, 정밀도가 마이크로초 이상인 경우), 지원되는 타임스탬프 범위 밖의 시간을 나타내는 경우 오류가 발생합니다.

날짜 유형과 타임스탬프 유형 간 변환

BigQuery는 다음과 같이 날짜 유형과 타임스탬프 유형 간의 변환을 지원합니다.

CAST(date_expression AS TIMESTAMP)
CAST(timestamp_expression AS DATE)

날짜에서 타임스탬프로 변환할 경우 date_expression은 기본 시간대인 UTC의 자정(하루의 시작)을 기준으로 해석됩니다. 타임스탬프에서 날짜로 변환할 경우 기본 시간대를 기준으로 타임스탬프를 효과적으로 잘라냅니다.

강제

BigQuery는 함수 서명을 일치시켜야 하는 경우 표현식의 결과 유형을 다른 유형으로 강제합니다. 예를 들어 함수 func()가 INT64 유형의 단일 인수를 취하도록 정의되어 있고, 표현식이 FLOAT64의 결과 유형을 갖는 인수로 사용되는 경우 이 표현식의 결과는 func()가 계산되기 전에 INT64 유형으로 강제됩니다.

리터럴 강제

BigQuery는 다음과 같은 리터럴 강제를 지원합니다.

입력 데이터 유형 결과 데이터 유형 참고
STRING 리터럴 DATE
TIMESTAMP

리터럴 강제는 실제 리터럴 유형이 해당 함수가 예상하는 유형과 다를 경우에 필요합니다. 예를 들어 함수 func()가 DATE 인수를 취하는 경우, STRING 리터럴 "2014-09-27"이 DATE로 강제되기 때문에 표현식 func("2014-09-27")은 유효합니다.

리터럴 강제는 분석 시 평가되며, 입력 리터럴을 대상 유형으로 성공적으로 변환할 수 없는 경우 오류가 발생합니다.

참고: 문자열 리터럴은 숫자 유형으로 강제되지 않습니다.

매개변수 강제

BigQuery는 다음과 같은 매개변수 강제를 지원합니다.

입력 데이터 유형 결과 데이터 유형
STRING 매개변수

매개변수 값을 대상 유형으로 성공적으로 강제할 수 없는 경우 오류가 발생합니다.

기타 변환 함수

BigQuery는 다음과 같은 변환 함수를 추가로 제공합니다.

집계 함수

집계 함수는 값의 집합에 대해 계산을 수행하는 함수입니다. 집계 함수의 예로는 COUNT, MIN, MAX가 있습니다.

SELECT COUNT(*) as total_count, COUNT(fruit) as non_null_count,
       MIN(fruit) as min, MAX(fruit) as max
FROM UNNEST([NULL, "apple", "pear", "orange"]) as fruit;
+-------------+----------------+-------+------+
| total_count | non_null_count | min   | max  |
+-------------+----------------+-------+------+
| 4           | 3              | apple | pear |
+-------------+----------------+-------+------+

다음 섹션에서는 BigQuery가 지원하는 집계 함수를 설명합니다.

ANY_VALUE

ANY_VALUE(expression)  [OVER (...)]

설명

0이 입력된 행이 있는 경우 아무 입력 값이나 NULL을 반환합니다. 반환된 값은 확정값이 아닙니다. 즉, 이 함수를 사용할 때마다 다른 결과를 얻을 수 있다는 뜻입니다.

지원되는 인수 유형

모두

선택적 절

OVER: 기간을 지정합니다. 분석 함수를 참조하세요.

반환되는 데이터 유형

입력된 데이터 유형과 일치합니다.

예시

SELECT ANY_VALUE(fruit) as any_value
FROM UNNEST(["apple", "banana", "pear"]) as fruit;

+-----------+
| any_value |
+-----------+
| apple     |
+-----------+

SELECT
  fruit,
  ANY_VALUE(fruit) OVER (ORDER BY LENGTH(fruit) ROWS BETWEEN 1 PRECEDING AND CURRENT ROW) AS any_value
FROM UNNEST(["apple", "banana", "pear"]) as fruit;

+--------+-----------+
| fruit  | any_value |
+--------+-----------+
| pear   | pear      |
| apple  | pear      |
| banana | apple     |
+--------+-----------+

ARRAY_AGG

ARRAY_AGG([DISTINCT] expression [{IGNORE|RESPECT} NULLS]
          [ORDER BY key [{ASC|DESC}] [, ... ]]  [LIMIT n])
[OVER (...)]

설명

expression 값의 ARRAY를 반환합니다.

지원되는 인수 유형

ARRAY를 제외한 모든 데이터 유형.

옵션 절

절은 다음 순서로 적용됩니다.

  1. OVER: 기간을 지정합니다. 분석 함수를 참조하세요. 이 절은 현재 ARRAY_AGG() 내의 다른 모든 절과 호환되지 않습니다.

  2. DISTINCT: 각각의 고유한 expression 값이 한 번만 결과로 집계됩니다.

  3. IGNORE NULLS 또는 RESPECT NULLS: IGNORE NULLS가 지정되면 NULL 값이 결과에서 제외됩니다. RESPECT NULLS가 지정되거나 아무것도 지정되지 않으면 결과에 NULL 값이 포함됩니다. 하지만 최종 쿼리 결과 배열에 NULL 요소가 포함되어 있는 경우 오류가 발생합니다.

  4. ORDER BY: 값의 순서를 지정합니다.

    • 각 정렬 키의 기본 정렬 방향은 ASC입니다.
    • NULL: ORDER BY 절의 컨텍스트에서 NULL은 가능한 최소 값입니다. 즉, NULL은 ASC 정렬에서 첫 번째로 나타나고 DESC 정렬에서 마지막으로 나타납니다.
    • 부동 소수점 데이터 유형: 정렬 및 그룹화에 대해서는 부동 소수점 의미 체계를 참조하세요.
    • DISTINCT도 지정되는 경우, 정렬 키는 expression과 동일해야 합니다.
    • ORDER BY가 지정되지 않으면 출력 배열 내 요소의 순서는 확정값이 아닙니다. 즉, 이 함수를 사용할 때마다 다른 결과가 나올 수 있다는 의미입니다.
  5. LIMIT: 결과에서 expression 입력의 최대 수를 지정합니다. 한도 n은 상수 INT64여야 합니다.

반환되는 데이터 유형

ARRAY

0 입력 행이 있는 경우, 이 함수는 NULL을 반환합니다.

예시

SELECT FORMAT("%T", 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 FORMAT("%T", 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 FORMAT("%T", 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] |
+-------------------+
SELECT FORMAT("%T", ARRAY_AGG(x ORDER BY ABS(x))) AS array_agg
FROM UNNEST([2, 1, -2, 3, -2, 1, 2]) AS x;
+-------------------------+
| array_agg               |
+-------------------------+
| [1, 1, 2, -2, -2, 2, 3] |
+-------------------------+
SELECT FORMAT("%T", ARRAY_AGG(x LIMIT 5)) AS array_agg
FROM UNNEST([2, 1, -2, 3, -2, 1, 2]) AS x;

+-------------------+
| array_agg         |
+-------------------+
| [2, 1, -2, 3, -2] |
+-------------------+
SELECT FORMAT("%T", ARRAY_AGG(DISTINCT x IGNORE NULLS ORDER BY x LIMIT 2)) AS array_agg
FROM UNNEST([NULL, 1, -2, 3, -2, 1, NULL]) AS x;

+-----------+
| array_agg |
+-----------+
| [-2, 1]   |
+-----------+
SELECT
  x,
  FORMAT("%T", ARRAY_AGG(x) OVER (ORDER BY ABS(x))) AS array_agg
FROM UNNEST([2, 1, -2, 3, -2, 1, 2]) AS x;

+----+-------------------------+
| x  | array_agg               |
+----+-------------------------+
| 1  | [1, 1]                  |
| 1  | [1, 1]                  |
| 2  | [1, 1, 2, -2, -2, 2]    |
| -2 | [1, 1, 2, -2, -2, 2]    |
| -2 | [1, 1, 2, -2, -2, 2]    |
| 2  | [1, 1, 2, -2, -2, 2]    |
| 3  | [1, 1, 2, -2, -2, 2, 3] |
+----+-------------------------+

ARRAY_CONCAT_AGG

ARRAY_CONCAT_AGG(expression  [ORDER BY key [{ASC|DESC}] [, ... ]]  [LIMIT n])

설명

유형 ARRAY의 expression에서 요소들을 연결하여 단일 ARRAY를 결과로 반환합니다. 이 함수는 NULL 입력 배열은 무시하지만 비 NULL 입력 배열의 NULL 요소는 고려합니다. 하지만 최종 쿼리 결과 배열에 NULL 요소가 포함되어 있는 경우 오류가 발생합니다.

지원되는 인수 유형

ARRAY

옵션 절

절은 다음 순서로 적용됩니다.

  1. ORDER BY: 값의 순서를 지정합니다.

    • 각 정렬 키의 기본 정렬 방향은 ASC입니다.
    • 배열 순서 지정은 지원되지 않으므로 정렬 키는 expression과 같을 수 없습니다.
    • NULL: ORDER BY 절의 컨텍스트에서 NULL은 가능한 최소 값입니다. 즉, NULL은 ASC 정렬에서 첫 번째로 나타나고 DESC 정렬에서 마지막으로 나타납니다.
    • 부동 소수점 데이터 유형: 정렬 및 그룹화에 대해서는 부동 소수점 의미 체계를 참조하세요.
    • ORDER BY가 지정되지 않으면 출력 배열 내 요소의 순서는 확정값이 아닙니다. 즉, 이 함수를 사용할 때마다 다른 결과가 나올 수 있다는 의미입니다.
  2. LIMIT: 결과의 expression 입력 최대 수를 지정합니다. 한도는 배열의 요소 수가 아니라 입력 배열의 수에 적용됩니다. 비어 있는 배열은 1로 계산됩니다. NULL 배열은 계산되지 않습니다. 한도 n은 상수 INT64여야 합니다.

반환되는 데이터 유형

ARRAY

0이 입력된 행이 있거나 expression이 모든 행에서 NULL로 평가되는 경우 NULL을 반환합니다.

예시

SELECT FORMAT("%T", 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] |
+-----------------------------------+

SELECT FORMAT("%T", ARRAY_CONCAT_AGG(x ORDER BY ARRAY_LENGTH(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                  |
+-----------------------------------+
| [5, 6, 7, 8, 9, NULL, 1, 2, 3, 4] |
+-----------------------------------+

SELECT FORMAT("%T", ARRAY_CONCAT_AGG(x LIMIT 2)) 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] |
+--------------------------+

SELECT FORMAT("%T", ARRAY_CONCAT_AGG(x ORDER BY ARRAY_LENGTH(x) LIMIT 2)) 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 |
+------------------+
| [5, 6, 7, 8, 9]  |
+------------------+

AVG

AVG([DISTINCT] expression)  [OVER (...)]

설명

NULL 이외 입력 값들의 평균을 반환하거나 입력에 NaN이 포함되어 있는 경우 NaN을 반환합니다.

지원되는 인수 유형

INT64 등 모든 숫자 입력 유형. 부동 소수점 입력 유형의 경우 반환 결과가 확정값이 아닙니다. 즉, 이 함수를 사용할 때마다 다른 결과를 얻을 수 있다는 의미입니다.

옵션 절

절은 다음 순서로 적용됩니다.

  1. OVER: 기간을 지정합니다. 분석 함수를 참조하세요. 이 절은 현재 AVG() 내의 다른 모든 절과 호환되지 않습니다.

  2. DISTINCT: 각각의 고유한 expression 값이 한 번만 결과로 집계됩니다.

반환되는 데이터 유형

  • 입력 유형이 NUMERIC인 경우, NUMERIC.
  • FLOAT64

예시

SELECT AVG(x) as avg
FROM UNNEST([0, 2, NULL, 4, 4, 5]) as x;

+-----+
| avg |
+-----+
| 3   |
+-----+

SELECT AVG(DISTINCT x) AS avg
FROM UNNEST([0, 2, NULL, 4, 4, 5]) AS x;

+------+
| avg  |
+------+
| 2.75 |
+------+

SELECT
  x,
  AVG(x) OVER (ORDER BY x ROWS BETWEEN 1 PRECEDING AND CURRENT ROW) AS avg
FROM UNNEST([0, 2, NULL, 4, 4, 5]) AS x;

+------+------+
| x    | avg  |
+------+------+
| NULL | NULL |
| 0    | 0    |
| 2    | 1    |
| 4    | 3    |
| 4    | 4    |
| 5    | 4.5  |
+------+------+

BIT_AND

BIT_AND(expression)

설명

expression에 대해 비트 AND 연산을 수행하여 그 결과를 반환합니다.

지원되는 인수 유형

  • INT64

반환되는 데이터 유형

INT64

예시

SELECT BIT_AND(x) as bit_and FROM UNNEST([0xF001, 0x00A1]) as x;

+---------+
| bit_and |
+---------+
| 1       |
+---------+

BIT_OR

BIT_OR(expression)

설명

expression에 대해 비트 OR 연산을 수행하여 그 결과를 반환합니다.

지원되는 인수 유형

  • INT64

반환되는 데이터 유형

INT64

예시

SELECT BIT_OR(x) as bit_or FROM UNNEST([0xF001, 0x00A1]) as x;

+--------+
| bit_or |
+--------+
| 61601  |
+--------+

BIT_XOR

BIT_XOR([DISTINCT] expression)

설명

expression에 대해 비트 XOR 연산을 수행하여 그 결과를 반환합니다.

지원되는 인수 유형

  • INT64

선택적 절

DISTINCT: 각각의 고유한 expression 값이 한 번만 결과로 집계됩니다.

반환되는 데이터 유형

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(*)  [OVER (...)]

2.

COUNT([DISTINCT] expression)  [OVER (...)]

설명

  1. 입력에 있는 행의 개수를 반환합니다.
  2. NULL 이외의 다른 값으로 평가된 expression이 있는 행의 개수를 반환합니다.

지원되는 인수 유형

expression에는 모든 데이터 유형이 지원됩니다.

옵션 절

절은 다음 순서로 적용됩니다.

  1. OVER: 기간을 지정합니다. 분석 함수를 참조하세요.

  2. DISTINCT: 각각의 고유한 expression 값이 한 번만 결과로 집계됩니다.

반환 데이터 유형

INT64

예시

SELECT
  COUNT(*) AS count_star,
  COUNT(x) AS count_x,
  COUNT(DISTINCT x) AS count_dist_x
FROM UNNEST([1, 4, NULL, 4, 5]) AS x;

+------------+---------+--------------+
| count_star | count_x | count_dist_x |
+------------+---------+--------------+
| 5          | 4       | 3            |
+------------+---------+--------------+

SELECT
  x,
  COUNT(*) OVER (PARTITION BY MOD(x, 3)) AS count_star,
  COUNT(x) OVER (PARTITION BY MOD(x, 3)) AS count_x,
  COUNT(DISTINCT x) OVER (PARTITION BY MOD(x, 3)) AS count_dist_x
FROM UNNEST([1, 4, NULL, 4, 5]) AS x;

+------+------------+---------+--------------+
| x    | count_star | count_x | count_dist_x |
+------+------------+---------+--------------+
| NULL | 1          | 0       | 0            |
| 1    | 3          | 3       | 2            |
| 4    | 3          | 3       | 2            |
| 4    | 3          | 3       | 2            |
| 5    | 1          | 1       | 1            |
+------+------------+---------+--------------+

COUNTIF

COUNTIF(expression)  [OVER (...)]

설명

expressionTRUE 값 개수를 반환합니다. 0이 입력된 행이 있거나 expression이 모든 행에서 FALSE로 평가되는 경우 0을 반환합니다.

지원되는 인수 유형

BOOL

선택적 절

OVER: 기간을 지정합니다. 분석 함수를 참조하세요.

반환 데이터 유형

INT64

예시

SELECT COUNTIF(x<0) AS num_negative, COUNTIF(x>0) AS num_positive
FROM UNNEST([5, -2, 3, 6, -10, NULL, -7, 4, 0]) AS x;

+--------------+--------------+
| num_negative | num_positive |
+--------------+--------------+
| 3            | 4            |
+--------------+--------------+

SELECT
  x,
  COUNTIF(x<0) OVER (ORDER BY ABS(x) ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING) AS num_negative
FROM UNNEST([5, -2, 3, 6, -10, NULL, -7, 4, 0]) AS x;

+------+--------------+
| x    | num_negative |
+------+--------------+
| NULL | 0            |
| 0    | 1            |
| -2   | 1            |
| 3    | 1            |
| 4    | 0            |
| 5    | 0            |
| 6    | 1            |
| -7   | 2            |
| -10  | 2            |
+------+--------------+

LOGICAL_AND

LOGICAL_AND(expression)

설명

NULL이 아닌 모든 표현식의 논리적 AND를 반환합니다. 0 입력 행이 있거나 expression이 모든 행에서 NULL로 평가되는 경우, NULL을 반환합니다.

지원되는 인수 유형

BOOL

반환 데이터 유형

BOOL

예시

SELECT LOGICAL_AND(x) as logical_and FROM UNNEST([true, false, true]) as x;

+-------------+
| logical_and |
+-------------+
| false       |
+-------------+

LOGICAL_OR

LOGICAL_OR(expression)

설명

NULL이 아닌 모든 표현식의 논리적 OR을 반환합니다. 0 입력 행이 있거나 expression이 모든 행에서 NULL로 평가되는 경우, NULL을 반환합니다.

지원되는 인수 유형

BOOL

반환 데이터 유형

BOOL

예시

SELECT LOGICAL_OR(x) as logical_or FROM UNNEST([true, false, true]) as x;

+------------+
| logical_or |
+------------+
| true       |
+------------+

MAX

MAX(expression)  [OVER (...)]

설명

NULL이 아닌 표현식의 최대값을 반환합니다. 0 입력 행이 있거나 expression이 모든 행에서 NULL로 평가되는 경우, NULL을 반환합니다. 입력에 NaN이 포함된 경우 NaN을 반환합니다.

지원되는 인수 유형

다음을 제외한 모든 데이터 유형: ARRAY STRUCT

선택적 절

OVER: 기간을 지정합니다. 분석 함수를 참조하세요.

반환 데이터 유형

입력값으로 사용된 데이터 유형과 동일합니다.

예시

SELECT MAX(x) AS max
FROM UNNEST([8, NULL, 37, 4, NULL, 55]) AS x;

+-----+
| max |
+-----+
| 55  |
+-----+

SELECT x, MAX(x) OVER (PARTITION BY MOD(x, 2)) AS max
FROM UNNEST([8, NULL, 37, 4, NULL, 55]) AS x;

+------+------+
| x    | max  |
+------+------+
| NULL | NULL |
| NULL | NULL |
| 8    | 8    |
| 4    | 8    |
| 37   | 55   |
| 55   | 55   |
+------+------+

MIN

MIN(expression)  [OVER (...)]

설명

NULL이 아닌 표현식의 최소값을 반환합니다. 0 입력 행이 있거나 expression이 모든 행에서 NULL로 평가되는 경우, NULL을 반환합니다. 입력에 NaN이 포함된 경우 NaN을 반환합니다.

지원되는 인수 유형

다음을 제외한 모든 데이터 유형: ARRAY STRUCT

선택적 절

OVER: 기간을 지정합니다. 분석 함수를 참조하세요.

반환 데이터 유형

입력값으로 사용된 데이터 유형과 동일합니다.

예시

SELECT MIN(x) AS min
FROM UNNEST([8, NULL, 37, 4, NULL, 55]) AS x;

+-----+
| min |
+-----+
| 4   |
+-----+

SELECT x, MIN(x) OVER (PARTITION BY MOD(x, 2)) AS min
FROM UNNEST([8, NULL, 37, 4, NULL, 55]) AS x;

+------+------+
| x    | min  |
+------+------+
| NULL | NULL |
| NULL | NULL |
| 8    | 4    |
| 4    | 4    |
| 37   | 37   |
| 55   | 37   |
+------+------+

STRING_AGG

STRING_AGG([DISTINCT] expression [, delimiter]  [ORDER BY key [{ASC|DESC}] [, ... ]]  [LIMIT n])
[OVER (...)]

설명

null이 아닌 값을 연결하여 얻은 값(STRING 또는 BYTES)을 반환합니다.

delimiter가 지정된 경우 연결된 값이 해당 구분 기호로 구분되고, 그렇지 않은 경우 쉼표가 구분 기호로 사용됩니다.

지원되는 인수 유형

STRING BYTES

옵션 절

절은 다음 순서로 적용됩니다.

  1. OVER: 기간을 지정합니다. 분석 함수를 참조하세요. 이 절은 현재 STRING_AGG() 내의 다른 모든 절과 호환되지 않습니다.

  2. DISTINCT: 각각의 고유한 expression 값이 한 번만 결과로 집계됩니다.

  3. ORDER BY: 값의 순서를 지정합니다.

    • 각 정렬 키의 기본 정렬 방향은 ASC입니다.
    • NULL: ORDER BY 절의 컨텍스트에서 NULL은 가능한 최소 값입니다. 즉, NULL은 ASC 정렬에서 첫 번째로 나타나고 DESC 정렬에서 마지막으로 나타납니다.
    • 부동 소수점 데이터 유형: 정렬 및 그룹화에 대해서는 부동 소수점 의미 체계를 참조하세요.
    • DISTINCT도 지정되는 경우, 정렬 키는 expression과 동일해야 합니다.
    • ORDER BY가 지정되지 않으면 출력 배열 내 요소의 순서는 확정값이 아닙니다. 즉, 이 함수를 사용할 때마다 다른 결과가 나올 수 있다는 의미입니다.
  4. LIMIT: 결과의 expression 입력 최대 수를 지정합니다. 한도는 입력의 문자 또는 바이트 수가 아니라 입력 문자열의 수에 적용됩니다. 비어 있는 문자열은 1로 계산됩니다. NULL 문자열은 계산되지 않습니다. 한도 n은 상수 INT64여야 합니다.

반환 데이터 유형

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", NULL, "pear", "banana", "pear"]) AS fruit;

+------------------------------+
| string_agg                   |
+------------------------------+
| apple & pear & banana & pear |
+------------------------------+

SELECT STRING_AGG(DISTINCT fruit, " & ") AS string_agg
FROM UNNEST(["apple", NULL, "pear", "banana", "pear"]) AS fruit;

+-----------------------+
| string_agg            |
+-----------------------+
| apple & banana & pear |
+-----------------------+

SELECT STRING_AGG(fruit, " & " ORDER BY LENGTH(fruit)) AS string_agg
FROM UNNEST(["apple", NULL, "pear", "banana", "pear"]) AS fruit;

+------------------------------+
| string_agg                   |
+------------------------------+
| pear & pear & apple & banana |
+------------------------------+

SELECT STRING_AGG(fruit, " & " LIMIT 2) AS string_agg
FROM UNNEST(["apple", NULL, "pear", "banana", "pear"]) AS fruit;

+--------------+
| string_agg   |
+--------------+
| apple & pear |
+--------------+

SELECT STRING_AGG(DISTINCT fruit, " & " ORDER BY fruit DESC LIMIT 2) AS string_agg
FROM UNNEST(["apple", NULL, "pear", "banana", "pear"]) AS fruit;

+---------------+
| string_agg    |
+---------------+
| pear & banana |
+---------------+

SELECT
  fruit,
  STRING_AGG(fruit, " & ") OVER (ORDER BY LENGTH(fruit)) AS string_agg
FROM UNNEST(["apple", NULL, "pear", "banana", "pear"]) AS fruit;

+--------+------------------------------+
| fruit  | string_agg                   |
+--------+------------------------------+
| NULL   | NULL                         |
| pear   | pear & pear                  |
| pear   | pear & pear                  |
| apple  | pear & pear & apple          |
| banana | pear & pear & apple & banana |
+--------+------------------------------+

SUM

SUM([DISTINCT] expression)  [OVER (...)]

설명

null이 아닌 값의 합계를 반환합니다.

표현식이 부동 소수점 값인 경우, 합계가 확정값이 아닙니다. 즉, 이 함수를 사용할 때마다 다른 결과를 얻을 수 있다는 뜻입니다.

지원되는 인수 유형

지원되는 모든 숫자 데이터 유형.

옵션 절

절은 다음 순서로 적용됩니다.

  1. OVER: 기간을 지정합니다. 분석 함수를 참조하세요.

  2. DISTINCT: 각각의 고유한 expression 값이 한 번만 결과로 집계됩니다.

반환 데이터 유형

  • 입력이 정수면 INT64를 반환합니다.

  • 입력 유형이 NUMERIC이면 NUMERIC을 반환합니다.

  • 입력이 부동 소수점 값이면 FLOAT64를 반환합니다.

입력에 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
  x,
  SUM(x) OVER (PARTITION BY MOD(x, 3)) AS sum
FROM UNNEST([1, 2, 3, 4, 5, 4, 3, 2, 1]) AS x;

+---+-----+
| x | sum |
+---+-----+
| 3 | 6   |
| 3 | 6   |
| 1 | 10  |
| 4 | 10  |
| 4 | 10  |
| 1 | 10  |
| 2 | 9   |
| 5 | 9   |
| 2 | 9   |
+---+-----+

SELECT
  x,
  SUM(DISTINCT x) OVER (PARTITION BY MOD(x, 3)) AS sum
FROM UNNEST([1, 2, 3, 4, 5, 4, 3, 2, 1]) AS x;

+---+-----+
| x | sum |
+---+-----+
| 3 | 3   |
| 3 | 3   |
| 1 | 5   |
| 4 | 5   |
| 4 | 5   |
| 1 | 5   |
| 2 | 7   |
| 5 | 7   |
| 2 | 7   |
+---+-----+

통계 집계 함수

BigQuery는 다음과 같은 통계 집계 함수를 지원합니다.

CORR

CORR(X1, X2)  [OVER (...)]

설명

번호 쌍 집합의 피어슨 상관 계수를 반환합니다. 각 번호 쌍의 첫 번째 번호는 종속 변수이고 두 번째 번호는 독립 변수입니다. 반환 결과는 -1에서 1 사이입니다. 결과가 0이면 상관관계가 없다는 의미입니다.

이 함수는 하나 이상의 NULL 값이 포함된 입력 쌍을 무시합니다. NULL 값이 없는 입력 쌍이 2개 미만일 경우 이 함수는 NULL을 반환합니다.

지원되는 입력 유형

FLOAT64

선택적 절

OVER: 기간을 지정합니다. 분석 함수를 참조하세요.

반환 데이터 유형

FLOAT64

COVAR_POP

COVAR_POP(X1, X2)  [OVER (...)]

설명

번호 쌍 집합의 모집단 공분산을 반환합니다. 첫 번째 번호는 종속 변수이고 두 번째 번호는 독립 변수입니다. 반환 결과는 -Inf에서 +Inf 사이입니다.

이 함수는 하나 이상의 NULL 값이 포함된 입력 쌍을 무시합니다. NULL 값이 없는 입력 쌍이 없는 경우, 이 함수는 NULL을 반환합니다. NULL 값이 없는 입력 쌍이 정확히 1개 있는 경우, 이 함수는 0을 반환합니다.

지원되는 입력 유형

FLOAT64

선택적 절

OVER: 기간을 지정합니다. 분석 함수를 참조하세요.

반환 데이터 유형

FLOAT64

COVAR_SAMP

COVAR_SAMP(X1, X2)  [OVER (...)]

설명

번호 쌍 집합의 샘플 공분산을 반환합니다. 첫 번째 번호는 종속 변수이고 두 번째 번호는 독립 변수입니다. 반환 결과는 -Inf에서 +Inf 사이입니다.

이 함수는 하나 이상의 NULL 값이 포함된 입력 쌍을 무시합니다. NULL 값이 없는 입력 쌍이 2개 미만일 경우 이 함수는 NULL을 반환합니다.

지원되는 입력 유형

FLOAT64

선택적 절

OVER: 기간을 지정합니다. 분석 함수를 참조하세요.

반환 데이터 유형

FLOAT64

STDDEV_POP

STDDEV_POP([DISTINCT] expression)  [OVER (...)]

설명

값의 모집단(편향) 표준 편차를 반환합니다. 반환 결과는 0에서 +Inf 사이입니다.

이 함수는 모든 NULL 입력을 무시합니다. 모든 입력이 무시되면 이 함수는 NULL을 반환합니다.

이 함수는 NULL이 아닌 단일 입력을 받으면 0을 반환합니다.

지원되는 입력 유형

FLOAT64

선택적 절

절은 다음 순서로 적용됩니다.

  1. OVER: 기간을 지정합니다. 분석 함수를 참조하세요. 이 절은 현재 STDDEV_POP() 내의 다른 모든 절과 호환되지 않습니다.

  2. DISTINCT: 각각의 고유한 expression 값이 한 번만 결과로 집계됩니다.

반환 데이터 유형

FLOAT64

STDDEV_SAMP

STDDEV_SAMP([DISTINCT] expression)  [OVER (...)]

설명

값의 샘플(비편향) 표준 편차를 반환합니다. 반환 결과는 0에서 +Inf 사이입니다.

이 함수는 모든 NULL 입력을 무시합니다. NULL이 아닌 입력이 2개 미만인 경우, 이 함수는 NULL을 반환합니다.

지원되는 입력 유형

FLOAT64

선택적 절

절은 다음 순서로 적용됩니다.

  1. OVER: 기간을 지정합니다. 분석 함수를 참조하세요. 이 절은 현재 STDDEV_SAMP() 내의 다른 모든 절과 호환되지 않습니다.

  2. DISTINCT: 각각의 고유한 expression 값이 한 번만 결과로 집계됩니다.

반환 데이터 유형

FLOAT64

STDDEV

STDDEV([DISTINCT] expression)  [OVER (...)]

설명

STDDEV_SAMP의 별칭입니다.

VAR_POP

VAR_POP([DISTINCT] expression)  [OVER (...)]

설명

값의 모집단(편향) 분산을 반환합니다. 반환 결과는 0에서 +Inf 사이입니다.

이 함수는 모든 NULL 입력을 무시합니다. 모든 입력이 무시되면 이 함수는 NULL을 반환합니다.

이 함수는 NULL이 아닌 단일 입력을 받으면 0을 반환합니다.

지원되는 입력 유형

FLOAT64

선택적 절

절은 다음 순서로 적용됩니다.

  1. OVER: 기간을 지정합니다. 분석 함수를 참조하세요. 이 절은 현재 VAR_POP() 내의 다른 모든 절과 호환되지 않습니다.

  2. DISTINCT: 각각의 고유한 expression 값이 한 번만 결과로 집계됩니다.

반환 데이터 유형

FLOAT64

VAR_SAMP

VAR_SAMP([DISTINCT] expression)  [OVER (...)]

설명

값의 샘플(비편향) 분산을 반환합니다. 반환 결과는 0에서 +Inf 사이입니다.

이 함수는 모든 NULL 입력을 무시합니다. NULL이 아닌 입력이 2개 미만인 경우, 이 함수는 NULL을 반환합니다.

지원되는 입력 유형

FLOAT64

선택적 절

절은 다음 순서로 적용됩니다.

  1. OVER: 기간을 지정합니다. 분석 함수를 참조하세요. 이 절은 현재 VAR_SAMP() 내의 다른 모든 절과 호환되지 않습니다.

  2. DISTINCT: 각각의 고유한 expression 값이 한 번만 결과로 집계됩니다.

반환 데이터 유형

FLOAT64

VARIANCE

VARIANCE([DISTINCT] expression)  [OVER (...)]

설명

VAR_SAMP의 별칭.

근사치 집계 함수

근사치 집계 함수는 메모리 사용량과 시간 면에서 확장 가능하지만 정확한 결과가 아닌 근사치 결과를 산출합니다. 자세한 배경 정보는 근사치 집계를 참조하세요.

APPROX_COUNT_DISTINCT

APPROX_COUNT_DISTINCT(expression)

설명

COUNT(DISTINCT expression)의 근사치 결과를 반환합니다. 반환되는 값은 통계적 추정치이며 실제 값과 다를 수 있습니다.

이 함수는 COUNT(DISTINCT expression)보다 정확성이 떨어지지만 대량의 데이터를 입력할 때 성능 면에서 유리합니다.

지원되는 인수 유형

다음을 제외한 모든 데이터 유형: ARRAY STRUCT

반환되는 데이터 유형

INT64

예시

SELECT APPROX_COUNT_DISTINCT(x) as approx_distinct
FROM UNNEST([0, 1, 1, 2, 3, 5]) as x;

+-----------------+
| approx_distinct |
+-----------------+
| 5               |
+-----------------+

APPROX_QUANTILES

APPROX_QUANTILES([DISTINCT] expression, number [{IGNORE|RESPECT} NULLS])

설명

expression 값 그룹의 근사치 경계를 반환합니다. 여기서 number는 생성할 분위 수를 나타냅니다. 이 함수는 number + 1 요소 배열을 반환합니다. 여기서 첫 번째 요소는 근사치의 최소값이며 마지막 요소는 근사치의 최대값입니다.

지원되는 인수 유형

expression은 다음을 제외하고 지원되는 모든 데이터 유형이 될 수 있습니다. ARRAY STRUCT

number는 INT64여야 합니다.

선택적 절

절은 다음 순서로 적용됩니다.

  1. DISTINCT: 각각의 고유한 expression 값이 한 번만 결과로 집계됩니다.

  2. IGNORE NULLS 또는 RESPECT NULLS: IGNORE NULLS가 지정되거나 아무것도 지정되지 않으면 NULL 값이 결과에서 제외됩니다. RESPECT NULLS가 지정되면 결과에 NULL 값이 포함됩니다. 하지만 최종 쿼리 결과 배열에 NULL 요소가 포함되는 경우 오류가 발생합니다.

반환되는 데이터 유형

expression 매개변수에 의해 지정된 유형의 ARRAY.

0이 입력된 행이 있거나 expression이 모든 행에서 NULL로 평가되는 경우 NULL을 반환합니다.

예시

SELECT APPROX_QUANTILES(x, 2) AS approx_quantiles
FROM UNNEST([NULL, NULL, 1, 1, 1, 4, 5, 6, 7, 8, 9, 10]) AS x;

+------------------+
| approx_quantiles |
+------------------+
| [1, 5, 10]       |
+------------------+

SELECT APPROX_QUANTILES(x, 100)[OFFSET(90)] AS percentile_90
FROM UNNEST([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) AS x;

+---------------+
| percentile_90 |
+---------------+
| 9             |
+---------------+

SELECT APPROX_QUANTILES(DISTINCT x, 2) AS approx_quantiles
FROM UNNEST([NULL, NULL, 1, 1, 1, 4, 5, 6, 7, 8, 9, 10]) AS x;

+------------------+
| approx_quantiles |
+------------------+
| [1, 6, 10]       |
+------------------+

SELECT FORMAT("%T", APPROX_QUANTILES(x, 2 RESPECT NULLS)) AS approx_quantiles
FROM UNNEST([NULL, NULL, 1, 1, 1, 4, 5, 6, 7, 8, 9, 10]) AS x;

+------------------+
| approx_quantiles |
+------------------+
| [NULL, 4, 10]    |
+------------------+

SELECT FORMAT("%T", APPROX_QUANTILES(DISTINCT x, 2 RESPECT NULLS)) AS approx_quantiles
FROM UNNEST([NULL, NULL, 1, 1, 1, 4, 5, 6, 7, 8, 9, 10]) AS x;

+------------------+
| approx_quantiles |
+------------------+
| [NULL, 6, 10]    |
+------------------+

APPROX_TOP_COUNT

APPROX_TOP_COUNT(expression, number)

설명

expression의 근사치 최상위 요소를 반환합니다. number 매개변수는 반환되는 요소의 수를 지정합니다.

지원되는 인수 유형

expressionGROUP BY 절이 지원하는 모든 데이터 유형이 될 수 있습니다.

number는 INT64여야 합니다.

반환되는 데이터 유형

STRUCT 유형의 ARRAY입니다. STRUCT에는 2개의 필드가 포함됩니다. 첫 번째 필드(value)에는 입력 값이 포함됩니다. 두 번째 필드(count)에는 값이 반환된 횟수를 나타내는 INT64가 포함됩니다.

0이 입력된 행이 있으면 NULL을 반환합니다.

예시

SELECT APPROX_TOP_COUNT(x, 2) as approx_top_count
FROM UNNEST(["apple", "apple", "pear", "pear", "pear", "banana"]) as x;

+-------------------------+
| approx_top_count        |
+-------------------------+
| [{pear, 3}, {apple, 2}] |
+-------------------------+

NULL 처리

APPROX_TOP_COUNT는 입력에서 NULL을 무시하지 않습니다. 예를 들면 다음과 같습니다.

SELECT APPROX_TOP_COUNT(x, 2) as approx_top_count
FROM UNNEST([NULL, "pear", "pear", "pear", "apple", NULL]) as x;

+------------------------+
| approx_top_count       |
+------------------------+
| [{pear, 3}, {NULL, 2}] |
+------------------------+

APPROX_TOP_SUM

APPROX_TOP_SUM(expression, weight, number)

설명

할당된 weight의 합계를 바탕으로 expression의 근사치 최상위 요소를 반환합니다. number 매개변수는 반환되는 요소의 수를 지정합니다.

weight 입력이 음수이거나 NaN이면 이 함수는 오류를 반환합니다.

지원되는 인수 유형

expressionGROUP BY 절이 지원하는 모든 데이터 유형이 될 수 있습니다.

weight는 다음 중 하나여야 합니다.

  • INT64
  • FLOAT64

number는 INT64여야 합니다.

반환되는 데이터 유형

유형 STRUCT의 ARRAY입니다. STRUCT에는 valuesum이라는 2개의 필드가 포함됩니다. value 필드에는 입력 표현식의 값이 포함됩니다. sum 필드는 weight와 같은 유형으로, value 필드에 연결된 입력 가중치의 근사치 합계입니다.

0이 입력된 행이 있으면 NULL을 반환합니다.

예시

SELECT APPROX_TOP_SUM(x, weight, 2) AS approx_top_sum FROM
UNNEST([
  STRUCT("apple" AS x, 3 AS weight),
  ("pear", 2),
  ("apple", 0),
  ("banana", 5),
  ("pear", 4)
]);

+--------------------------+
| approx_top_sum           |
+--------------------------+
| [{pear, 6}, {banana, 5}] |
+--------------------------+

NULL 처리

APPROX_TOP_SUM은 expressionweight 매개변수의 NULL 값을 무시하지 않습니다.

SELECT APPROX_TOP_SUM(x, weight, 2) AS approx_top_sum FROM
UNNEST([STRUCT("apple" AS x, NULL AS weight), ("pear", 0), ("pear", NULL)]);

+----------------------------+
| approx_top_sum             |
+----------------------------+
| [{pear, 0}, {apple, NULL}] |
+----------------------------+
SELECT APPROX_TOP_SUM(x, weight, 2) AS approx_top_sum FROM
UNNEST([STRUCT("apple" AS x, 0 AS weight), (NULL, 2)]);

+-------------------------+
| approx_top_sum          |
+-------------------------+
| [{NULL, 2}, {apple, 0}] |
+-------------------------+
SELECT APPROX_TOP_SUM(x, weight, 2) AS approx_top_sum FROM
UNNEST([STRUCT("apple" AS x, 0 AS weight), (NULL, NULL)]);

+----------------------------+
| approx_top_sum             |
+----------------------------+
| [{apple, 0}, {NULL, NULL}] |
+----------------------------+

HyperLogLog++ 함수

BigQuery는 HyperLogLog++ 알고리즘을 사용하여 다음 근사치 집계 함수를 지원합니다. 근사치 집계 함수의 작동 방식에 대한 설명은 근사치 집계를 참조하세요.

HLL_COUNT.INIT

HLL_COUNT.INIT(input [, precision])

설명

input 값을 한 개 이상 취해 HyperLogLog++ 스케치로 집계하는 집계 함수입니다. 각 스케치는 BYTES 데이터 유형을 사용하여 나타냅니다. HLL_COUNT.MERGE 또는 HLL_COUNT.MERGE_PARTIAL을 사용하여 스케치를 병합할 수 있습니다. 병합이 필요하지 않다면 HLL_COUNT.EXTRACT를 사용하여 스케치에서 고유 값의 최종 개수를 추출할 수 있습니다.

input은 다음 중 하나가 될 수 있습니다.

  • INT64
  • STRING
  • BYTES

이 함수는 선택적 매개변수인 precision을 지원합니다. 이 매개변수는 추정의 정확성을 정의하지만 그 대신 스케치를 처리하거나 디스크에 저장하려면 메모리가 추가로 필요합니다. 아래 표는 허용되는 정밀도 값, 그룹당 최대 스케치 크기, 일반적 정밀도의 신뢰 구간(CI)을 보여 줍니다.

정밀도 최대 스케치 크기(KiB) 65% CI 95% CI 99% CI
10 1 ±1.63% ±3.25% ±6.50%
11 2 ±1.15% ±2.30% ±4.60%
12 4 ±0.81% ±1.63% ±3.25%
13 8 ±0.57% ±1.15% ±1.72%
14 16 ±0.41% ±0.81% ±1.22%
15(기본값) 32 ±0.29% ±0.57% ±0.86%
16 64 ±0.20% ±0.41% ±0.61%
17 128 ±0.14% ±0.29% ±0.43%
18 256 ±0.10% ±0.20% ±0.41%
19 512 ±0.07% ±0.14% ±0.29%
20 1024 ±0.05% ±0.10% ±0.20%
21 2048 ±0.04% ±0.07% ±0.14%
22 4096 ±0.03% ±0.05% ±0.10%
23 8192 ±0.02% ±0.04% ±0.07%
24 16384 ±0.01% ±0.03% ±0.05%

입력이 NULL이면 이 함수는 NULL을 반환합니다.

자세한 내용은 HyperLogLog 실무: 첨단 카디널리티 추정 알고리즘의 알고리즘 엔지니어링을 참조하세요.

지원되는 입력 유형

BYTES

반환 유형

BYTES

예시

SELECT
  HLL_COUNT.INIT(respondent) AS respondents_hll,
  flavor,
  country
FROM UNNEST([
  STRUCT(1 AS respondent, "Vanilla" AS flavor, "CH" AS country),
  (1, "Chocolate", "CH"),
  (2, "Chocolate", "US"),
  (2, "Strawberry", "US")])
GROUP BY flavor, country;

HLL_COUNT.MERGE

HLL_COUNT.MERGE(sketch)

설명

여러 HyperLogLog++ 세트 스케치의 공용 구조체를 계산하여 해당 카디널리티를 반환하는 집계 함수입니다.

sketch의 정밀도는 동일해야 하고 동일한 유형에서 초기화되어야 합니다. 정밀도가 다른 스케치를 병합하거나 다른 유형에서 병합하려고 시도하면 오류가 발생합니다. 예를 들어 INT64 데이터에서 초기화된 스케치는 STRING 데이터에서 초기화된 스케치와 병합할 수 없습니다.

이 함수는 스케치를 병합할 때 NULL 값을 무시합니다. 0개의 행에서 또는 NULL 값에서만 병합이 이루어지는 경우, 함수는 0을 반환합니다.

지원되는 입력 유형

BYTES

반환 유형

INT64

예시

SELECT HLL_COUNT.MERGE(respondents_hll) AS num_respondents, flavor
FROM (
  SELECT
    HLL_COUNT.INIT(respondent) AS respondents_hll,
    flavor,
    country
  FROM UNNEST([
    STRUCT(1 AS respondent, "Vanilla" AS flavor, "CH" AS country),
    (1, "Chocolate", "CH"),
    (2, "Chocolate", "US"),
    (2, "Strawberry", "US")])
  GROUP BY flavor, country)
GROUP BY flavor;

HLL_COUNT.MERGE_PARTIAL

HLL_COUNT.MERGE_PARTIAL(sketch)

설명

HyperLogLog++ sketch 입력을 한 개 이상 취해 새로운 스케치로 병합하는 집계 함수입니다.

이 함수는 입력이 없거나 모든 입력이 NULL일 경우 NULL을 반환합니다.

지원되는 입력 유형

BYTES

반환 유형

BYTES

예시

SELECT HLL_COUNT.MERGE_PARTIAL(respondents_hll) AS num_respondents, flavor
FROM (
  SELECT
    HLL_COUNT.INIT(respondent) AS respondents_hll,
    flavor,
    country
  FROM UNNEST([
    STRUCT(1 AS respondent, "Vanilla" AS flavor, "CH" AS country),
    (1, "Chocolate", "CH"),
    (2, "Chocolate", "US"),
    (2, "Strawberry", "US")])
  GROUP BY flavor, country)
GROUP BY flavor;

HLL_COUNT.EXTRACT

HLL_COUNT.EXTRACT(sketch)

설명

단일 HyperLogLog++ 스케치의 카디널리티 추정치를 추출하는 스칼라 함수입니다.

sketch가 NULL이면 이 함수는 0 카디널리티 추정치를 반환합니다.

지원되는 입력 유형

BYTES

반환 유형

INT64

예시

SELECT
  flavor,
  country,
  HLL_COUNT.EXTRACT(respondents_hll) AS num_respondents
FROM (
  SELECT
    HLL_COUNT.INIT(respondent) AS respondents_hll,
    flavor,
    country
  FROM UNNEST([
    STRUCT(1 AS respondent, "Vanilla" AS flavor, "CH" AS country),
    (1, "Chocolate", "CH"),
    (2, "Chocolate", "US"),
    (2, "Strawberry", "US")])
  GROUP BY flavor, country);

+------------+---------+-----------------+
| flavor     | country | num_respondents |
+------------+---------+-----------------+
| Vanilla    | CH      | 1               |
| Chocolate  | CH      | 1               |
| Chocolate  | US      | 1               |
| Strawberry | US      | 1               |
+------------+---------+-----------------+

번호 지정 함수

다음 섹션은 BigQuery가 지원하는 번호 지정 함수를 설명합니다. 번호 지정 함수는 분석 함수의 하위 집합입니다. 분석 함수의 작동 방식에 대한 설명은 분석 함수 개념을 참조하세요. 번호 지정 함수의 작동 방식에 대한 설명은 번호 지정 함수 개념을 참조하세요.

OVER 절 요구사항:

  • PARTITION BY: 선택사항입니다.
  • ORDER BY: ROW_NUMBER()를 제외하고 필수입니다.
  • window_frame_clause: 허용되지 않습니다.

RANK

설명

순서가 지정된 파티션 내 각 행의 서수(1부터 시작) 순위를 반환합니다. 모든 피어 행은 동일한 순위 값을 받습니다. 다음 행 또는 피어 행 집합은 항상 1씩 증가하는 DENSE_RANK 대신 이전 순위 값의 피어 수만큼 증가하는 순위 값을 받습니다.

지원되는 인수 유형

INT64

DENSE_RANK

설명

윈도우 파티션 내 각 행의 서수(1부터 시작) 순위를 반환합니다. 모든 피어 행은 동일한 순위 값을 받으며, 이후의 순위 값은 1씩 증가합니다.

지원되는 인수 유형

INT64

PERCENT_RANK

설명

(RK-1)/(NR-1)로 정의된 행의 백분위수 순위를 반환합니다. 여기서 RK는 행의 RANK이고 NR은 파티션에 있는 행의 수입니다. NR=1이면 0을 반환합니다.

지원되는 인수 유형

FLOAT64

CUME_DIST

설명

NP/NR로 정의된 행의 상대적 순위를 반환합니다. NP는 현재 행보다 선행하거나 현재 행과 피어인 행의 수로 정의됩니다. NR은 파티션에 있는 행의 수입니다.

지원되는 인수 유형

FLOAT64

NTILE

NTILE(constant_integer_expression)

설명

이 함수는 행 순서에 따라 행을 constant_integer_expression 버킷으로 나누고 각 행에 할당된 버킷 번호(1부터 시작)를 반환합니다. 버킷에 있는 행의 번호는 최대 1만큼 다를 수 있습니다. 나머지 값(버킷으로 나눈 행의 나머지 번호)은 버킷 1부터 시작하여 각 버킷에 하나씩 분배됩니다. constant_integer_expression이 NULL, 0 또는 음수로 평가되면 오류가 생성됩니다.

지원되는 인수 유형

INT64

ROW_NUMBER

설명

ORDER BY 절이 필요하지 않습니다. 순서가 지정된 파티션마다 각 행의 순차 행 서수(1부터 시작)를 반환합니다. ORDER BY 절이 지정되지 않으면 결과는 비확정적입니다.

지원되는 인수 유형

INT64

비트 함수

BigQuery는 다음 비트 함수를 지원합니다.

BIT_COUNT

BIT_COUNT(expression)

설명

입력 expression은 정수 또는 BYTES여야 합니다.

입력 expression에 설정된 비트 수를 반환합니다. 부호 있는 정수의 경우, 2의 보수 형식의 비트 수입니다.

반환 데이터 유형

INT64

예시

SELECT a, BIT_COUNT(a) AS a_bits, FORMAT("%T", b) as b, BIT_COUNT(b) AS b_bits
FROM UNNEST([
  STRUCT(0 AS a, b'' AS b), (0, b'\x00'), (5, b'\x05'), (8, b'\x00\x08'),
  (0xFFFF, b'\xFF\xFF'), (-2, b'\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFE'),
  (-1, b'\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF'),
  (NULL, b'\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF')
]) AS x;

+-------+--------+---------------------------------------------+--------+
| a     | a_bits | b                                           | b_bits |
+-------+--------+---------------------------------------------+--------+
| 0     | 0      | b""                                         | 0      |
| 0     | 0      | b"\x00"                                     | 0      |
| 5     | 2      | b"\x05"                                     | 2      |
| 8     | 1      | b"\x00\x08"                                 | 1      |
| 65535 | 16     | b"\xff\xff"                                 | 16     |
| -2    | 63     | b"\xff\xff\xff\xff\xff\xff\xff\xfe"         | 63     |
| -1    | 64     | b"\xff\xff\xff\xff\xff\xff\xff\xff"         | 64     |
| NULL  | NULL   | b"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" | 80     |
+-------+--------+---------------------------------------------+--------+

수학 함수

모든 수학 함수는 다음과 같이 동작합니다.

  • 입력 매개변수 중 하나가 NULL인 경우 NULL을 반환합니다.
  • 인수 중 하나가 NaN인 경우 NaN을 반환합니다.

ABS

ABS(X)

설명

절대값을 계산합니다. 인수가 정수이고 출력값을 동일한 유형으로 나타낼 수 없는 경우 오류를 반환합니다. 양의 표현이 없는 최대 음의 입력값의 경우에만 이 오류가 발생합니다. +/-inf 인수의 경우 +inf를 반환합니다.

SIGN

SIGN(X)

설명

음의 인수, 0, 양의 인수에 각각 -1, 0, +1을 반환합니다. 이 함수는 부동 소수점 인수의 양의 0과 음의 0을 구별하지 않습니다. NaN 인수에는 NaN을 반환합니다.

IS_INF

IS_INF(X)

설명

값이 양의 무한대이거나 음의 무한대이면 TRUE를 반환합니다. NULL 입력에는 NULL을 반환합니다.

IS_NAN

IS_NAN(X)

설명

값이 NaN 값이면 TRUE를 반환합니다. NULL 입력에는 NULL을 반환합니다.

IEEE_DIVIDE

IEEE_DIVIDE(X, Y)

설명

X를 Y로 나눕니다. 이 함수는 절대 실패하지 않습니다. FLOAT64를 반환합니다. 나누기 연산자(/)와 달리 이 함수는 0으로 나누기 또는 오버플로 오류를 생성하지 않습니다.

특수한 경우:

  • 결과가 오버플로인 경우, +/-inf를 반환합니다.
  • Y=0이고 X=0이면, NaN을 반환합니다.
  • Y=0이고 X!=0이면, +/-inf를 반환합니다.
  • X = +/-inf이고 Y = +/-inf이면, NaN을 반환합니다.

IEEE_DIVIDE의 동작이 아래 표에 자세히 설명되어 있습니다.

IEEE_DIVIDE의 특수한 경우

아래 표는 IEEE_DIVIDE의 특수한 경우를 나열한 것입니다.

분자 데이터 유형(X) 분모 데이터 유형(Y) 결과 값
0을 제외한 모든 유형 0 +/-inf
0 0 NaN
0 NaN NaN
NaN 0 NaN
+/-inf +/-inf NaN

RAND

RAND()

설명

[0, 1) 범위(0은 포함, 1은 제외)에 있는 FLOAT64 유형의 의사 난수 값을 생성합니다.

SQRT

SQRT(X)

설명

X의 제곱근을 계산합니다. X가 0보다 작은 경우 오류를 생성합니다. X가 +inf인 경우 +inf를 반환합니다.

POW

POW(X, Y)

설명

X의 Y제곱 값을 반환합니다. 결과가 언더플로이고 나타낼 수 없는 경우, 이 함수는 0 값을 반환합니다. 다음 중 하나가 참이면 오류를 반환합니다.

  • X는 0보다 작은 유한한 값이고 Y는 정수가 아닙니다.
  • X는 0이고 Y는 0보다 작은 유한한 값입니다.

POW()의 동작이 아래 표에 자세히 설명되어 있습니다.

POWER

POWER(X, Y)

설명

POW()의 동의어입니다.

POW(X, Y)POWER(X, Y)의 특수한 경우

다음은 POW(X, Y)POWER(X, Y)의 특수한 경우입니다.

X Y POW(X, Y) 또는 POWER(X, Y)
1.0 NaN을 포함한 모든 값 1.0
NaN을 포함한 모든 값 0 1.0
-1.0 +/-inf 1.0
ABS(X) < 1 -inf +inf
ABS(X) > 1 -inf 0
ABS(X) < 1 +inf 0
ABS(X) > 1 +inf +inf
-inf Y < 0 0
-inf Y > 0 Y가 홀수이면 -inf, 그렇지 않으면 +inf
+inf Y < 0 0
+inf Y > 0 +inf

EXP

EXP(X)

설명

e의 X승을 계산합니다. 자연 지수 함수라고도 합니다. 결과가 언더플로인 경우, 이 함수는 0을 반환합니다. 결과가 오버플로인 경우 오류를 생성합니다. X가 +/-inf이면 이 함수는 +inf 또는 0을 반환합니다.

LN

LN(X)

설명

X의 자연로그를 계산합니다. X가 0 이하이면 오류를 생성합니다. X가 +inf인 경우, 이 함수는 +inf를 반환합니다.

LOG

LOG(X [, Y])

설명

X만 존재하는 경우, LOGLN의 동의어입니다. Y도 존재한다면, LOG는 Y를 밑으로 하는 X의 로그를 계산합니다. 다음의 경우 오류를 생성합니다.

  • X가 0 이하인 경우
  • Y가 1.0인 경우
  • Y가 0 이하인 경우

LOG(X, Y)의 동작이 아래 표에 자세히 설명되어 있습니다.

LOG(X, Y)의 특수한 경우

X Y LOG(X, Y)
-inf 모든 값 NaN
모든 값 +inf NaN
+inf 0.0 Y < 1.0 -inf
+inf Y > 1.0 +inf

LOG10

LOG10(X)

설명

LOG와 유사하되, 10을 밑으로 한 로그를 계산합니다.

GREATEST

GREATEST(X1,...,XN)

설명

입력 중에 NULL이 있으면 NULL을 반환하고, 입력 중에 NaN이 있으면 NaN을 반환합니다. 그렇지 않을 경우 < 비교에 따라 X1,...,XN 중 가장 큰 값을 반환합니다.

LEAST

LEAST(X1,...,XN)

설명

입력 중에 NULL이 있으면 NULL을 반환하고, 입력 중에 NaN이 있으면 NaN을 반환합니다. 그렇지 않을 경우 > 비교에 따라 X1,...,XN 중 가장 작은 값을 반환합니다.

DIV

DIV(X, Y)

설명

X/Y의 정수 나누기 결과를 반환합니다. 0으로 나눌 경우 오류를 반환합니다. -1로 나누면 오버플로가 발생할 수 있습니다. 가능한 결과 유형은 아래 표를 참조하세요.

SAFE_DIVIDE

SAFE_DIVIDE(X, Y)

설명

나누기 연산자(/)와 동일하지만 0으로 나누기 오류와 같은 오류가 발생하면 NULL을 반환합니다.

SAFE_MULTIPLY

SAFE_MULTIPLY(X, Y)

설명

곱하기 연산자(*)와 동일하지만 오버플로가 발생하면 NULL을 반환합니다.

SAFE_NEGATE

SAFE_NEGATE(X)

설명

단행 빼기 연산자(-)와 동일하지만 오버플로가 발생하면 NULL을 반환합니다.

SAFE_ADD

SAFE_ADD(X, Y)

설명

더하기 연산자(+)와 동일하지만 오버플로가 발생하면 NULL을 반환합니다.

SAFE_SUBTRACT

SAFE_SUBTRACT(X, Y)

설명

빼기 연산자(-)와 동일하지만 오버플로가 발생하면 NULL을 반환합니다.

MOD

MOD(X, Y)

설명

모듈로 함수: X를 Y로 나눈 나머지를 반환합니다. 반환되는 값은 X와 동일한 기호를 갖습니다. Y가 0이면 오류가 생성됩니다. 결과 유형은 아래 표를 참조하세요.

ROUND

ROUND(X [, N])

설명

X만 존재하는 경우, ROUND는 X를 가장 가까운 정수로 반올림합니다. N이 존재하는 경우, ROUND는 X를 소수점 아래 N자리까지 반올림합니다. N이 음수이면 ROUND 는 소수점 왼쪽의 자릿수를 반올림합니다. 중간 값은 올림됩니다. 오버플로가 발생하면 오류를 생성합니다.

TRUNC

TRUNC(X [, N])

설명

X만 존재하는 경우, TRUNC는 절대값이 X의 절대값 이하인 가장 가까운 정수로 X를 반올림합니다. N도 존재할 경우, TRUNCROUND(X, N)와 유사하게 동작하지만, 항상 0쪽으로 반올림하며 절대 오버플로가 발생하지 않습니다.

CEIL

CEIL(X)

설명

X보다 작지 않은 가장 작은 정수 값(FLOAT64 유형)을 반환합니다.

CEILING

CEILING(X)

설명

CEIL(X)의 동의어

FLOOR

FLOOR(X)

설명

X보다 크지 않은 가장 큰 정수 값(FLOAT64 유형)을 반환합니다.

반올림 함수의 동작 예

BigQuery 반올림 함수의 동작 예:

입력 'X' ROUND(X) TRUNC(X) CEIL(X) FLOOR(X)
2.0 2.0 2.0 2.0 2.0
2.3 2.0 2.0 3.0 2.0
2.8 3.0 2.0 3.0 2.0
2.5 3.0 2.0 3.0 2.0
-2.3 -2.0 -2.0 -2.0 -3.0
-2.8 -3.0 -2.0 -2.0 -3.0
-2.5 -3.0 -2.0 -2.0 -3.0
0 0 0 0 0
+/-inf +/-inf +/-inf +/-inf +/-inf
NaN NaN NaN NaN NaN

COS

COS(X)

설명

라디안으로 지정된 X의 코사인을 계산합니다. 어떠한 경우에도 오류가 발생하지 않습니다.

COSH

COSH(X)

설명

라디안으로 지정된 X의 쌍곡선 코사인을 계산합니다. 오버플로가 발생하면 오류를 생성합니다.

ACOS

ACOS(X)

설명

X의 역코사인 주요 값을 계산합니다. 반환 값의 범위는 [0,π]입니다. X의 값이 [-1, 1] 범위를 벗어나면 오류를 생성합니다.

ACOSH

ACOSH(X)

설명

X의 역쌍곡선 코사인을 계산합니다. X의 값이 1 이하이면 오류를 생성합니다.

SIN

SIN(X)

설명

라디안으로 지정된 X의 사인을 계산합니다. 어떠한 경우에도 오류가 발생하지 않습니다.

SINH

SINH(X)

설명

라디안으로 지정된 X의 쌍곡선 사인을 계산합니다. 오버플로가 발생하면 오류를 생성합니다.

ASIN

ASIN(X)

설명

X의 역사인 주요 값을 계산합니다. 반환 값의 범위는 [-π/2,π/2]입니다. X의 값이 [-1, 1] 범위를 벗어나면 오류를 생성합니다.

ASINH

ASINH(X)

설명

X의 역쌍곡사인을 계산합니다. 실패하지 않습니다.

TAN

TAN(X)

설명

라디안으로 지정된 X의 탄젠트를 계산합니다. 오버플로가 발생하면 오류를 생성합니다.

TANH

TANH(X)

설명

라디안으로 지정된 X의 쌍곡선 탄젠트를 계산합니다. 오류가 발생하지 않습니다.

ATAN

ATAN(X)

설명

X의 역탄젠트 주요 값을 계산합니다. 반환 값의 범위는 [-π/2,π/2]입니다. 오류가 발생하지 않습니다.

ATANH

ATANH(X)

설명

X의 역쌍곡선 탄젠트를 계산합니다. X의 값이 [-1, 1] 범위를 벗어나면 오류를 생성합니다.

ATAN2

ATAN2(Y, X)

설명

사분면을 결정하기 위해 두 인수의 기호를 사용하여 Y/X의 역탄젠트 주요 값을 계산합니다. 반환 값은 [-π,π] 범위 이내입니다. 이 함수의 동작은 아래 표에 자세하게 설명되어 있습니다.

ATAN2()의 특수한 경우

Y X ATAN2(Y, X)
NaN 모든 값 NaN
모든 값 NaN NaN
0 0 X와 Y의 기호에 따라 0, π, 또는 -π
유한한 값 -inf Y의 기호에 따라 π 또는 -π
유한한 값 +inf 0
+/-inf 유한한 값 Y의 기호에 따라 π/2 또는 π/2
+/-inf -inf Y의 기호에 따라 ¾π 또는 -¾π
+/-inf +inf Y의 기호에 따라 π/4 또는 -π/4

삼각 반올림 함수와 쌍곡선 반올림 함수의 특수한 경우

X COS(X) COSH(X) ACOS(X) ACOSH(X) SIN(X) SINH(X) ASIN(X) ASINH(X) TAN(X) TANH(X) ATAN(X) ATANH(X)
+/-inf NaN =+inf NaN =+inf NaN =+inf NaN =+inf NaN =+1.0 π/2 NaN
-inf NaN =+inf NaN NaN NaN -inf NaN -inf NaN -1.0 -π/2 NaN
NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN

다음 섹션에서는 BigQuery가 지원하는 탐색 함수를 설명합니다. 탐색 함수는 분석 함수의 하위 집합입니다. 분석 함수의 작동 방식에 대한 설명은 분석 함수 개념을 참조하세요. 탐색 함수의 작동 방식에 대한 설명은 탐색 함수 개념을 참조하세요.

FIRST_VALUE

FIRST_VALUE (value_expression [{RESPECT | IGNORE} NULLS])

설명

현재 창 프레임에 있는 첫 번째 행의 value_expression 값을 반환합니다.

이 함수는 IGNORE NULLS가 없으면 계산에 NULL 값을 포함합니다. IGNORE NULLS가 있으면 이 함수는 계산에서 NULL 값을 제외합니다.

지원되는 인수 유형

value_expression은 표현식이 반환할 수 있는 모든 데이터 유형이 될 수 있습니다.

반환 데이터 유형

모두

예시

다음 예는 각 나누기의 가장 빠른 시간을 계산합니다.

WITH finishers AS
 (SELECT 'Sophia Liu' as name,
  TIMESTAMP '2016-10-18 2:51:45' as finish_time,
  'F30-34' as division
  UNION ALL SELECT 'Lisa Stelzner', TIMESTAMP '2016-10-18 2:54:11', 'F35-39'
  UNION ALL SELECT 'Nikki Leith', TIMESTAMP '2016-10-18 2:59:01', 'F30-34'
  UNION ALL SELECT 'Lauren Matthews', TIMESTAMP '2016-10-18 3:01:17', 'F35-39'
  UNION ALL SELECT 'Desiree Berry', TIMESTAMP '2016-10-18 3:05:42', 'F35-39'
  UNION ALL SELECT 'Suzy Slane', TIMESTAMP '2016-10-18 3:06:24', 'F35-39'
  UNION ALL SELECT 'Jen Edwards', TIMESTAMP '2016-10-18 3:06:36', 'F30-34'
  UNION ALL SELECT 'Meghan Lederer', TIMESTAMP '2016-10-18 3:07:41', 'F30-34'
  UNION ALL SELECT 'Carly Forte', TIMESTAMP '2016-10-18 3:08:58', 'F25-29'
  UNION ALL SELECT 'Lauren Reasoner', TIMESTAMP '2016-10-18 3:10:14', 'F30-34')
SELECT name,
  FORMAT_TIMESTAMP('%X', finish_time) AS finish_time,
  division,
  FORMAT_TIMESTAMP('%X', fastest_time) AS fastest_time,
  TIMESTAMP_DIFF(finish_time, fastest_time, SECOND) AS delta_in_seconds
FROM (
  SELECT name,
  finish_time,
  division,
  FIRST_VALUE(finish_time)
    OVER (PARTITION BY division ORDER BY finish_time ASC
    ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) AS fastest_time
  FROM finishers);

+-----------------+-------------+----------+--------------+------------------+
| name            | finish_time | division | fastest_time | delta_in_seconds |
+-----------------+-------------+----------+--------------+------------------+
| Carly Forte     | 03:08:58    | F25-29   | 03:08:58     | 0                |
| Sophia Liu      | 02:51:45    | F30-34   | 02:51:45     | 0                |
| Nikki Leith     | 02:59:01    | F30-34   | 02:51:45     | 436              |
| Jen Edwards     | 03:06:36    | F30-34   | 02:51:45     | 891              |
| Meghan Lederer  | 03:07:41    | F30-34   | 02:51:45     | 956              |
| Lauren Reasoner | 03:10:14    | F30-34   | 02:51:45     | 1109             |
| Lisa Stelzner   | 02:54:11    | F35-39   | 02:54:11     | 0                |
| Lauren Matthews | 03:01:17    | F35-39   | 02:54:11     | 426              |
| Desiree Berry   | 03:05:42    | F35-39   | 02:54:11     | 691              |
| Suzy Slane      | 03:06:24    | F35-39   | 02:54:11     | 733              |
+-----------------+-------------+----------+--------------+------------------+

LAST_VALUE

LAST_VALUE (value_expression [{RESPECT | IGNORE} NULLS])

설명

현재 창 프레임에 있는 마지막 행의 value_expression 값을 반환합니다.

이 함수는 IGNORE NULLS가 없으면 계산에 NULL 값을 포함합니다. IGNORE NULLS가 있으면 이 함수는 계산에서 NULL 값을 제외합니다.

지원되는 인수 유형

value_expression은 표현식이 반환할 수 있는 모든 데이터 유형이 될 수 있습니다.

반환 데이터 유형

모두

예시

다음 예는 각 나누기의 가장 느린 시간을 계산합니다.

WITH finishers AS
 (SELECT 'Sophia Liu' as name,
  TIMESTAMP '2016-10-18 2:51:45' as finish_time,
  'F30-34' as division
  UNION ALL SELECT 'Lisa Stelzner', TIMESTAMP '2016-10-18 2:54:11', 'F35-39'
  UNION ALL SELECT 'Nikki Leith', TIMESTAMP '2016-10-18 2:59:01', 'F30-34'
  UNION ALL SELECT 'Lauren Matthews', TIMESTAMP '2016-10-18 3:01:17', 'F35-39'
  UNION ALL SELECT 'Desiree Berry', TIMESTAMP '2016-10-18 3:05:42', 'F35-39'
  UNION ALL SELECT 'Suzy Slane', TIMESTAMP '2016-10-18 3:06:24', 'F35-39'
  UNION ALL SELECT 'Jen Edwards', TIMESTAMP '2016-10-18 3:06:36', 'F30-34'
  UNION ALL SELECT 'Meghan Lederer', TIMESTAMP '2016-10-18 3:07:41', 'F30-34'
  UNION ALL SELECT 'Carly Forte', TIMESTAMP '2016-10-18 3:08:58', 'F25-29'
  UNION ALL SELECT 'Lauren Reasoner', TIMESTAMP '2016-10-18 3:10:14', 'F30-34')
SELECT name,
  FORMAT_TIMESTAMP('%X', finish_time) AS finish_time,
  division,
  FORMAT_TIMESTAMP('%X', slowest_time) AS slowest_time,
  TIMESTAMP_DIFF(slowest_time, finish_time, SECOND) AS delta_in_seconds
FROM (
  SELECT name,
  finish_time,
  division,
  LAST_VALUE(finish_time)
    OVER (PARTITION BY division ORDER BY finish_time ASC
    ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) AS slowest_time
  FROM finishers);

+-----------------+-------------+----------+--------------+------------------+
| name            | finish_time | division | slowest_time | delta_in_seconds |
+-----------------+-------------+----------+--------------+------------------+
| Carly Forte     | 03:08:58    | F25-29   | 03:08:58     | 0                |
| Sophia Liu      | 02:51:45    | F30-34   | 03:10:14     | 1109             |
| Nikki Leith     | 02:59:01    | F30-34   | 03:10:14     | 673              |
| Jen Edwards     | 03:06:36    | F30-34   | 03:10:14     | 218              |
| Meghan Lederer  | 03:07:41    | F30-34   | 03:10:14     | 153              |
| Lauren Reasoner | 03:10:14    | F30-34   | 03:10:14     | 0                |
| Lisa Stelzner   | 02:54:11    | F35-39   | 03:06:24     | 733              |
| Lauren Matthews | 03:01:17    | F35-39   | 03:06:24     | 307              |
| Desiree Berry   | 03:05:42    | F35-39   | 03:06:24     | 42               |
| Suzy Slane      | 03:06:24    | F35-39   | 03:06:24     | 0                |
+-----------------+-------------+----------+--------------+------------------+

NTH_VALUE

NTH_VALUE (value_expression, constant_integer_expression [{RESPECT | IGNORE} NULLS])

설명

현재 창 프레임에 있는 N번째 행의 value_expression 값을 반환합니다. N번째는 constant_integer_expression에 의해 정의됩니다. 이 행이 없으면 NULL을 반환합니다.

이 함수는 IGNORE NULLS가 없으면 계산에 NULL 값을 포함합니다. IGNORE NULLS가 있으면 이 함수는 계산에서 NULL 값을 제외합니다.

지원되는 인수 유형

  • value_expression은 표현식에서 반환될 수 있는 모든 데이터 유형이 될 수 있습니다.
  • constant_integer_expression은 정수를 반환하는 모든 상수 표현식이 될 수 있습니다.

반환 데이터 유형

모두

예시

WITH finishers AS
 (SELECT 'Sophia Liu' as name,
  TIMESTAMP '2016-10-18 2:51:45' as finish_time,
  'F30-34' as division
  UNION ALL SELECT 'Lisa Stelzner', TIMESTAMP '2016-10-18 2:54:11', 'F35-39'
  UNION ALL SELECT 'Nikki Leith', TIMESTAMP '2016-10-18 2:59:01', 'F30-34'
  UNION ALL SELECT 'Lauren Matthews', TIMESTAMP '2016-10-18 3:01:17', 'F35-39'
  UNION ALL SELECT 'Desiree Berry', TIMESTAMP '2016-10-18 3:05:42', 'F35-39'
  UNION ALL SELECT 'Suzy Slane', TIMESTAMP '2016-10-18 3:06:24', 'F35-39'
  UNION ALL SELECT 'Jen Edwards', TIMESTAMP '2016-10-18 3:06:36', 'F30-34'
  UNION ALL SELECT 'Meghan Lederer', TIMESTAMP '2016-10-18 3:07:41', 'F30-34'
  UNION ALL SELECT 'Carly Forte', TIMESTAMP '2016-10-18 3:08:58', 'F25-29'
  UNION ALL SELECT 'Lauren Reasoner', TIMESTAMP '2016-10-18 3:10:14', 'F30-34')
SELECT name,
  FORMAT_TIMESTAMP('%X', finish_time) AS finish_time,
  division,
  FORMAT_TIMESTAMP('%X', fastest_time) AS fastest_time,
  FORMAT_TIMESTAMP('%X', second_fastest) AS second_fastest
FROM (
  SELECT name,
  finish_time,
  division,finishers,
  FIRST_VALUE(finish_time)
    OVER w1 AS fastest_time,
  NTH_VALUE(finish_time, 2)
    OVER w1 as second_fastest
  FROM finishers
  WINDOW w1 AS (
    PARTITION BY division ORDER BY finish_time ASC
    ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING));

+-----------------+-------------+----------+--------------+----------------+
| name            | finish_time | division | fastest_time | second_fastest |
+-----------------+-------------+----------+--------------+----------------+
| Carly Forte     | 03:08:58    | F25-29   | 03:08:58     | NULL           |
| Sophia Liu      | 02:51:45    | F30-34   | 02:51:45     | 02:59:01       |
| Nikki Leith     | 02:59:01    | F30-34   | 02:51:45     | 02:59:01       |
| Jen Edwards     | 03:06:36    | F30-34   | 02:51:45     | 02:59:01       |
| Meghan Lederer  | 03:07:41    | F30-34   | 02:51:45     | 02:59:01       |
| Lauren Reasoner | 03:10:14    | F30-34   | 02:51:45     | 02:59:01       |
| Lisa Stelzner   | 02:54:11    | F35-39   | 02:54:11     | 03:01:17       |
| Lauren Matthews | 03:01:17    | F35-39   | 02:54:11     | 03:01:17       |
| Desiree Berry   | 03:05:42    | F35-39   | 02:54:11     | 03:01:17       |
| Suzy Slane      | 03:06:24    | F35-39   | 02:54:11     | 03:01:17       |
+-----------------+-------------+----------+--------------+----------------+

LEAD

LEAD (value_expression[, offset [, default_expression]])

설명

후속 행의 value_expression 값을 반환합니다. offset 값을 변경하면 반환되는 후속 행이 변경됩니다. 기본값은 1이며 창 프레임의 다음 행을 나타냅니다. offset이 NULL이거나 음수 값이면 오류가 발생합니다.

지정된 오프셋에서 창 프레임에 행이 없으면 선택사항인 default_expression이 사용됩니다. 이 표현식은 상수 표현식이어야 하며, 해당 유형은 value_expression 유형으로 묵시적 강제 변환이 가능해야 합니다. default_expression을 지정하지 않으면 기본값 NULL이 사용됩니다.

지원되는 인수 유형

  • value_expression은 표현식에서 반환될 수 있는 모든 데이터 유형이 될 수 있습니다.
  • offset은 음이 아닌 정수 리터럴 또는 매개변수여야 합니다.
  • default_expression은 값 표현식 유형과 호환되어야 합니다.

반환 데이터 유형

모두

예시

다음 예는 LEAD 함수의 기본적인 사용을 보여줍니다.

WITH finishers AS
 (SELECT 'Sophia Liu' as name,
  TIMESTAMP '2016-10-18 2:51:45' as finish_time,
  'F30-34' as division
  UNION ALL SELECT 'Lisa Stelzner', TIMESTAMP '2016-10-18 2:54:11', 'F35-39'
  UNION ALL SELECT 'Nikki Leith', TIMESTAMP '2016-10-18 2:59:01', 'F30-34'
  UNION ALL SELECT 'Lauren Matthews', TIMESTAMP '2016-10-18 3:01:17', 'F35-39'
  UNION ALL SELECT 'Desiree Berry', TIMESTAMP '2016-10-18 3:05:42', 'F35-39'
  UNION ALL SELECT 'Suzy Slane', TIMESTAMP '2016-10-18 3:06:24', 'F35-39'
  UNION ALL SELECT 'Jen Edwards', TIMESTAMP '2016-10-18 3:06:36', 'F30-34'
  UNION ALL SELECT 'Meghan Lederer', TIMESTAMP '2016-10-18 3:07:41', 'F30-34'
  UNION ALL SELECT 'Carly Forte', TIMESTAMP '2016-10-18 3:08:58', 'F25-29'
  UNION ALL SELECT 'Lauren Reasoner', TIMESTAMP '2016-10-18 3:10:14', 'F30-34')
SELECT name,
  finish_time,
  division,
  LEAD(name)
    OVER (PARTITION BY division ORDER BY finish_time ASC) AS followed_by
FROM finishers;

+-----------------+-------------+----------+-----------------+
| name            | finish_time | division | followed_by     |
+-----------------+-------------+----------+-----------------+
| Carly Forte     | 03:08:58    | F25-29   | NULL            |
| Sophia Liu      | 02:51:45    | F30-34   | Nikki Leith     |
| Nikki Leith     | 02:59:01    | F30-34   | Jen Edwards     |
| Jen Edwards     | 03:06:36    | F30-34   | Meghan Lederer  |
| Meghan Lederer  | 03:07:41    | F30-34   | Lauren Reasoner |
| Lauren Reasoner | 03:10:14    | F30-34   | NULL            |
| Lisa Stelzner   | 02:54:11    | F35-39   | Lauren Matthews |
| Lauren Matthews | 03:01:17    | F35-39   | Desiree Berry   |
| Desiree Berry   | 03:05:42    | F35-39   | Suzy Slane      |
| Suzy Slane      | 03:06:24    | F35-39   | NULL            |
+-----------------+-------------+----------+-----------------+

다음 예는 선택적 offset 매개변수를 사용합니다.

WITH finishers AS
 (SELECT 'Sophia Liu' as name,
  TIMESTAMP '2016-10-18 2:51:45' as finish_time,
  'F30-34' as division
  UNION ALL SELECT 'Lisa Stelzner', TIMESTAMP '2016-10-18 2:54:11', 'F35-39'
  UNION ALL SELECT 'Nikki Leith', TIMESTAMP '2016-10-18 2:59:01', 'F30-34'
  UNION ALL SELECT 'Lauren Matthews', TIMESTAMP '2016-10-18 3:01:17', 'F35-39'
  UNION ALL SELECT 'Desiree Berry', TIMESTAMP '2016-10-18 3:05:42', 'F35-39'
  UNION ALL SELECT 'Suzy Slane', TIMESTAMP '2016-10-18 3:06:24', 'F35-39'
  UNION ALL SELECT 'Jen Edwards', TIMESTAMP '2016-10-18 3:06:36', 'F30-34'
  UNION ALL SELECT 'Meghan Lederer', TIMESTAMP '2016-10-18 3:07:41', 'F30-34'
  UNION ALL SELECT 'Carly Forte', TIMESTAMP '2016-10-18 3:08:58', 'F25-29'
  UNION ALL SELECT 'Lauren Reasoner', TIMESTAMP '2016-10-18 3:10:14', 'F30-34')
SELECT name,
  finish_time,
  division,
  LEAD(name, 2)
    OVER (PARTITION BY division ORDER BY finish_time ASC) AS two_runners_back
FROM finishers;

+-----------------+-------------+----------+------------------+
| name            | finish_time | division | two_runners_back |
+-----------------+-------------+----------+------------------+
| Carly Forte     | 03:08:58    | F25-29   | NULL             |
| Sophia Liu      | 02:51:45    | F30-34   | Jen Edwards      |
| Nikki Leith     | 02:59:01    | F30-34   | Meghan Lederer   |
| Jen Edwards     | 03:06:36    | F30-34   | Lauren Reasoner  |
| Meghan Lederer  | 03:07:41    | F30-34   | NULL             |
| Lauren Reasoner | 03:10:14    | F30-34   | NULL             |
| Lisa Stelzner   | 02:54:11    | F35-39   | Desiree Berry    |
| Lauren Matthews | 03:01:17    | F35-39   | Suzy Slane       |
| Desiree Berry   | 03:05:42    | F35-39   | NULL             |
| Suzy Slane      | 03:06:24    | F35-39   | NULL             |
+-----------------+-------------+----------+------------------+

다음 예는 NULL 값을 기본값으로 바꿉니다.

WITH finishers AS
 (SELECT 'Sophia Liu' as name,
  TIMESTAMP '2016-10-18 2:51:45' as finish_time,
  'F30-34' as division
  UNION ALL SELECT 'Lisa Stelzner', TIMESTAMP '2016-10-18 2:54:11', 'F35-39'
  UNION ALL SELECT 'Nikki Leith', TIMESTAMP '2016-10-18 2:59:01', 'F30-34'
  UNION ALL SELECT 'Lauren Matthews', TIMESTAMP '2016-10-18 3:01:17', 'F35-39'
  UNION ALL SELECT 'Desiree Berry', TIMESTAMP '2016-10-18 3:05:42', 'F35-39'
  UNION ALL SELECT 'Suzy Slane', TIMESTAMP '2016-10-18 3:06:24', 'F35-39'
  UNION ALL SELECT 'Jen Edwards', TIMESTAMP '2016-10-18 3:06:36', 'F30-34'
  UNION ALL SELECT 'Meghan Lederer', TIMESTAMP '2016-10-18 3:07:41', 'F30-34'
  UNION ALL SELECT 'Carly Forte', TIMESTAMP '2016-10-18 3:08:58', 'F25-29'
  UNION ALL SELECT 'Lauren Reasoner', TIMESTAMP '2016-10-18 3:10:14', 'F30-34')
SELECT name,
  finish_time,
  division,
  LEAD(name, 2, 'Nobody')
    OVER (PARTITION BY division ORDER BY finish_time ASC) AS two_runners_back
FROM finishers;

+-----------------+-------------+----------+------------------+
| name            | finish_time | division | two_runners_back |
+-----------------+-------------+----------+------------------+
| Carly Forte     | 03:08:58    | F25-29   | Nobody           |
| Sophia Liu      | 02:51:45    | F30-34   | Jen Edwards      |
| Nikki Leith     | 02:59:01    | F30-34   | Meghan Lederer   |
| Jen Edwards     | 03:06:36    | F30-34   | Lauren Reasoner  |
| Meghan Lederer  | 03:07:41    | F30-34   | Nobody           |
| Lauren Reasoner | 03:10:14    | F30-34   | Nobody           |
| Lisa Stelzner   | 02:54:11    | F35-39   | Desiree Berry    |
| Lauren Matthews | 03:01:17    | F35-39   | Suzy Slane       |
| Desiree Berry   | 03:05:42    | F35-39   | Nobody           |
| Suzy Slane      | 03:06:24    | F35-39   | Nobody           |
+-----------------+-------------+----------+------------------+

LAG

LAG (value_expression[, offset [, default_expression]])

설명

이전 행의 value_expression 값을 반환합니다. offset 값을 변경하면 반환되는 이전 행이 변경됩니다. 기본값은 1이며 창 프레임의 이전 행을 나타냅니다. offset이 NULL이거나 음수 값이면 오류가 발생합니다.

지정된 오프셋에서 창 프레임에 행이 없으면 선택사항인 default_expression이 사용됩니다. 이 표현식은 상수 표현식이어야 하며, 해당 유형은 value_expression 유형으로 묵시적 강제 변환이 가능해야 합니다. default_expression을 지정하지 않으면 기본값 NULL이 사용됩니다.

지원되는 인수 유형

  • value_expression은 표현식에서 반환될 수 있는 모든 데이터 유형이 될 수 있습니다.
  • offset은 음이 아닌 정수 리터럴 또는 매개변수여야 합니다.
  • default_expression은 값 표현식 유형과 호환되어야 합니다.

반환 데이터 유형

모두

예시

다음 예는 LAG 함수의 기본적인 사용을 보여줍니다.

WITH finishers AS
 (SELECT 'Sophia Liu' as name,
  TIMESTAMP '2016-10-18 2:51:45' as finish_time,
  'F30-34' as division
  UNION ALL SELECT 'Lisa Stelzner', TIMESTAMP '2016-10-18 2:54:11', 'F35-39'
  UNION ALL SELECT 'Nikki Leith', TIMESTAMP '2016-10-18 2:59:01', 'F30-34'
  UNION ALL SELECT 'Lauren Matthews', TIMESTAMP '2016-10-18 3:01:17', 'F35-39'
  UNION ALL SELECT 'Desiree Berry', TIMESTAMP '2016-10-18 3:05:42', 'F35-39'
  UNION ALL SELECT 'Suzy Slane', TIMESTAMP '2016-10-18 3:06:24', 'F35-39'
  UNION ALL SELECT 'Jen Edwards', TIMESTAMP '2016-10-18 3:06:36', 'F30-34'
  UNION ALL SELECT 'Meghan Lederer', TIMESTAMP '2016-10-18 3:07:41', 'F30-34'
  UNION ALL SELECT 'Carly Forte', TIMESTAMP '2016-10-18 3:08:58', 'F25-29'
  UNION ALL SELECT 'Lauren Reasoner', TIMESTAMP '2016-10-18 3:10:14', 'F30-34')
SELECT name,
  finish_time,
  division,
  LAG(name)
    OVER (PARTITION BY division ORDER BY finish_time ASC) AS preceding_runner
FROM finishers;

+-----------------+-------------+----------+------------------+
| name            | finish_time | division | preceding_runner |
+-----------------+-------------+----------+------------------+
| Carly Forte     | 03:08:58    | F25-29   | NULL             |
| Sophia Liu      | 02:51:45    | F30-34   | NULL             |
| Nikki Leith     | 02:59:01    | F30-34   | Sophia Liu       |
| Jen Edwards     | 03:06:36    | F30-34   | Nikki Leith      |
| Meghan Lederer  | 03:07:41    | F30-34   | Jen Edwards      |
| Lauren Reasoner | 03:10:14    | F30-34   | Meghan Lederer   |
| Lisa Stelzner   | 02:54:11    | F35-39   | NULL             |
| Lauren Matthews | 03:01:17    | F35-39   | Lisa Stelzner    |
| Desiree Berry   | 03:05:42    | F35-39   | Lauren Matthews  |
| Suzy Slane      | 03:06:24    | F35-39   | Desiree Berry    |
+-----------------+-------------+----------+------------------+

다음 예는 선택적 offset 매개변수를 사용합니다.

WITH finishers AS
 (SELECT 'Sophia Liu' as name,
  TIMESTAMP '2016-10-18 2:51:45' as finish_time,
  'F30-34' as division
  UNION ALL SELECT 'Lisa Stelzner', TIMESTAMP '2016-10-18 2:54:11', 'F35-39'
  UNION ALL SELECT 'Nikki Leith', TIMESTAMP '2016-10-18 2:59:01', 'F30-34'
  UNION ALL SELECT 'Lauren Matthews', TIMESTAMP '2016-10-18 3:01:17', 'F35-39'
  UNION ALL SELECT 'Desiree Berry', TIMESTAMP '2016-10-18 3:05:42', 'F35-39'
  UNION ALL SELECT 'Suzy Slane', TIMESTAMP '2016-10-18 3:06:24', 'F35-39'
  UNION ALL SELECT 'Jen Edwards', TIMESTAMP '2016-10-18 3:06:36', 'F30-34'
  UNION ALL SELECT 'Meghan Lederer', TIMESTAMP '2016-10-18 3:07:41', 'F30-34'
  UNION ALL SELECT 'Carly Forte', TIMESTAMP '2016-10-18 3:08:58', 'F25-29'
  UNION ALL SELECT 'Lauren Reasoner', TIMESTAMP '2016-10-18 3:10:14', 'F30-34')
SELECT name,
  finish_time,
  division,
  LAG(name, 2)
    OVER (PARTITION BY division ORDER BY finish_time ASC) AS two_runners_ahead
FROM finishers;

+-----------------+-------------+----------+-------------------+
| name            | finish_time | division | two_runners_ahead |
+-----------------+-------------+----------+-------------------+
| Carly Forte     | 03:08:58    | F25-29   | NULL              |
| Sophia Liu      | 02:51:45    | F30-34   | NULL              |
| Nikki Leith     | 02:59:01    | F30-34   | NULL              |
| Jen Edwards     | 03:06:36    | F30-34   | Sophia Liu        |
| Meghan Lederer  | 03:07:41    | F30-34   | Nikki Leith       |
| Lauren Reasoner | 03:10:14    | F30-34   | Jen Edwards       |
| Lisa Stelzner   | 02:54:11    | F35-39   | NULL              |
| Lauren Matthews | 03:01:17    | F35-39   | NULL              |
| Desiree Berry   | 03:05:42    | F35-39   | Lisa Stelzner     |
| Suzy Slane      | 03:06:24    | F35-39   | Lauren Matthews   |
+-----------------+-------------+----------+-------------------+

다음 예는 NULL 값을 기본값으로 바꿉니다.

WITH finishers AS
 (SELECT 'Sophia Liu' as name,
  TIMESTAMP '2016-10-18 2:51:45' as finish_time,
  'F30-34' as division
  UNION ALL SELECT 'Lisa Stelzner', TIMESTAMP '2016-10-18 2:54:11', 'F35-39'
  UNION ALL SELECT 'Nikki Leith', TIMESTAMP '2016-10-18 2:59:01', 'F30-34'
  UNION ALL SELECT 'Lauren Matthews', TIMESTAMP '2016-10-18 3:01:17', 'F35-39'
  UNION ALL SELECT 'Desiree Berry', TIMESTAMP '2016-10-18 3:05:42', 'F35-39'
  UNION ALL SELECT 'Suzy Slane', TIMESTAMP '2016-10-18 3:06:24', 'F35-39'
  UNION ALL SELECT 'Jen Edwards', TIMESTAMP '2016-10-18 3:06:36', 'F30-34'
  UNION ALL SELECT 'Meghan Lederer', TIMESTAMP '2016-10-18 3:07:41', 'F30-34'
  UNION ALL SELECT 'Carly Forte', TIMESTAMP '2016-10-18 3:08:58', 'F25-29'
  UNION ALL SELECT 'Lauren Reasoner', TIMESTAMP '2016-10-18 3:10:14', 'F30-34')
SELECT name,
  finish_time,
  division,
  LAG(name, 2, 'Nobody')
    OVER (PARTITION BY division ORDER BY finish_time ASC) AS two_runners_ahead
FROM finishers;

+-----------------+-------------+----------+-------------------+
| name            | finish_time | division | two_runners_ahead |
+-----------------+-------------+----------+-------------------+
| Carly Forte     | 03:08:58    | F25-29   | Nobody            |
| Sophia Liu      | 02:51:45    | F30-34   | Nobody            |
| Nikki Leith     | 02:59:01    | F30-34   | Nobody            |
| Jen Edwards     | 03:06:36    | F30-34   | Sophia Liu        |
| Meghan Lederer  | 03:07:41    | F30-34   | Nikki Leith       |
| Lauren Reasoner | 03:10:14    | F30-34   | Jen Edwards       |
| Lisa Stelzner   | 02:54:11    | F35-39   | Nobody            |
| Lauren Matthews | 03:01:17    | F35-39   | Nobody            |
| Desiree Berry   | 03:05:42    | F35-39   | Lisa Stelzner     |
| Suzy Slane      | 03:06:24    | F35-39   | Lauren Matthews   |
+-----------------+-------------+----------+-------------------+

PERCENTILE_CONT

PERCENTILE_CONT (value_expression, percentile [{RESPECT | IGNORE} NULLS])

설명

value_expression의 지정된 백분위수 값을 선형 보간으로 계산합니다.

이 함수는 RESPECT NULLS가 없으면 NULL 값을 무시합니다. RESPECT NULLS가 있는 경우:

  • NULL 값 사이의 보간은 NULL을 반환합니다.
  • NULL 값과 NULL이 아닌 값 사이의 보간은 NULL이 아닌 값을 반환합니다.

지원되는 인수 유형

  • value_expression은 숫자 표현식입니다.
  • percentile[0, 1] 범위의 DOUBLE 리터럴입니다.

반환 데이터 유형

DOUBLE

예시

다음 예는 null을 무시하면서 값의 열에서 일부 백분위수 값을 계산합니다.

SELECT
  PERCENTILE_CONT(x, 0) OVER() AS min,
  PERCENTILE_CONT(x, 0.01) OVER() AS percentile1,
  PERCENTILE_CONT(x, 0.5) OVER() AS median,
  PERCENTILE_CONT(x, 0.9) OVER() AS percentile90,
  PERCENTILE_CONT(x, 1) OVER() AS max
FROM UNNEST([0, 3, NULL, 1, 2]) AS x LIMIT 1;

+-----+-------------+--------+--------------+-----+
| min | percentile1 | median | percentile90 | max |
+-----+-------------+--------+--------------+-----+
| 0   | 0.03        | 1.5    | 2.7          | 3   |
+-----+-------------+--------+--------------+-----+

다음 예는 null을 고려하면서 값의 열에서 일부 백분위수 값을 계산합니다.

SELECT
  PERCENTILE_CONT(x, 0 RESPECT NULLS) OVER() AS min,
  PERCENTILE_CONT(x, 0.01 RESPECT NULLS) OVER() AS percentile1,
  PERCENTILE_CONT(x, 0.5 RESPECT NULLS) OVER() AS median,
  PERCENTILE_CONT(x, 0.9 RESPECT NULLS) OVER() AS percentile90,
  PERCENTILE_CONT(x, 1 RESPECT NULLS) OVER() AS max
FROM UNNEST([0, 3, NULL, 1, 2]) AS x LIMIT 1;

+------+-------------+--------+--------------+-----+
| min  | percentile1 | median | percentile90 | max |
+------+-------------+--------+--------------+-----+
| NULL | 0           | 1      | 2.6          | 3   |
+------+-------------+--------+--------------+-----+

PERCENTILE_DISC

PERCENTILE_DISC (value_expression, percentile [{RESPECT | IGNORE} NULLS])

설명

불연속 value_expression의 지정된 백분위수 값을 계산합니다. 반환되는 값은 누적 분포가 주어진 percentile 값 이상인 value_expression에서 정렬된 첫 번째 값입니다.

이 함수는 RESPECT NULLS가 없으면 NULL 값을 무시합니다.

지원되는 인수 유형

  • value_expression은 정렬 가능한 모든 유형이 될 수 있습니다.
  • percentile[0, 1] 범위의 DOUBLE 리터럴입니다.

반환 데이터 유형

ANY

예시

다음 예는 null을 무시하면서 값의 열에서 일부 백분위수 값을 계산합니다.

SELECT
  x,
  PERCENTILE_DISC(x, 0) OVER() AS min,
  PERCENTILE_DISC(x, 0.5) OVER() AS median,
  PERCENTILE_DISC(x, 1) OVER() AS max
FROM UNNEST(['c', NULL, 'b', 'a']) AS x;

+------+-----+--------+-----+
| x    | min | median | max |
+------+-----+--------+-----+
| c    | a   | b      | c   |
| NULL | a   | b      | c   |
| b    | a   | b      | c   |
| a    | a   | b      | c   |
+------+-----+--------+-----+

다음 예는 null을 고려하면서 값의 열에서 일부 백분위수의 값을 계산합니다.

SELECT
  x,
  PERCENTILE_DISC(x, 0 RESPECT NULLS) OVER() AS min,
  PERCENTILE_DISC(x, 0.5 RESPECT NULLS) OVER() AS median,
  PERCENTILE_DISC(x, 1 RESPECT NULLS) OVER() AS max
FROM UNNEST(['c', NULL, 'b', 'a']) AS x;

+------+------+--------+-----+
| x    | min  | median | max |
+------+------+--------+-----+
| c    | NULL | a      | c   |
| NULL | NULL | a      | c   |
| b    | NULL | a      | c   |
| a    | NULL | a      | c   |
+------+------+--------+-----+

집계 분석 함수

다음 섹션은 BigQuery가 지원하는 집계 분석 함수를 설명합니다. 분석 함수의 작동 방식에 대한 설명은 분석 함수 개념을 참조하세요. 집계 분석 함수의 작동 방식에 대한 설명은 집계 분석 함수 개념을 참조하세요.

BigQuery는 다음 집계 함수를 분석 함수로 지원합니다.

OVER 절 요구사항:

  • PARTITION BY: 선택사항입니다.
  • ORDER BY: 선택사항입니다. DISTINCT가 있는 경우에는 허용되지 않습니다.
  • window_frame_clause: 선택사항입니다. DISTINCT가 있는 경우에는 허용되지 않습니다.

예시:

COUNT(*) OVER (ROWS UNBOUNDED PRECEDING)
SUM(DISTINCT x) OVER ()

해시 함수

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 |
+---+-------+-------+----------------------+

MD5

MD5(input)

설명

MD5 알고리즘을 사용하여 입력의 해시를 계산합니다. 입력은 STRING 또는 BYTES일 수 있습니다. 문자열 버전은 입력을 바이트 배열로 취급합니다.

이 함수는 16바이트를 반환합니다.

반환 유형

BYTES

예시

SELECT MD5("Hello World") as md5;

+-------------------------------------------------+
| md5                                             |
+-------------------------------------------------+
| \xb1\n\x8d\xb1d\xe0uA\x05\xb7\xa9\x9b\xe7.?\xe5 |
+-------------------------------------------------+

SHA1

SHA1(input)

설명

SHA-1 알고리즘을 사용하여 입력의 해시를 계산합니다. 입력은 STRING 또는 BYTES일 수 있습니다. 문자열 버전은 입력을 바이트 배열로 취급합니다.

이 함수는 20바이트를 반환합니다.

반환 유형

BYTES

예시

SELECT SHA1("Hello World") as sha1;

+-----------------------------------------------------------+
| sha1                                                      |
+-----------------------------------------------------------+
| \nMU\xa8\xd7x\xe5\x02/\xabp\x19w\xc5\xd8@\xbb\xc4\x86\xd0 |
+-----------------------------------------------------------+

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인지 관계없이 의 길이를 바이트로 반환합니다.

반환 유형

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;

+-------+
| bytes |
+-------+
| AbCd  |
+-------+

다음 예에서는 ROT13(rotate-by-13 places) 알고리즘을 사용하여 문자열을 인코딩합니다.

SELECT CODE_POINTS_TO_BYTES(ARRAY_AGG(
  (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([code]) chr)
  ) ORDER BY OFFSET)) AS encoded_string
FROM UNNEST(TO_CODE_POINTS(b'Test String!')) code WITH OFFSET;

+----------------+
| encoded_string |
+----------------+
| Grfg Fgevat!   |
+----------------+

CODE_POINTS_TO_STRING

CODE_POINTS_TO_STRING(value)

설명

유니코드 코드 포인트의 배열(INT64의 ARRAY)을 취해 STRING을 반환합니다.

문자열을 코드 포인트의 배열로 변환하려면 TO_CODE_POINTS를 참조하세요.

반환 유형

STRING

예시

다음은 CODE_POINTS_TO_STRING을 사용하는 기본적인 예입니다.

SELECT CODE_POINTS_TO_STRING([65, 255, 513, 1024]) AS string;

+--------+
| string |
+--------+
| AÿȁЀ   |
+--------+

다음 예는 단어 집합에서 문자의 빈도를 계산합니다.

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 또는 BYTES

예시

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)

설명

2개의 을 취합니다. 두 번째 값이 첫 번째 값의 서픽스인 경우 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

BigQuery는 문자열 형식 지정을 위한 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() 같은 유형별 형식 함수를 사용하여 형식을 지정해야 합니다. 예를 들면 다음과 같습니다.

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.65
inf
NaN

NUMERIC
FLOAT64
F 10진 부동 소수점, 대문자 392.65
inf
NAN

NUMERIC
FLOAT64
e 과학적 표기법(가수/지수), 소문자 3.9265e+2
inf
NaN

NUMERIC
FLOAT64
E 과학적 표기법(가수/지수), 대문자 3.9265E+2
inf
NAN
NUMERIC
FLOAT64
g 가장 짧은 표현 사용(%e 또는 %f) 392.65
FLOAT64
G 가장 짧은 표현 사용(%E 또는 %F) 392.65
FLOAT64
s 문자의 문자열 sample STRING
t 값을 나타내는 인쇄 가능한 문자열을 반환합니다. 종종 인수를 STRING으로 변환하는 것과 유사하게 보입니다. 아래의 %t 섹션을 참조하세요. sample
2014‑01‑01
<any>
T 값과 비슷한 유형의 유효한 BigQuery 상수인 문자열을 생성합니다(더 넓거나 문자열일 수 있음). 아래의 %T 섹션을 참조하세요. 'sample'
b'bytes sample'
1234
2.3
date '2014‑01‑01'

<any>
% '%%'는 단일 '%'를 생성합니다. % 해당사항 없음

*음수 값이 사용되면 지정자 o, x, X에서 오류가 발생합니다.

형식 지정자는 위의 지정자 프로토타입에서 식별된 하위 지정자를 선택적으로 포함할 수 있습니다.

이러한 하위 지정자는 다음 사양을 준수해야 합니다.

플래그
플래그 설명
- 지정된 필드 너비 내에서 왼쪽 정렬. 오른쪽 정렬이 기본값입니다(너비 하위 지정자 참조).
+ 양수이더라도 결과 앞에 플러스 또는 마이너스 부호(+ 또는 -)를 강제로 배치합니다. 기본적으로 음수 앞에만 - 부호가 있습니다.
<space> 부호를 쓰지 않으려면 값 앞에 빈 공백을 삽입합니다.
# o, x 또는 X 지정자와 함께 사용됩니다. 0과 다른 값 앞에 각각 0, 0x 또는 0X가 옵니다.
0 패딩이 지정되면 공백 대신 0으로 숫자를 왼쪽으로 패딩합니다(너비 하위 지정자 참조).
'

적절한 그룹화 문자를 사용하여 정수 형식을 지정합니다. 예를 들면 다음과 같습니다.

  • FORMAT("%'d", 12345678)12,345,678을 반환합니다.
  • FORMAT("%'x", 12345678)bc:614e를 반환합니다.
  • FORMAT("%'o", 55555)15,4403을 반환합니다.
  • 이 플래그는 10진수, 16진수, 8진수 값에만 관련됩니다.

플래그는 순서에 상관없이 지정할 수 있습니다. 중복 플래그는 오류가 아닙니다. 일부 요소 유형과 관련이 없는 플래그는 무시됩니다.

너비
너비 설명
<number> 인쇄할 최소 문자 수입니다. 인쇄할 값이 이 숫자보다 짧으면 결과가 빈 공백으로 패딩됩니다. 결과가 더 크더라도 값은 잘리지 않습니다.
* 너비가 형식 문자열에서 지정되지 않고 형식을 지정해야 하는 인수 앞에 오는 추가 정수 값 인수로 지정됩니다.
정밀도
정밀도 설명
.<number> 정수 지정자(d, i, o, u, x, X)의 경우: 정밀도는 써야 할 최소 자릿수를 지정합니다. 써야 할 값이 이 숫자보다 짧으면 결과는 후행 0으로 패딩됩니다. 결과가 더 길더라도 값은 잘리지 않습니다. 정밀도가 0이면 0 값에 쓰이는 문자가 없음을 뜻합니다. a, A, e, E, f, F 지정자는 소수점 다음의 인쇄할 자릿수입니다(기본값은 6입니다).
.* 정밀도가 형식 문자열에서 지정되지 않고 형식을 지정해야 하는 인수 앞에 오는 추가 정수 값 인수로 지정됩니다.

%t 및 %T 동작

%t%T 형식 지정자는 모든 유형에 정의됩니다. 너비, 정밀도, 플래그는 %s에 대해 동작하는 것처럼 동작합니다. width는 최소 너비이고 STRING은 해당 크기로 패딩되며, precision은 표시할 콘텐츠의 최대 너비이고 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로 형식 지정됩니다.
STRUCT (value, value, ...)
여기서 필드는 %t로 형식 지정됩니다.
(value, value, ...)
여기서 필드는 %T로 형식 지정됩니다.

특수한 경우:
0 필드: STRUCT()
1 필드: STRUCT(값)

오류 조건

형식 지정자가 유효하지 않거나 관련 인수 유형과 호환되지 않거나 잘못된 숫자 또는 인수가 제공되는 경우, 오류가 생성됩니다. 예를 들어 다음 <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(또는 대문자로 된 동일한 결과)입니다. 이는 BigQuery가 이러한 값을 STRING으로 변환하는 방법에 부합합니다. %T의 경우, BigQuery는 문자열이 아닌 리터럴 표현이 없는 FLOAT64 값에 대해 따옴표 붙은 문자열을 반환합니다.

FROM_BASE32

FROM_BASE32(string_expr)

설명

base32로 인코딩된 입력 string_expr를 BYTES 형식으로 변환합니다. BYTES를 base32로 인코딩된 STRING으로 변환하려면 TO_BASE32를 사용하세요.

반환 유형

BYTES

예시

SELECT FROM_BASE32('MFRGGZDF74======') AS byte_data;

+-----------+
| byte_data |
+-----------+
| abcde\xff |
+-----------+

FROM_BASE64

FROM_BASE64(string_expr)

설명

base64로 인코딩된 입력 string_expr를 BYTES 형식으로 변환합니다. BYTES를 base64로 인코딩된 STRING으로 변환하려면 TO_BASE64를 사용하세요.

반환 유형

BYTES

예시

SELECT FROM_BASE64('3q2+7w==') AS byte_data;

+------------------+
| byte_data        |
+------------------+
| \xde\xad\xbe\xef |
+------------------+

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;
+------------------+----------------------------------+
| hex_str          | bytes_str                        |
+------------------+----------------------------------+
| 0AF              | \x00\xaf                         |
| 00010203aaeeefff | \x00\x01\x02\x03\xaa\xee\xef\xff |
| 666f6f626172     | foobar                           |
+------------------+----------------------------------+

LENGTH

LENGTH(value)

설명

의 길이를 반환합니다. 반환되는 값은 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이 추가된 을 반환합니다. return_length는 반환되는 값의 길이를 지정하는 INT64입니다. original_value가 BYTES인 경우 return_length는 바이트 수입니다. original_value가 STRING인 경우 return_length는 문자 수입니다.

pattern의 기본값은 빈 공백입니다.

original_valuepattern은 같은 데이터 유형이어야 합니다.

return_lengthoriginal_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 패턴 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 패턴 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   |
+-----------+

NORMALIZE

NORMALIZE(value[, normalization_mode])

설명

STRING value를 취해 정규화된 문자열로 반환합니다.

정규화는 2개의 문자열을 동등하게 만드는 데 사용됩니다. 정규화는 흔히 화면에서 동일하게 렌더링되는 두 문자열의 유니코드 코드 포인트가 서로 다른 상황에서 사용됩니다.

NORMALIZE는 네 가지 선택적 정규화 모드를 지원합니다.

이름 설명
NFC Normalization Form Canonical Composition 규범적 등가에 따라 문자를 분해하고 다시 구성합니다.
NFKC Normalization Form Compatibility Composition 호환성을 기준으로 문자를 분해한 다음 규범적 등가에 따라 다시 구성합니다.
NFD Normalization Form Canonical Decomposition 규범적 등가로 문자를 분해하고 여러 조합 문자를 특정 순서로 배열합니다.
NFKD Normalization Form Compatibility Decomposition 호환성을 기준으로 문자를 분해하고 여러 조합 문자를 특정 순서로 배열합니다.

기본 정규화 모드는 NFC입니다.

반환 유형

STRING

예시

SELECT a, b, a = b as normalized
FROM (SELECT NORMALIZE('\u00ea') as a, NORMALIZE('\u0065\u0302') as b)
AS normalize_example;

+---+---+------------+
| a | b | normalized |
+---+---+------------+
| ê | ê | true       |
+---+---+------------+

다음 예는 서로 다른 공백 문자를 정규화합니다.

WITH EquivalentNames AS (
  SELECT name
  FROM UNNEST([
      'Jane\u2004Doe',
      'John\u2004Smith',
      'Jane\u2005Doe',
      'Jane\u2006Doe',
      'John Smith']) AS name
)
SELECT
  NORMALIZE(name, NFKC) AS normalized_name,
  COUNT(*) AS name_count
FROM EquivalentNames
GROUP BY 1;

+-----------------+------------+
| normalized_name | name_count |
+-----------------+------------+
| John Smith      | 2          |
| Jane Doe        | 3          |
+-----------------+------------+

NORMALIZE_AND_CASEFOLD

NORMALIZE_AND_CASEFOLD(value[, normalization_mode])

설명

STRING 유형의 value를 취해 NORMALIZE와 동일한 작업을 수행하고, 대소문자를 구분하지 않는 연산의 경우 casefolding도 수행합니다.

NORMALIZE_AND_CASEFOLD는 4가지 선택적 정규화 모드를 지원합니다.

이름 설명
NFC Normalization Form Canonical Composition 규범적 등가에 따라 문자를 분해하고 다시 구성합니다.
NFKC Normalization Form Compatibility Composition 호환성을 기준으로 문자를 분해한 다음 규범적 등가에 따라 다시 구성합니다.
NFD Normalization Form Canonical Decomposition 규범적 등가로 문자를 분해하고 여러 조합 문자를 특정 순서로 배열합니다.
NFKD Normalization Form Compatibility Decomposition 호환성을 기준으로 문자를 분해하고 여러 조합 문자를 특정 순서로 배열합니다.

기본 정규화 모드는 NFC입니다.

반환 유형

STRING

예시

WITH Strings AS (
  SELECT '\u2168' AS a, 'IX' AS b UNION ALL
  SELECT '\u0041\u030A', '\u00C5'
)
SELECT a, b,
  NORMALIZE_AND_CASEFOLD(a, NFD)=NORMALIZE_AND_CASEFOLD(b, NFD) AS nfd,
  NORMALIZE_AND_CASEFOLD(a, NFC)=NORMALIZE_AND_CASEFOLD(b, NFC) AS nfc,
  NORMALIZE_AND_CASEFOLD(a, NFKD)=NORMALIZE_AND_CASEFOLD(b, NFKD) AS nkfd,
  NORMALIZE_AND_CASEFOLD(a, NFKC)=NORMALIZE_AND_CASEFOLD(b, NFKC) AS nkfc
FROM Strings;

+---+----+-------+-------+------+------+
| a | b  | nfd   | nfc   | nkfd | nkfc |
+---+----+-------+-------+------+------+
| Ⅸ | IX | false | false | true | true |
| Å | Å  | true  | true  | true | true |
+---+----+-------+-------+------+------+

REGEXP_CONTAINS

REGEXP_CONTAINS(value, regex)

설명

value가 정규 표현식 regex의 부분 일치 값이면 TRUE를 반환합니다.

regex 인수가 잘못되면 이 함수는 오류를 반환합니다.

^(텍스트 시작) 및 $(텍스트 종료)를 사용하여 완전 일치를 검색할 수 있습니다. 정규 표현식 연산자의 우선순위로 인해 ^$ 사이의 모든 문자를 괄호로 묶는 것이 좋습니다.

참고: BigQuery는 re2 라이브러리를 사용하여 정규 표현식을 지원합니다. 정규 표현식 구문은 해당 문서를 참조하세요.

반환 유형

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, regex)

설명

value에서 정규 표현식 regex와 일치하는 첫 번째 하위 문자열을 반환합니다. 일치하는 항목이 없으면 NULL을 반환합니다.

정규 표현식에 캡처 그룹이 포함되어 있는 경우, 이 함수는 그 캡처 그룹으로 일치되는 하위 문자열을 반환합니다. 정규 표현식에 캡처 그룹이 포함되어 있지 않은 경우, 이 함수는 일치하는 전체 하위 문자열을 반환합니다.

다음의 경우 오류를 반환합니다.

  • 정규 표현식이 유효하지 않은 경우
  • 정규 표현식에 캡처 그룹이 둘 이상 있는 경우

참고: BigQuery는 re2 라이브러리를 사용하여 정규 표현식을 지원합니다. 정규 표현식 구문은 해당 문서를 참조하세요.

반환 유형

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, regex)

설명

정규 표현식 regex와 일치하는 value의 모든 하위 문자열 배열을 반환합니다.

REGEXP_EXTRACT_ALL 함수는 중첩되지 않는 일치 항목만 반환합니다. 예를 들어 이 함수를 사용하여 banana에서 ana를 추출하면 2개가 아닌 1개의 하위 문자열만 반환됩니다.

참고: BigQuery는 re2 라이브러리를 사용하여 정규 표현식을 지원합니다. 정규 표현식 구문은 해당 문서를 참조하세요.

반환 유형

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, regex, replacement)

설명

value에서 정규 표현식 regex와 일치하는 모든 하위 문자열이 replacement로 바뀐 STRING을 반환합니다.

replacement 인수 내에 백슬래시로 이스케이프 처리된 숫자(\1~\9)를 사용하여 regex 패턴에서 괄호로 묶인 해당 그룹과 일치하는 텍스트를 삽입할 수 있습니다. 전체 일치 텍스트를 나타내려면 \0을 사용합니다.

참고: 정규 표현식에 백슬래시를 추가하려면 먼저 이스케이프 처리해야 합니다. 예를 들어 SELECT REGEXP_REPLACE("abc", "b(.)", "X\\1");aXc를 반환합니다.

REGEXP_REPLACE 함수는 중첩되지 않는 일치 항목만 바꿉니다. 예를 들어 banana 내의 ana를 바꿀 때는 2개가 아니라 1개만 바뀝니다.

regex 인수가 유효한 정규 표현식이 아니면 이 함수는 오류를 반환합니다.

참고: BigQuery는 re2 라이브러리를 사용하여 정규 표현식을 지원합니다. 정규 표현식 구문은 해당 문서를 참조하세요.

반환 유형

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_valueto_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로 구성된 을 반환합니다. 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 반복
abc 3 abcabcabc
例子 2 例子例子
abc NULL NULL
NULL 3 NULL

역순 정렬

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이 추가된 을 반환합니다. return_length는 반환되는 값의 길이를 지정하는 INT64입니다. original_value가 BYTES인 경우 return_length는 바이트 수입니다. original_value가 STRING인 경우 return_length는 문자 수입니다.

pattern의 기본값은 빈 공백입니다.

original_valuepattern은 같은 데이터 유형이어야 합니다.

return_lengthoriginal_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 패턴 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 패턴 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)

설명

바이트의 시퀀스를 문자열로 변환합니다. 유효하지 않은 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 "a b c d" as letter_group
  UNION ALL
  SELECT "e f g h" as letter_group
  UNION ALL
  SELECT "i j k l" as letter_group)

SELECT SPLIT(letter_group, " ") as example
FROM letters;

+----------------------+
| example              |
+----------------------+
| [a, b, c, d]         |
| [e, f, g, h]         |
| [i, j, k, l]         |
+----------------------+

STARTS_WITH

STARTS_WITH(value1, value2)

설명

2개의 을 취합니다. 두 번째 값이 첫 번째 값의 접두사인 경우 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로 시작하는 색인을 반환합니다. 0을 찾을 수 없는 경우 substring을 반환합니다.

반환 유형

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])

설명

제공된 의 하위 문자열을 반환합니다. position 인수는 하위 문자열의 시작 위치를 명시하는 정수로, position = 1은 첫 번째 문자나 바이트를 의미합니다. length 인수는 STRING 인수의 경우 최대 문자 수, BYTES 인수의 경우 최대 바이트 수입니다.

position이 음수인 경우, 이 함수는 value의 끝에서부터 계수하며 -1은 마지막 문자를 나타냅니다.

position이 STRING의 왼쪽 끝인 경우(position = 0 또는 position < -LENGTH(value)), 이 함수는 position = 1에서 시작됩니다. lengthvalue의 길이를 초과할 경우, 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를 사용하세요.

반환 유형

STRING

예시

SELECT TO_BASE64(b'\xde\xad\xbe\xef') AS base64_string;

+---------------+
| base64_string |
+---------------+
| 3q2+7w==      |
+---------------+

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를 참조하세요.

반환 유형

INT64의 ARRAY

예시

다음 예는 단어 배열에 있는 각 요소의 코드 포인트를 가져옵니다.

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 버전은 요소가 2개인 배열을 반환하며 STRING 버전은 요소가 하나인 배열을 반환합니다.

TO_HEX

TO_HEX(bytes)

설명

BYTES의 시퀀스를 16진수 STRING으로 변환합니다. STRING의 각 바이트를 범위(0..9, a..f)에 있는 2개의 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       |
+----------------------------------+------------------+
| foobar                           | 666f6f626172     |
| \x00\x01\x02\x03\xaa\xee\xef\xff | 00010203aaeeefff |
+----------------------------------+------------------+

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 함수

BigQuery는 JSON 형식의 문자열에 저장된 데이터를 검색하는 데 도움이 되는 함수와 데이터를 JSON 형식의 문자열로 변환하는 데 도움이 되는 함수를 지원합니다.

JSON_EXTRACT 또는 JSON_EXTRACT_SCALAR

JSON_EXTRACT(json_string_expr, json_path_string_literal)는 JSON 값을 STRING으로 반환합니다.

JSON_EXTRACT_SCALAR(json_string_expr, json_path_string_literal)는 스칼라 JSON 값을 STRING으로 반환합니다.

설명

json_string_expr 매개변수는 JSON 형식의 문자열이어야 합니다. 예를 들면 다음과 같습니다.

{"class" : {"students" : [{"name" : "Jane"}]}}

json_path_string_literal 매개변수는 JSON 형식의 문자열에서 가져올 값을 식별합니다. 이 매개변수는 JSONPath 형식을 사용하여 구성합니다. 이 형식의 일부로 이 매개변수는 JSON 형식 문자열의 가장 바깥쪽 레벨을 참조하는 $ 기호로 시작해야 합니다. 점 또는 대괄호 표기법을 사용하여 하위 값을 식별할 수 있습니다. JSON 객체가 배열인 경우 대괄호를 사용하여 배열 색인을 지정할 수 있습니다.

JSONPath 설명
$ 루트 객체 또는 요소
. 또는 [] 하위 연산자
[] 아래 첨자 연산자

json_path_string_literal 매개변수가 json_string_expr 값과 일치하지 않는 경우 두 함수 모두 NULL을 반환합니다. JSON_EXTRACT_SCALAR에 선택한 값이 객체 또는 배열과 같이 스칼라가 아닌 경우 함수는 NULL을 반환합니다.

JSONPath가 유효하지 않으면 함수에서 오류가 발생합니다.

JSON 키가 잘못된 JSONPath 문자를 사용하는 경우, 작은 따옴표와 대괄호 [' ']를 사용하여 해당 문자를 이스케이프 처리할 수 있습니다. 예를 들면 다음과 같습니다.

SELECT JSON_EXTRACT_SCALAR('{"a.b": {"c": "world"}}', "$['a.b'].c") as hello;

+-------+
| hello |
+-------+
| world |
+-------+

예시

SELECT JSON_EXTRACT(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_EXTRACT(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_EXTRACT(json_text, '$.class.students[1].name') AS second_student_name
FROM UNNEST([
  '{"class" : {"students" : [{"name" : "Jane"}]}}',
  '{"class" : {"students" : []}}',
  '{"class" : {"students" : [{"name" : "John"}, {"name": "Jamie"}]}}'
  ]) AS json_text;

위의 쿼리는 다음과 같은 결과를 산출합니다.

+-------------------+
| second_student    |
+-------------------+
| NULL              |
| NULL              |
| "Jamie"           |
+-------------------+
SELECT JSON_EXTRACT(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_EXTRACT('{ "name" : "Jakob", "age" : "6" }', '$.name') as json_name,
  JSON_EXTRACT_SCALAR('{ "name" : "Jakob", "age" : "6" }', '$.name') as scalar_name,
  JSON_EXTRACT('{ "name" : "Jakob", "age" : "6" }', '$.age') as json_age,
  JSON_EXTRACT_SCALAR('{ "name" : "Jakob", "age" : "6" }', '$.age') as scalar;

위의 쿼리는 다음과 같은 결과를 산출합니다.

+-----------+-------------+----------+--------+
| json_name | scalar_name | json_age | scalar |
+-----------+-------------+----------+--------+
| "Jakob"   | Jakob       | "6"      | 6      |
+-----------+-------------+----------+--------+

TO_JSON_STRING

TO_JSON_STRING(value[, pretty_print])

설명

value의 JSON 형식 문자열 표현을 반환합니다. 이 함수는 선택적 pretty_print 매개변수를 지원합니다. pretty_print가 있으면 반환되는 값이 읽기 쉬운 형식으로 지정됩니다.

입력 데이터 유형 반환되는 값
모든 유형의 NULL null
BOOL true 또는 false.
INT64

value가 [-253, 253] 범위 내에 있으면 CAST(value AS STRING)와 같습니다. 이 범위는 IEEE 754 배정밀도 부동 소수점 수로 손실 없이 표시될 수 있는 정수 범위입니다. 이 범위를 벗어난 값은 따옴표 붙은 문자열로 표시됩니다. 예를 들면 다음과 같습니다.

-1
0
12345678901
9007199254740992
-9007199254740992
"9007199254740993"

9007199254740993은 253보다 크므로 따옴표가 붙은 문자열로 표시됩니다.

NUMERIC

value가 [-253, 253] 범위 내에 있고 소수 부분이 없으면 CAST(value AS STRING)와 같습니다. 이 범위를 벗어난 값은 따옴표 붙은 문자열로 표시됩니다. 예를 들면 다음과 같습니다.

-1
0
"9007199254740993"
"123.56"


FLOAT64 +/-infNaN은 각각 Infinity, -InfinityNaN으로 표시됩니다.

그 외의 경우는 CAST(value AS STRING)과 같습니다.

STRING JSON 표준에 따라 이스케이프 처리된 따옴표 붙은 문자열 값입니다. 구체적으로 말해 ", \, U+0000부터 U+001F까지의 제어 문자가 이스케이프 처리됩니다.
BYTES

따옴표 붙은 RFC 4648 base64로 이스케이프 처리된 값입니다. 예를 들면 다음과 같습니다.

"R29vZ2xl"은 바이트 b"Google"의 base64 표현입니다.

DATE

따옴표 붙은 날짜입니다. 예를 들면 다음과 같습니다.

"2017-03-06"
TIMESTAMP

따옴표 붙은 ISO 8601 날짜-시간으로서 T는 날짜와 시간을 분리하고 Zulu/UTC는 시간대를 나타냅니다. 예를 들면 다음과 같습니다.

"2017-03-06T12:34:56.789012Z"
DATETIME

따옴표 붙은 ISO 8601 날짜-시간으로서 T는 날짜와 시간을 분리합니다. 예를 들면 다음과 같습니다.

"2017-03-06T12:34:56.789012"
TIME

따옴표 붙은 ISO 8601 시간입니다. 예를 들면 다음과 같습니다.

"12:34:56.789012"
ARRAY

[elem1,elem2,...], 여기서 각 elem은 요소 유형에 따라 형식이 지정됩니다.

형식 지정 예시:

[
  elem1,
  elem2,
  ...
]

여기서 각 elem은 요소 유형에 따라 형식이 지정됩니다. 빈 배열은 []로 표시됩니다.

STRUCT {"field_name1":field_value1,"field_name2":field_value2,...}

여기서 각 field_value는 그 유형에 따라 형식이 지정됩니다.

형식 지정 예시:

{
  "field_name1": field_value1,
  "field_name2": field_value2,
  ...
}

여기서 각 field_value는 그 유형에 따라 형식이 지정됩니다. field_value가 비어 있지 않은 ARRAY 또는 STRUCT이면 요소를 적절한 수준으로 들여씁니다. 빈 구조체는 {}로 표시합니다.

필드에 중복된 이름이 있으면 JSON을 파싱하지 못할 수 있습니다. 익명 필드는 ""로 표시됩니다.

UTF-8 필드 이름이 유효하지 않으면 JSON을 파싱하지 못할 수 있습니다. 문자열 값은 JSON 표준에 따라 이스케이프 처리됩니다. 구체적으로 말해 ", \, 그리고 U+0000부터 U+001F까지의 제어 문자가 이스케이프 처리됩니다.

반환 유형

값의 JSON 문자열 표현.

예시

테이블의 행을 JSON으로 변환합니다.

WITH Input AS (
  SELECT [1, 2] AS x, 'foo' AS y, STRUCT(true AS a, DATE '2017-04-05' AS b) AS s UNION ALL
  SELECT NULL AS x, '' AS y, STRUCT(false AS a, DATE '0001-01-01' AS b) AS s UNION ALL
  SELECT [3] AS x, 'bar' AS y, STRUCT(NULL AS a, DATE '2016-12-05' AS b) AS s
)
SELECT
  t,
  TO_JSON_STRING(t) AS json_row
FROM Input AS t;

위의 쿼리는 다음과 같은 결과를 산출합니다.

+-----------------------------------+-------------------------------------------------------+
| t                                 | json_row                                              |
+-----------------------------------+-------------------------------------------------------+
| {[1, 2], foo, {true, 2017-04-05}} | {"x":[1,2],"y":"foo","s":{"a":true,"b":"2017-04-05"}} |
| {NULL, , {false, 0001-01-01}}     | {"x":null,"y":"","s":{"a":false,"b":"0001-01-01"}}    |
| {[3], bar, {NULL, 2016-12-05}}    | {"x":[3],"y":"bar","s":{"a":null,"b":"2016-12-05"}}   |
+-----------------------------------+-------------------------------------------------------+

형식 지정을 사용하여 테이블의 행을 JSON으로 변환합니다.

WITH Input AS (
  SELECT [1, 2] AS x, 'foo' AS y, STRUCT(true AS a, DATE '2017-04-05' AS b) AS s UNION ALL
  SELECT NULL AS x, '' AS y, STRUCT(false AS a, DATE '0001-01-01' AS b) AS s UNION ALL
  SELECT [3] AS x, 'bar' AS y, STRUCT(NULL AS a, DATE '2016-12-05' AS b) AS s
)
SELECT
  TO_JSON_STRING(t, true) AS json_row
FROM Input AS t;

위의 쿼리는 다음과 같은 결과를 산출합니다.

+-----------------------+
| json_row              |
+-----------------------+
| {                     |
|  "x": [               |
|    1,                 |
|    2                  |
|  ],                   |
|  "y": "foo",          |
|  "s": {               |
|    "a": true,         |
|    "b": "2017-04-05"  |
|  }                    |
|}                      |
| {                     |
|  "x": null,           |
|  "y": "",             |
|  "s": {               |
|    "a": false,        |
|    "b": "0001-01-01"  |
|  }                    |
|}                      |
| {                     |
|  "x": [               |
|    3                  |
|  ],                   |
|  "y": "bar",          |
|  "s": {               |
|    "a": null,         |
|    "b": "2016-12-05"  |
|  }                    |
|}                      |
+-----------------------+

배열 함수

ARRAY

ARRAY(subquery)

설명

ARRAY 함수는 서브 쿼리의 각 행마다 요소가 한 개 있는 ARRAY를 반환합니다.

subquerySQL 테이블을 생성할 경우 테이블에는 열이 정확하게 한 개 있어야 합니다. 출력 ARRAY의 각 요소는 테이블에 있는 행의 단일 열 값입니다.

subquery값 테이블을 생성할 경우 출력 ARRAY의 각 요소는 값 테이블의 해당 행 전체입니다.

제약조건

  • 서브 쿼리는 정렬되지 않으므로 서브 쿼리의 소스 테이블에서 출력 ARRAY의 요소 순서가 지켜진다는 보장은 없습니다. 그러나 서브 쿼리에 ORDER BY 절이 포함되어 있는 경우 ARRAY 함수는 해당 절을 반영하는 ARRAY를 반환합니다.
  • 하위 쿼리가 둘 이상의 열을 반환하면 ARRAY 함수는 오류를 반환합니다.
  • 서브 쿼리가 ARRAY 유형의 열 또는 ARRAY 유형의 행을 반환할 경우 ARRAY 함수는 오류를 반환합니다. BigQuery는 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 함수가 STRUCTARRAY를 반환합니다. 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_expressionNULL이면 NULL을 반환합니다.

반환 유형

INT64

예시

WITH items AS
  (SELECT ["apples", "bananas", NULL, "grapes"] as list
  UNION ALL
  SELECT ["coffee", "tea", "milk" ] as list
  UNION ALL
  SELECT ["cake", "pie"] as list)

SELECT list, ARRAY_LENGTH(list) AS size
FROM items
ORDER BY size DESC;

+---------------------------------+------+
| list                            | size |
+---------------------------------+------+
| [apples, bananas, NULL, grapes] | 4    |
| [coffee, tea, 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 ["apples", "bananas", "pears", "grapes"] as list
  UNION ALL
  SELECT ["coffee", "tea", "milk" ] as list
  UNION ALL
  SELECT ["cake", "pie", NULL] as list)

SELECT ARRAY_TO_STRING(list, '--') AS text
FROM items;

+--------------------------------+
| text                           |
+--------------------------------+
| apples--bananas--pears--grapes |
| coffee--tea--milk              |
| cake--pie                      |
+--------------------------------+

WITH items AS
  (SELECT ["apples", "bananas", "pears", "grapes"] as list
  UNION ALL
  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                           |
+--------------------------------+
| apples--bananas--pears--grapes |
| coffee--tea--milk              |
| cake--pie--MISSING             |
+--------------------------------+

GENERATE_ARRAY

GENERATE_ARRAY(start_expression, end_expression[, step_expression])

설명

값 배열을 반환합니다. start_expressionend_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_expressionend_expression에 같은 값을 사용하여 배열을 반환합니다.

SELECT GENERATE_ARRAY(4, 4, 10) AS example_array;

+---------------+
| example_array |
+---------------+
| [4]           |
+---------------+

다음은 빈 배열을 반환합니다. start_expressionend_expression보다 크고 step_expression 값이 양수이기 때문입니다.

SELECT GENERATE_ARRAY(10, 0, 3) AS example_array;

+---------------+
| example_array |
+---------------+
| []            |
+---------------+

다음은 end_expressionNULL이므로 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_dateend_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_dateend_date에 같은 값을 사용하여 배열을 반환합니다.

SELECT GENERATE_DATE_ARRAY('2016-10-05',
  '2016-10-05', INTERVAL 8 DAY) AS example;

+--------------+
| example      |
+--------------+
| [2016-10-05] |
+--------------+

다음은 빈 배열을 반환합니다. start_dateend_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] |
+--------------------------------------------------------------------------+

다음은 상수가 아닌 날짜를 사용하여 배열을 생성합니다.

WITH StartsAndEnds AS (
  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"
)
SELECT GENERATE_DATE_ARRAY(date_start, date_end, INTERVAL 1 WEEK) AS date_range
FROM StartsAndEnds;

+--------------------------------------------------------------+
| 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] |
+--------------------------------------------------------------+

GENERATE_TIMESTAMP_ARRAY

GENERATE_TIMESTAMP_ARRAY(start_timestamp, end_timestamp,
                         INTERVAL step_expression date_part)

설명

지정된 간격으로 구분된 ARRAYTIMESTAMPS를 반환합니다. start_timestampend_timestamp 매개변수는 ARRAY의 하한 및 상한을 결정합니다(해당 값 포함).

GENERATE_TIMESTAMP_ARRAY 함수에는 다음 데이터 유형을 입력할 수 있습니다.

  • start_timestamp: TIMESTAMP
  • end_timestamp: TIMESTAMP
  • step_expression: INT64
  • 허용되는 date_part 값은 다음과 같습니다.

MICROSECOND, MILLISECOND,

SECOND, MINUTE, HOUR 또는 DAY

step_expression 매개변수는 타임스탬프를 생성하는 데 사용되는 증분을 결정합니다.

반환 데이터 유형

0 이상의 TIMESTAMP 값이 포함된 ARRAY.

예시

다음 예시에서는 1초 간격으로 TIMESTAMPARRAY를 반환합니다.

SELECT GENERATE_TIMESTAMP_ARRAY('2016-10-05 00:00:00', '2016-10-05 00:00:02',
                                INTERVAL 1 SECOND) AS timestamp_array;

+--------------------------------------------------------------------------+
| timestamp_array                                                          |
+--------------------------------------------------------------------------+
| [2016-10-05 00:00:00+00, 2016-10-05 00:00:01+00, 2016-10-05 00:00:02+00] |
+--------------------------------------------------------------------------+

다음 예시에서는 음수 간격으로 TIMESTAMPSARRAY를 반환합니다.

SELECT GENERATE_TIMESTAMP_ARRAY('2016-10-06 00:00:00', '2016-10-01 00:00:00',
                                INTERVAL -2 DAY) AS timestamp_array;

+--------------------------------------------------------------------------+
| timestamp_array                                                          |
+--------------------------------------------------------------------------+
| [2016-10-06 00:00:00+00, 2016-10-04 00:00:00+00, 2016-10-02 00:00:00+00] |
+--------------------------------------------------------------------------+

다음 예시에서는 하나의 요소로 ARRAY를 반환합니다. start_timestampend_timestamp의 값이 같기 때문입니다.

SELECT GENERATE_TIMESTAMP_ARRAY('2016-10-05 00:00:00', '2016-10-05 00:00:00',
                                INTERVAL 1 HOUR) AS timestamp_array;

+--------------------------+
| timestamp_array          |
+--------------------------+
| [2016-10-05 00:00:00+00] |
+--------------------------+

다음 예시에서는 빈 ARRAY를 반환합니다. start_timestampend_timestamp보다 이후이기 때문입니다.

SELECT GENERATE_TIMESTAMP_ARRAY('2016-10-06 00:00:00', '2016-10-05 00:00:00',
                                INTERVAL 1 HOUR) AS timestamp_array;

+-----------------+
| timestamp_array |
+-----------------+
| []              |
+-----------------+

다음 예시에서는 null ARRAY를 반환합니다. 입력 값 중 하나가 NULL이기 때문입니다.

SELECT GENERATE_TIMESTAMP_ARRAY('2016-10-05 00:00:00', NULL, INTERVAL 1 HOUR)
  AS timestamp_array;

+-----------------+
| timestamp_array |
+-----------------+
| NULL            |
+-----------------+

다음 예시에서는 start_timestampend_timestamp 값이 포함된 열에서 TIMESTAMPARRAY를 생성합니다.

SELECT GENERATE_TIMESTAMP_ARRAY(start_timestamp, end_timestamp, INTERVAL 1 HOUR)
  AS timestamp_array
FROM
  (SELECT
    TIMESTAMP '2016-10-05 00:00:00' AS start_timestamp,
    TIMESTAMP '2016-10-05 02:00:00' AS end_timestamp
   UNION ALL
   SELECT
    TIMESTAMP '2016-10-05 12:00:00' AS start_timestamp,
    TIMESTAMP '2016-10-05 14:00:00' AS end_timestamp
   UNION ALL
   SELECT
    TIMESTAMP '2016-10-05 23:59:00' AS start_timestamp,
    TIMESTAMP '2016-10-06 01:59:00' AS end_timestamp);

+--------------------------------------------------------------------------+
| timestamp_array                                                          |
+--------------------------------------------------------------------------+
| [2016-10-05 00:00:00+00, 2016-10-05 01:00:00+00, 2016-10-05 02:00:00+00] |
| [2016-10-05 12:00:00+00, 2016-10-05 13:00:00+00, 2016-10-05 14:00:00+00] |
| [2016-10-05 23:59:00+00, 2016-10-06 00:59:00+00, 2016-10-06 01:59:00+00] |
+--------------------------------------------------------------------------+

OFFSET과 ORDINAL

array_expression[OFFSET(zero_based_offset)]
array_expression[ORDINAL(one_based_offset)]

설명

위치별로 ARRAY 요소에 액세스하고 해당 요소를 반환합니다. OFFSET은 0부터 번호가 시작된다는 뜻이고, ORDINAL은 1부터 번호가 시작된다는 뜻입니다.

주어진 배열은 0이나 1부터 시작되는 것으로 해석될 수 있습니다. 배열 요소에 액세스할 때 배열 위치를 각각 OFFSET 또는 ORDINAL로 시작해야 합니다. 기본 설정된 동작은 없습니다.

색인이 범위를 벗어날 경우 OFFSETORDINAL 모두 오류를 생성합니다.

반환 유형

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]      |
| []        | []          |
+-----------+-------------+

SAFE_OFFSET 및 SAFE_ORDINAL

array_expression[SAFE_OFFSET(zero_based_offset)]
array_expression[SAFE_ORDINAL(one_based_offset)]

설명

OFFSETORDINAL과 동일하지만 색인이 범위를 벗어나면 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           |
+----------------------------------+---------------+----------------+

날짜 함수

BigQuery는 다음 DATE 함수를 지원합니다.

CURRENT_DATE

CURRENT_DATE([time_zone])

설명

지정된 시간대 또는 기본 시간대를 기준으로 현재 날짜를 반환합니다.

이 함수는 선택적 time_zone 매개변수를 지원합니다. 이 매개변수는 사용할 시간대를 나타내는 문자열입니다. 시간대를 지정하지 않으면 기본 시간대인 UTC가 사용됩니다. 시간대를 지정하는 방법에 대한 자세한 내용은 시간대 정의를 참조하세요.

time_zone 매개변수가 NULL로 평가되면 이 함수는 NULL을 반환합니다.

반환 데이터 유형

DATE

예시

SELECT CURRENT_DATE() as the_date;

+--------------+
| the_date     |
+--------------+
| 2016-12-25   |
+--------------+

EXTRACT

EXTRACT(part FROM date_expression)

설명

지정된 날짜 부분(part)에 해당하는 값을 반환합니다. part는 다음 중 하나여야 합니다.

  • DAYOFWEEK: 한 주의 첫날이 일요일인 [1,7] 범위의 값을 반환합니다.
  • DAY
  • DAYOFYEAR
  • WEEK: [0, 53] 범위에서 해당 날짜의 주 번호를 반환합니다. 주는 일요일부터 시작되며 그 해의 첫 번째 일요일 이전 날짜는 0번째 주에 속합니다.

  • WEEK(<WEEKDAY>): [0, 53] 범위에서 해당 날짜의 주 번호를 반환합니다. 주는 WEEKDAY부터 시작되며 그 해의 첫 번째 WEEKDAY 이전 날짜는 0번째 주에 속합니다. 유효한 WEEKDAY 값은 SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY입니다.

  • ISOWEEK: date_expressionISO 8601 주 번호를 반환합니다. ISOWEEK는 월요일에 시작됩니다. 반환 값은 [1, 53] 범위에 속합니다. 각 ISO 연도의 첫 번째 ISOWEEK는 그레고리력 연도의 첫 번째 목요일 이전의 월요일에 시작됩니다.
  • MONTH
  • QUARTER: [1,4] 범위의 값을 반환합니다.
  • YEAR
  • ISOYEAR: date_expression이 속한 주의 목요일이 포함된 그레고리력 연도인 ISO 8601 주 번호 지정 연도를 반환합니다.

반환 데이터 유형

INT64

예시

다음 예에서 EXTRACTDAY 시간 부분에 해당하는 값을 반환합니다.

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_expression은 일요일입니다. EXTRACT는 일요일에 시작하는 주를 사용하여 첫 번째 열을 계산하고, 월요일에 시작하는 주를 사용하여 두 번째 열을 계산합니다.

WITH table AS (SELECT DATE('2017-11-05') AS date)
SELECT
  date,
  EXTRACT(WEEK(SUNDAY) FROM date) AS week_sunday,
  EXTRACT(WEEK(MONDAY) FROM date) AS week_monday FROM table;

+------------+-------------+-------------+
| date       | week_sunday | week_monday |
+------------+-------------+-------------+
| 2017-11-05 | 45          | 44          |
+------------+-------------+-------------+

DATE

1. DATE(year, month, day)
2. DATE(timestamp_expression[, timezone])

설명

  1. 연도, 월, 일을 나타내는 INT64 값에서 DATE를 구성합니다.
  2. timestamp_expression을 DATE 데이터 유형으로 변환합니다. 시간대를 지정하는 선택적 매개변수를 지원합니다. 시간대를 지정하지 않으면 기본 시간대인 UTC가 사용됩니다.

반환 데이터 유형

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_expr 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_expr 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, date_expression, date_part)

설명

date_part 사이에 있는 date_expression 경계의 개수를 반환합니다. 첫 번째 날짜가 두 번째 날짜보다 먼저 올 경우, 결과는 양수가 아닌 값이 됩니다.

DATE_DIFF는 다음 date_part 값을 지원합니다.

  • DAY
  • WEEK 이 날짜 부분은 일요일에 시작합니다.
  • WEEK(<WEEKDAY>): 이 날짜 부분은 WEEKDAY에 시작합니다. 유효한 WEEKDAY 값은 SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY입니다.
  • 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 결과를 보여줍니다. 첫 번째 날짜는 월요일이고 두 번째 날짜는 일요일입니다. 날짜 부분 WEEK가 있는 DATE_DIFF는 0을 반환하는데, 이 시간 부분이 일요일에 시작하는 주를 사용하기 때문입니다. 날짜 부분 WEEK(MONDAY)가 있는 DATE_DIFF는 1을 반환합니다. 날짜 부분 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', WEEK(MONDAY)) AS week_weekday_diff,
  DATE_DIFF('2017-12-18', '2017-12-17', ISOWEEK) AS isoweek_diff;

+-----------+-------------------+--------------+
| week_diff | week_weekday_diff | isoweek_diff |
+-----------+-------------------+--------------+
| 0         | 1                 | 1            |
+-----------+-------------------+--------------+

DATE_TRUNC

DATE_TRUNC(date_expression, date_part)

설명

날짜를 지정한 단위로 자릅니다.

DATE_TRUNCdate_part에 다음 값을 지원합니다.

  • DAY
  • WEEK
  • WEEK(<WEEKDAY>): date_expression을 이전 주 경계로 자릅니다. 여기서 주는 WEEKDAY에 시작합니다. 유효한 WEEKDAY 값은 SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY입니다.
  • 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_partWEEK(MONDAY)이므로 DATE_TRUNC는 이전 월요일의 DATE를 반환합니다.

SELECT date AS original, DATE_TRUNC(date, WEEK(MONDAY)) AS truncated
FROM (SELECT DATE('2017-11-05') AS date);

+------------+------------+
| original   | truncated  |
+------------+------------+
| 2017-11-05 | 2017-10-30 |
+------------+------------+

다음 예에서 원본 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)

설명

지정된 date_expr에 따라 format_string의 형식을 지정합니다.

이 함수가 지원하는 형식 요소 목록은 DATE에 지원되는 형식 요소를 참조하세요.

반환 데이터 유형

STRING

예시

SELECT FORMAT_DATE("%x", DATE "2008-12-25") as US_format;

+------------+
| US_format  |
+------------+
| 12/25/08   |
+------------+

PARSE_DATE

PARSE_DATE(format_string, date_string)

설명

format_string과 날짜의 문자열 표현을 사용하여 DATE 객체를 반환합니다.

PARSE_DATE를 사용할 때는 다음 사항에 유의하세요.

  • 미지정 필드. 지정하지 않은 필드는 1970-01-01부터 초기화됩니다.
  • 대소문자를 구분하지 않는 이름. Monday, February 등과 같은 이름은 대소문자를 구분하지 않습니다.
  • 공백. 형식 문자열에 하나 이상의 공백이 연달아 있는 경우는 날짜 문자열에 0개 이상의 공백이 연달아 있는 것에 해당합니다. 또한 날짜 문자열의 선행 및 후행 공백은 형식 문자열에 없더라도 언제나 허용됩니다.
  • 형식 우선순위. 2개(또는 그 이상)의 형식 요소에 중첩되는 정보가 있을 경우(예: %F%Y가 모두 연도에 적용되는 경우), 일반적으로 마지막 요소가 앞의 요소보다 우선합니다.

이 함수가 지원하는 형식 요소 목록은 DATE에 지원되는 형식 요소를 참조하세요.

반환 데이터 유형

DATE

예시

SELECT PARSE_DATE("%x", "12/25/08") 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 한 해의 주 번호(월요일이 일주일의 첫 번째 날임)를 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는 연도를 완전히 렌더링하는 데 필요한 만큼의 문자 수를 생성한다는 점에 유의하세요.

DateTime 함수

BigQuery는 다음 DATETIME 함수를 지원합니다.

CURRENT_DATETIME

CURRENT_DATETIME([timezone])

설명

현재 시간을 DATETIME 객체로 반환합니다.

이 함수는 선택적 timezone 매개변수를 지원합니다. 시간대를 지정하는 방법에 대한 자세한 내용은 시간대 정의를 참조하세요.

반환 데이터 유형

DATETIME

예시

SELECT CURRENT_DATETIME() as now;

+----------------------------+
| now                        |
+----------------------------+
| 2016-05-19 10:38:47.046465 |
+----------------------------+

DATETIME

1. DATETIME(year, month, day, hour, minute, second)
2. DATETIME(date_expression, time_expression)
3. DATETIME(timestamp_expression [, timezone])

설명

  1. 연도, 월, 일, 시, 분, 초를 나타내는 INT64 값을 사용하여 DATETIME 객체를 구성합니다.
  2. DATE 객체와 TIME 객체를 사용하여 DATETIME 객체를 구성합니다.
  3. TIMESTAMP 객체를 사용하여 DATETIME 객체를 구성합니다. 시간대를 지정하는 선택적 매개변수를 지원합니다. 시간대를 지정하지 않으면 기본 시간대인 UTC가 사용됩니다.

반환 데이터 유형

DATETIME

예시

SELECT
  DATETIME(2008, 12, 25, 05, 30, 00) as datetime_ymdhms,
  DATETIME(TIMESTAMP "2008-12-25 05:30:00+00", "America/Los_Angeles") as datetime_tstz;

+---------------------+---------------------+
| datetime_ymdhms     | datetime_tstz       |
+---------------------+---------------------+
| 2008-12-25 05:30:00 | 2008-12-24 21:30:00 |
+---------------------+---------------------+

DATETIME_ADD

DATETIME_ADD(datetime_expression, INTERVAL INT64_expr part)

설명

INT64_exprpart 단위를 DATETIME 객체에 추가합니다.

DATETIME_ADD는 다음 part 값을 지원합니다.

  • MICROSECOND
  • MILLISECOND
  • SECOND
  • MINUTE
  • HOUR
  • DAY
  • WEEK. 7DAY에 해당합니다.
  • MONTH
  • QUARTER
  • YEAR

월말이거나 월말과 가까운 날짜는 MONTH, QUARTER, YEAR 부분을 특수하게 처리해야 합니다. 달의 결과값이 원본 DATETIME의 일수보다 적을 경우, 일의 결과값은 새 달의 마지막 날이 됩니다.

반환 데이터 유형

DATETIME

예시

SELECT
  DATETIME "2008-12-25 15:30:00" as original_date,
  DATETIME_ADD(DATETIME "2008-12-25 15:30:00", INTERVAL 10 MINUTE) as later;

+-----------------------------+------------------------+
| original_date               | later                  |
+-----------------------------+------------------------+
| 2008-12-25 15:30:00         | 2008-12-25 15:40:00    |
+-----------------------------+------------------------+

DATETIME_SUB

DATETIME_SUB(datetime_expression, INTERVAL INT64_expr part)

설명

DATETIME에서 partINT64_expr 단위를 뺍니다.

DATETIME_SUB는 다음 part 값을 지원합니다.

  • MICROSECOND
  • MILLISECOND
  • SECOND
  • MINUTE
  • HOUR
  • DAY
  • WEEK. 7DAY에 해당합니다.
  • MONTH
  • QUARTER
  • YEAR

월말이거나 월말과 가까운 날짜는 MONTH, QUARTER, YEAR 부분을 특수하게 처리해야 합니다. 달의 결과값이 원본 DATETIME의 일수보다 적을 경우, 일의 결과값은 새 달의 마지막 날이 됩니다.

반환 데이터 유형

DATETIME

예시

SELECT
  DATETIME "2008-12-25 15:30:00" as original_date,
  DATETIME_SUB(DATETIME "2008-12-25 15:30:00", INTERVAL 10 MINUTE) as earlier;

+-----------------------------+------------------------+
| original_date               | earlier                |
+-----------------------------+------------------------+
| 2008-12-25 15:30:00         | 2008-12-25 15:20:00    |
+-----------------------------+------------------------+

DATETIME_DIFF

DATETIME_DIFF(datetime_expression, datetime_expression, part)

설명

datetime_expression 사이에 있는 part 경계의 개수를 반환합니다. 첫 번째 DATETIME이 두 번째 DATETIME보다 먼저 올 경우, 결과는 양수가 아닌 값이 됩니다. 두 DATETIME 객체 간 마이크로초의 차이가 INT64 값을 오버플로하는 경우처럼 계산이 결과 유형을 오버플로하는 경우 오류가 발생합니다.

DATETIME_DIFF는 다음 part 값을 지원합니다.

  • MICROSECOND
  • MILLISECOND
  • SECOND
  • MINUTE
  • HOUR
  • DAY
  • WEEK: 이 날짜 부분은 일요일에 시작합니다.
  • WEEK(<WEEKDAY>): 이 날짜 부분은 WEEKDAY에 시작합니다. 유효한 WEEKDAY 값은 SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY입니다.
  • ISOWEEK: ISO 8601 주 경계를 사용합니다. ISO 주는 월요일에 시작합니다.
  • MONTH
  • QUARTER
  • YEAR
  • ISOYEAR: ISO 8601 주 번호 지정 연도 경계를 사용합니다. ISO 연도 경계는 목요일이 해당 그레고리력 연도에 속하는 첫 번째 주의 월요일입니다.

반환 데이터 유형

INT64

예시

SELECT
  DATETIME "2010-07-07 10:20:00" as first_datetime,
  DATETIME "2008-12-25 15:30:00" as second_datetime,
  DATETIME_DIFF(DATETIME "2010-07-07 10:20:00",
    DATETIME "2008-12-25 15:30:00", DAY) as difference;

+----------------------------+------------------------+------------------------+
| first_datetime             | second_datetime        | difference             |
+----------------------------+------------------------+------------------------+
| 2010-07-07 10:20:00        | 2008-12-25 15:30:00    | 559                    |
+----------------------------+------------------------+------------------------+
SELECT
  DATETIME_DIFF(DATETIME '2017-10-15 00:00:00',
    DATETIME '2017-10-14 00:00:00', DAY) as days_diff,
  DATETIME_DIFF(DATETIME '2017-10-15 00:00:00',
    DATETIME '2017-10-14 00:00:00', WEEK) as weeks_diff;

+-----------+------------+
| days_diff | weeks_diff |
+-----------+------------+
| 1         | 1          |
+-----------+------------+

위의 예는 24시간 떨어진 두 DATETIMEDATETIME_DIFF 결과를 보여줍니다. 부분 WEEK가 있는 DATETIME_DIFF는 1을 반환합니다. DATETIME_DIFF가 이 DATETIME 범위에 있는 부분 경계의 수를 세기 때문입니다. 각각의 WEEK는 일요일에 시작하므로 2017-10-14 00:00:00 토요일과 2017-10-15 00:00:00 일요일 사이에는 하나의 부분 경계가 있습니다.

다음 예는 연도가 서로 다른 두 날짜의 DATETIME_DIFF 결과를 보여줍니다. 날짜 부분 YEAR가 있는 DATETIME_DIFF는 3을 반환합니다. 두 DATETIME 사이의 그레고리력 연도 경계의 수를 세기 때문입니다. 날짜 부분 ISOYEAR가 있는 DATETIME_DIFF는 2를 반환하는데, 두 번째 DATETIME이 ISO 2015 연도에 속하기 때문입니다. 2015 달력 연도의 첫 번째 목요일은 2015-01-01이었으므로 ISO 2015 연도는 이전 월요일인 2014-12-29에 시작합니다.

SELECT
  DATETIME_DIFF('2017-12-30 00:00:00',
    '2014-12-30 00:00:00', YEAR) AS year_diff,
  DATETIME_DIFF('2017-12-30 00:00:00',
    '2014-12-30 00:00:00', ISOYEAR) AS isoyear_diff;

+-----------+--------------+
| year_diff | isoyear_diff |
+-----------+--------------+
| 3         | 2            |
+-----------+--------------+

다음 예는 연속되는 두 날짜의 DATETIME_DIFF 결과를 보여줍니다. 첫 번째 날짜는 월요일이고 두 번째 날짜는 일요일입니다. 날짜 부분 WEEK가 있는 DATETIME_DIFF는 0을 반환합니다. 이 시간 부분은 일요일에 시작하는 주를 사용하기 때문입니다. 날짜 부분 WEEK(MONDAY)가 있는 DATETIME_DIFF는 1을 반환합니다. 날짜 부분 ISOWEEK가 있는 DATETIME_DIFF도 ISO 주가 월요일에 시작하므로 1을 반환합니다.

SELECT
  DATETIME_DIFF('2017-12-18', '2017-12-17', WEEK) AS week_diff,
  DATETIME_DIFF('2017-12-18', '2017-12-17', WEEK(MONDAY)) AS week_weekday_diff,
  DATETIME_DIFF('2017-12-18', '2017-12-17', ISOWEEK) AS isoweek_diff;

+-----------+-------------------+--------------+
| week_diff | week_weekday_diff | isoweek_diff |
+-----------+-------------------+--------------+
| 0         | 1                 | 1            |
+-----------+-------------------+--------------+

DATETIME_TRUNC

DATETIME_TRUNC(datetime_expression, part)

설명

DATETIME 객체를 part 단위로 자릅니다.

DATETIME_TRUNC는 다음 part 값을 지원합니다.

  • MICROSECOND
  • MILLISECOND
  • SECOND
  • MINUTE
  • HOUR
  • DAY
  • WEEK
  • WEEK(<WEEKDAY>): datetime_expression을 이전 주 경계로 자릅니다. 여기서 주는 WEEKDAY에 시작합니다. 유효한 WEEKDAY 값은 SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY입니다.
  • ISOWEEK: datetime_expression을 이전 ISO 8601 주 경계로 자릅니다. ISOWEEK는 월요일에 시작합니다. 각 ISO 연도의 첫 번째 ISOWEEK는 해당 그레고리력 연도의 첫 번째 목요일을 포함합니다. 이보다 이전의 모든 date_expression은 이전 월요일로 자릅니다.
  • MONTH
  • QUARTER
  • YEAR
  • ISOYEAR: datetime_expression을 이전 ISO 8601 주 번호 지정 연도 경계로 자릅니다. ISO 연도 경계는 목요일이 해당 그레고리력 연도에 속하는 첫 번째 주의 월요일입니다.

반환 데이터 유형

DATETIME

예시

SELECT
  DATETIME "2008-12-25 15:30:00" as original,
  DATETIME_TRUNC(DATETIME "2008-12-25 15:30:00", DAY) as truncated;

+----------------------------+------------------------+
| original                   | truncated              |
+----------------------------+------------------------+
| 2008-12-25 15:30:00        | 2008-12-25 00:00:00    |
+----------------------------+------------------------+

다음 예에서 원본 DATETIME은 일요일입니다. partWEEK(MONDAY)이므로 DATE_TRUNC는 이전 월요일의 DATETIME을 반환합니다.

SELECT
 datetime AS original,
 DATETIME_TRUNC(datetime, WEEK(MONDAY)) AS truncated
FROM (SELECT DATETIME(TIMESTAMP '2017-11-05 00:00:00') AS datetime);

+---------------------+---------------------+
| original            | truncated           |
+---------------------+---------------------+
| 2017-11-05 00:00:00 | 2017-10-30 00:00:00 |
+---------------------+---------------------+

다음 예에서 원본 datetime_expression은 그레고리력 2015 연도에 속합니다. 하지만 ISOYEAR 날짜 부분이 있는 DATETIME_TRUNC는 그레고리력 연도가 아니라 ISO 연도의 시작으로 datetime_expression을 자릅니다. 2015 달력 연도의 첫 번째 목요일은 2015-01-01이었으므로 ISO 2015 연도는 이전 월요일인 2014-12-29에 시작합니다. 따라서 datetime_expression 2015-06-15 00:00:00 이전의 ISO 연도 경계는 2014-12-29입니다.

SELECT
  DATETIME_TRUNC('2015-06-15 00:00:00', ISOYEAR) AS isoyear_boundary,
  EXTRACT(ISOYEAR FROM DATETIME '2015-06-15 00:00:00') AS isoyear_number;

+---------------------+----------------+
| isoyear_boundary    | isoyear_number |
+---------------------+----------------+
| 2014-12-29 00:00:00 | 2015           |
+---------------------+----------------+

FORMAT_DATETIME

FORMAT_DATETIME(format_string, datetime_expression)

설명

지정된 format_string에 따라 DATETIME 객체의 형식을 지정합니다. 이 함수가 지원하는 형식 요소 목록은 DATETIME에 지원되는 형식 요소를 참조하세요.

반환 데이터 유형

STRING

예시

SELECT
  FORMAT_DATETIME("%c", DATETIME "2008-12-25 15:30:00")
  AS formatted;

PARSE_DATETIME

PARSE_DATETIME(format_string, string)

설명

DATETIMEformat_stringSTRING 표현을 사용하여 DATETIME을 반환합니다. 이 함수가 지원하는 형식 요소의 목록은 DATETIME에 지원되는 형식 요소를 참조하세요.

PARSE_DATETIME은 다음 규칙에 따라 string을 파싱합니다.

  • 미지정 필드: 지정되지 않은 필드는 1970-01-01 00:00:00.0부터 초기화됩니다. 예를 들어 연도가 지정되지 않으면 1970이 기본값이 됩니다.
  • 대소문자를 구분하지 않는 이름: Monday, February와 같은 이름은 대소문자를 구분하지 않습니다.
  • 공백: 형식 문자열에 하나 이상의 공백이 연달아 있는 경우는 DATETIME 문자열에 0개 이상의 공백이 연달아 있는 것과 같습니다. DATETIME 문자열의 선행 및 후행 공백은 형식 문자열에 없더라도 언제나 허용됩니다.
  • 형식 우선순위: 2개 이상의 형식 요소에 겹치는 정보가 있으면 일반적으로 몇 가지 경우를 제외하고는 마지막 요소가 앞의 요소보다 우선합니다. 예를 들어 %F%Y는 모두 연도에 영향을 주므로 이전 요소가 이후 요소보다 우선합니다. DATETIME에 지원되는 형식 요소에서 %s, %C, %y에 대한 설명을 참조하세요.

예시

다음 예에서는 STRING 리터럴을 DATETIME으로 파싱합니다.

SELECT PARSE_DATETIME('%Y-%m-%d %H:%M:%S', '1998-10-18 13:45:55') AS datetime;

위의 쿼리는 다음과 같은 출력을 반환합니다.

+---------------------+
| datetime            |
+---------------------+
| 1998-10-18 13:45:55 |
+---------------------+

다음 예에서는 자연어 형식의 날짜를 포함하는 STRING 리터럴을 DATETIME으로 파싱합니다.

SELECT PARSE_DATETIME('%A, %B %e, %Y','Wednesday, December 19, 2018')
  AS datetime;

위의 쿼리는 다음과 같은 출력을 반환합니다.

+---------------------+
| datetime            |
+---------------------+
| 2018-12-19 00:00:00 |
+---------------------+

반환 데이터 유형

DATETIME

DATETIME에 지원되는 형식 요소

달리 명시되지 않는 한, 형식 문자열을 사용하는 DATETIME 함수는 다음 요소를 지원합니다.

형식 요소 설명
%A 요일 이름입니다.
%a 요일 이름의 약어입니다.
%B 월 이름입니다.
%b 또는 %h 월 이름의 약어입니다.
%C 10진수(00~99)로 표현한 세기(연도를 100으로 나누어 정수로 자른 것)입니다.
%c 날짜 및 시간 표현입니다.
%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 이후의 초 수입니다. 문자열에서 %s가 나타나는 위치에 상관없이 항상 다른 모든 형식 요소보다 우선합니다. 여러 개의 %s 요소가 나타날 경우, 마지막 요소가 우선합니다.
%T %H:%M:%S 형식으로 표현한 시간입니다.
%t 탭 문자입니다.
%U 한 해의 주 번호(일요일이 일주일의 첫 번째 날임)를 10진수(00-53)로 표현한 것입니다.
%u 요일(월요일이 일주일의 첫 번째 날임)을 10진수(1~7)로 표현한 것입니다.
%V 한 해의 주 번호(월요일이 일주일의 첫 번째 날임)를 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년대입니다.
%% 단일 % 문자입니다.
%E#S 초를 #자리 소수의 정밀도로 표현한 것입니다.
%E*S 초를 전체 소수 자릿수로 표현한 것입니다(리터럴 '*').
%E4Y 4자릿수 연도(0001 ... 9999). %Y는 연도를 완전히 렌더링하는 데 필요한 만큼의 문자 수를 생성한다는 점에 유의하세요.

시간 함수

BigQuery는 다음 TIME 함수를 지원합니다.

CURRENT_TIME

CURRENT_TIME()

설명

현재 시간을 TIME 객체로 반환합니다.

반환 데이터 유형

TIME

예시

SELECT CURRENT_TIME() as now;

+----------------------------+
| now                        |
+----------------------------+
| 15:31:38.776361            |
+----------------------------+

TIME

1. TIME(hour, minute, second)
2. TIME(timestamp, [timezone])
3. TIME(datetime)

설명

  1. 시, 분, 초를 나타내는 INT64 값을 사용하여 TIME 객체를 구성합니다.
  2. TIMESTAMP 객체를 사용하여 TIME 객체를 구성합니다. 시간대를 지정하는 선택적 매개변수를 지원합니다. 시간대를 지정하지 않으면 기본 시간대인 UTC가 사용됩니다.
  3. DATETIME 객체를 사용하여 TIME 객체를 구성합니다.

반환 데이터 유형

TIME

예시

SELECT
  TIME(15, 30, 00) as time_hms,
  TIME(TIMESTAMP "2008-12-25 15:30:00+08", "America/Los_Angeles") as time_tstz;
+----------+-----------+
| time_hms | time_tstz |
+----------+-----------+
| 15:30:00 | 23:30:00  |
+----------+-----------+
SELECT
  TIME(DATETIME "2008-12-25 15:30:00.000000") AS time_dt;
+----------+
| time_dt  |
+----------+
| 15:30:00 |
+----------+

TIME_ADD

TIME_ADD(time_expression, INTERVAL INT64_expr part)

설명

TIME 객체에 partINT64_expr 단위를 더합니다.

TIME_ADD는 다음 part 값을 지원합니다.

  • MICROSECOND
  • MILLISECOND
  • SECOND
  • MINUTE
  • HOUR

이 함수는 값이 00:00:00~24:00:00 경계를 벗어나면 자동으로 조정합니다. 예를 들어 23:30:00에 한 시간을 더하면 반환되는 값은 00:30:00입니다.

반환 데이터 유형

TIME

예시

SELECT
  TIME "15:30:00" as original_time,
  TIME_ADD(TIME "15:30:00", INTERVAL 10 MINUTE) as later;

+-----------------------------+------------------------+
| original_time               | later                  |
+-----------------------------+------------------------+
| 15:30:00                    | 15:40:00               |
+-----------------------------+------------------------+

TIME_SUB

TIME_SUB(time_expression, INTERVAL INT_expr part)

설명

TIME 객체에서 partINT64_expr 단위를 뺍니다.

TIME_SUB는 다음 part 값을 지원합니다.

  • MICROSECOND
  • MILLISECOND
  • SECOND
  • MINUTE
  • HOUR

이 함수는 값이 00:00:00~24:00:00 경계를 벗어나면 자동으로 조정합니다. 예를 들어 00:30:00에서 한 시간을 빼면 반환되는 값은 23:30:00입니다.

반환 데이터 유형

TIME

예시

SELECT
  TIME "15:30:00" as original_date,
  TIME_SUB(TIME "15:30:00", INTERVAL 10 MINUTE) as earlier;

+-----------------------------+------------------------+
| original_date                | earlier                |
+-----------------------------+------------------------+
| 15:30:00                    | 15:20:00               |
+-----------------------------+------------------------+

TIME_DIFF

TIME_DIFF(time_expression, time_expression, part)

설명

두 TIME 객체 사이에서 지정된 전체 part 간격의 수를 반환합니다. 두 시간 객체 간 마이크로초의 차이가 INT64 값을 오버플로하는 경우처럼 계산이 결과 유형을 오버플로하는 경우 오류가 발생합니다.

TIME_DIFF는 다음 part 값을 지원합니다.

  • MICROSECOND
  • MILLISECOND
  • SECOND
  • MINUTE
  • HOUR

반환 데이터 유형

INT64

예시

SELECT
  TIME "15:30:00" as first_time,
  TIME "14:35:00" as second_time,
  TIME_DIFF(TIME "15:30:00", TIME "14:35:00", MINUTE) as difference;

+----------------------------+------------------------+------------------------+
| first_time                 | second_time            | difference             |
+----------------------------+------------------------+------------------------+
| 15:30:00                   | 14:35:00               | 55                     |
+----------------------------+------------------------+------------------------+

TIME_TRUNC

TIME_TRUNC(time_expression, part)

설명

TIME 객체를 part 단위로 자릅니다.

TIME_TRUNC는 다음 part 값을 지원합니다.

  • MICROSECOND
  • MILLISECOND
  • SECOND
  • MINUTE
  • HOUR

반환 데이터 유형

TIME

예시

SELECT
  TIME "15:30:00" as original,
  TIME_TRUNC(TIME "15:30:00", HOUR) as truncated;

+----------------------------+------------------------+
| original                   | truncated              |
+----------------------------+------------------------+
| 15:30:00                   | 15:00:00               |
+----------------------------+------------------------+

FORMAT_TIME

FORMAT_TIME(format_string, time_object)

설명 지정된 format_string에 따라 TIME 객체 형식을 지정합니다. 이 함수가 지원하는 형식 요소 목록은 TIME에 지원되는 형식 요소를 참조하세요.

반환 데이터 유형

STRING

예시

SELECT FORMAT_TIME("%R", TIME "15:30:00") as formatted_time;

+----------------+
| formatted_time |
+----------------+
| 15:30          |
+----------------+

PARSE_TIME

PARSE_TIME(format_string, string)

설명

format_string과 문자열을 사용하여 TIME 객체를 반환합니다. 이 함수가 지원하는 형식 요소 목록은 TIME에 지원되는 형식 요소를 참조하세요.

PARSE_TIME을 사용할 때는 다음 사항에 유의하세요.

  • 미지정 필드: 지정하지 않은 필드는 00:00:00.0부터 초기화됩니다. 예를 들어 seconds가 지정되지 않으면 00이 기본값이 되고 나머지도 마찬가지입니다.
  • 공백: 형식 문자열에 하나 이상의 공백이 연달아 있는 경우는 TIME 문자열에 0개 이상의 공백이 연달아 있는 것과 같습니다. 또한 TIME 문자열의 선행 및 후행 공백은 형식 문자열에 없더라도 항상 허용됩니다.
  • 형식 우선순위: 2개(또는 그 이상)의 형식 요소에 겹치는 정보가 있을 경우, 일반적으로 마지막 요소가 앞의 요소보다 우선합니다.

반환 데이터 유형

TIME

예시

SELECT PARSE_TIME("%H", "15") as parsed_time;

+-------------+
| parsed_time |
+-------------+
| 15:00:00    |
+-------------+

TIME에 지원되는 형식 요소

별도로 명시하지 않은 경우 형식 문자열을 사용하는 TIME 함수는 다음 요소를 지원합니다.

형식 요소 설명
%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)로 표현한 것입니다.
%n 줄바꿈 문자입니다.
%P am 또는 pm입니다.
%p AM 또는 PM입니다.
%R %H:%M 형식으로 표현한 시간입니다.
%r AM/PM 표기법을 사용한 12시간제 시간입니다.
%S 초를 10진수(00-60)로 표현한 것입니다.
%T %H:%M:%S 형식으로 표현한 시간입니다.
%t 탭 문자입니다.
%X 시간을 HH:MM:SS 형식으로 표현한 것입니다.
%% 단일 % 문자입니다.
%E#S 초를 #자리 소수의 정밀도로 표현한 것입니다.
%E*S 초를 전체 소수 자릿수로 표현한 것입니다(리터럴 '*').

타임스탬프 함수

BigQuery는 다음 TIMESTAMP 함수를 지원합니다.

참고: 이 함수는 오버플로가 발생할 경우 런타임 오류를 반환합니다. 결과값은 정의된 날짜와 타임스탬프 최솟값/최댓값으로 제한됩니다.

CURRENT_TIMESTAMP

CURRENT_TIMESTAMP()

설명

괄호는 선택사항입니다. 이 함수는 삽입된 윤초에 집중하여 20시간에 걸쳐 윤초를 제거합니다. CURRENT_TIMESTAMP()는 연속적이고 모호하지 않으며 분당 정확히 60초이고 윤초 동안 값을 반복하지 않는 TIMESTAMP 값을 생성합니다.

지원되는 입력 유형

해당 없음

결과 데이터 유형

TIMESTAMP

예시

SELECT CURRENT_TIMESTAMP() as now;

+-------------------------------+
| now                           |
+-------------------------------+
| 2016-05-16 18:12:47.145482+00 |
+-------------------------------+

EXTRACT

EXTRACT(part FROM timestamp_expression [AT TIME ZONE tz_spec])

설명

제공된 timestamp_expression에서 지정된 part에 해당하는 INT64 값을 반환합니다.

허용되는 part 값은 다음과 같습니다.

  • MICROSECOND
  • MILLISECOND
  • SECOND
  • MINUTE
  • HOUR
  • DAYOFWEEK
  • DAY
  • DAYOFYEAR
  • WEEK: [0, 53] 범위에서 해당 날짜의 주 번호를 반환합니다. 주는 일요일부터 시작되며 그 해의 첫 번째 일요일 이전 날짜는 0번째 주에 속합니다.

  • WEEK(<WEEKDAY>): [0, 53] 범위에서 timestamp_expression의 주 번호를 반환합니다. 주는 WEEKDAY에 시작됩니다. 그 해의 첫 번째 WEEKDAY 이전의 datetime은 0번째 주에 속합니다. 유효한 WEEKDAY 값은 SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY입니다.

  • ISOWEEK: datetime_expressionISO 8601 주 번호를 반환합니다. ISOWEEK는 월요일에 시작됩니다. 반환 값은 [1, 53] 범위에 속합니다. 각 ISO 연도의 첫 번째 ISOWEEK는 태양력 연도의 첫 번째 목요일 이전의 월요일에 시작됩니다.

  • MONTH
  • QUARTER
  • YEAR
  • ISOYEAR: date_expression이 속한 주의 목요일이 포함된 그레고리력 연도인 ISO 8601 주 번호 지정 연도를 반환합니다.
  • DATE
  • DATETIME
  • TIME

반환되는 값은 더 낮은 순서의 기간을 자릅니다. 예를 들어 초를 추출할 경우 EXTRACT는 밀리초와 마이크로초 값을 자릅니다.

시간대를 지정하는 방법에 대한 자세한 내용은 시간대 정의를 참조하세요.

반환 데이터 유형

일반적으로 INT64입니다. partDATE인 경우 DATE를 반환합니다.

예시

다음 예시에서 EXTRACTDAY 시간 부분에 해당하는 값을 반환합니다.

SELECT EXTRACT(DAY
  FROM TIMESTAMP "2008-12-25 15:30:00" AT TIME ZONE "America/Los_Angeles")
  AS the_day;

+------------+
| the_day    |
+------------+
| 25         |
+------------+

다음 예시에서 EXTRACT는 타임스탬프 열의 다양한 시간 부분에 해당하는 값을 반환합니다.

WITH Timestamps AS (
  SELECT TIMESTAMP '2005-01-03 12:34:56' AS timestamp UNION ALL
  SELECT TIMESTAMP '2007-12-31' UNION ALL
  SELECT TIMESTAMP '2009-01-01' UNION ALL
  SELECT TIMESTAMP '2009-12-31' UNION ALL
  SELECT TIMESTAMP '2017-01-02' UNION ALL
  SELECT TIMESTAMP '2017-05-26'
)
SELECT
  timestamp,
  EXTRACT(ISOYEAR FROM timestamp) AS isoyear,
  EXTRACT(ISOWEEK FROM timestamp) AS isoweek,
  EXTRACT(YEAR FROM timestamp) AS year,
  EXTRACT(WEEK FROM timestamp) AS week
FROM Timestamps
ORDER BY timestamp;
+------------------------+---------+---------+------+------+
| timestamp              | isoyear | isoweek | year | week |
+------------------------+---------+---------+------+------+
| 2005-01-03 12:34:56+00 | 2005    | 1       | 2005 | 1    |
| 2007-12-31 00:00:00+00 | 2008    | 1       | 2007 | 52   |
| 2009-01-01 00:00:00+00 | 2009    | 1       | 2009 | 0    |
| 2009-12-31 00:00:00+00 | 2009    | 53      | 2009 | 52   |
| 2017-01-02 00:00:00+00 | 2017    | 1       | 2017 | 1    |
| 2017-05-26 00:00:00+00 | 2017    | 21      | 2017 | 21   |
+------------------------+---------+---------+------+------+

다음 예시에서 timestamp_expression은 일요일입니다. EXTRACT는 일요일에 시작하는 주를 사용하여 첫 번째 열을 계산하고, 월요일에 시작하는 주를 사용하여 두 번째 열을 계산합니다.

WITH table AS (SELECT TIMESTAMP('2017-11-05 00:00:00') AS timestamp)
SELECT
  timestamp,
  EXTRACT(WEEK(SUNDAY) FROM timestamp) AS week_sunday,
  EXTRACT(WEEK(MONDAY) FROM timestamp) AS week_monday
FROM table;

+------------------------+-------------+---------------+
| timestamp              | week_sunday | week_monday |
+------------------------+-------------+---------------+
| 2017-11-05 00:00:00+00 | 45          | 44            |
+------------------------+-------------+---------------+

STRING

STRING(timestamp_expression[, timezone])

설명

timestamp_expression을 STRING 데이터 유형으로 변환합니다. 시간대를 지정하는 선택적 매개변수를 지원합니다. 시간대를 지정하는 방법에 대한 자세한 내용은 시간대 정의를 참조하세요.

반환 데이터 유형

STRING

예시

SELECT STRING(TIMESTAMP "2008-12-25 15:30:00", "America/Los_Angeles") as string;

+-------------------------------+
| string                        |
+-------------------------------+
| 2008-12-25 15:30:00-08        |
+-------------------------------+

TIMESTAMP

1. TIMESTAMP(string_expression[, timezone])
2. TIMESTAMP(date_expression[, timezone])
3. TIMESTAMP(datetime_expression[, timezone])

설명

  1. STRING 표현식을 TIMESTAMP 데이터 유형으로 변환합니다.

  2. DATE 객체를 TIMESTAMP 데이터 유형으로 변환합니다.

  3. DATETIME 객체를 TIMESTAMP 데이터 유형으로 변환합니다.

이 함수는 시간대를 지정하는 선택적 매개변수를 지원합니다. 시간대를 지정하지 않으면 기본 시간대인 UTC가 사용됩니다.

반환 데이터 유형

TIMESTAMP

예시

SELECT
  CAST(TIMESTAMP("2008-12-25 15:30:00", "America/Los_Angeles") AS STRING) AS timestamp_str,
  CAST(TIMESTAMP(DATE "2008-12-25", "America/Los_Angeles") AS STRING) AS timestamp_date,
  CAST(TIMESTAMP(DATETIME "2008-12-25 15:30:00", "America/Los_Angeles") AS STRING) AS timestamp_datetime;

+------------------------+------------------------+------------------------+
| timestamp_str          | timestamp_date         | timestamp_datetime     |
+------------------------+------------------------+------------------------+
| 2008-12-25 23:30:00+00 | 2008-12-25 08:00:00+00 | 2008-12-25 23:30:00+00 |
+------------------------+------------------------+------------------------+

TIMESTAMP_ADD

TIMESTAMP_ADD(timestamp_expression, INTERVAL int64_expression date_part)

설명

시간대와 관계없이 date_partint64_expression 단위를 타임스탬프에 추가합니다.

TIMESTAMP_ADD는 다음 date_part 값을 지원합니다.

  • MICROSECOND
  • MILLISECOND
  • SECOND
  • MINUTE
  • HOUR. 60MINUTE에 해당합니다.

반환 데이터 유형

TIMESTAMP

예시

SELECT
  TIMESTAMP "2008-12-25 15:30:00 UTC" as original,
  TIMESTAMP_ADD(TIMESTAMP "2008-12-25 15:30:00 UTC", INTERVAL 10 MINUTE) AS later;

+------------------------+------------------------+
| original               | later                  |
+------------------------+------------------------+
| 2008-12-25 15:30:00+00 | 2008-12-25 15:40:00+00 |
+------------------------+------------------------+

TIMESTAMP_SUB

TIMESTAMP_SUB(timestamp_expression, INTERVAL int64_expression date_part)

설명

시간대와 관계없이 타임스탬프에서 date_partint64_expression 단위를 뺍니다.

TIMESTAMP_SUB는 다음 date_part 값을 지원합니다.

  • MICROSECOND
  • MILLISECOND
  • SECOND
  • MINUTE
  • HOUR. 60MINUTE에 해당합니다.

반환 데이터 유형

TIMESTAMP

예시

SELECT
  TIMESTAMP "2008-12-25 15:30:00 UTC" as original,
  TIMESTAMP_SUB(TIMESTAMP "2008-12-25 15:30:00 UTC", INTERVAL 10 MINUTE) AS earlier;

+------------------------+------------------------+
| original               | earlier                |
+------------------------+------------------------+
| 2008-12-25 15:30:00+00 | 2008-12-25 15:20:00+00 |
+------------------------+------------------------+

TIMESTAMP_DIFF

TIMESTAMP_DIFF(timestamp_expression, timestamp_expression, date_part)

설명

두 타임스탬프 간에 지정된 전체 date_part 간격 수를 반환합니다. 첫 번째 timestamp_expression은 이후 날짜를 나타냅니다. 첫 번째 timestamp_expression이 두 번째 timestamp_expression보다 이전이면 음수 출력이 생성됩니다. 두 타임스탬프 간의 나노초 차이가 INT64 값을 초과하는 경우처럼 계산이 결과 유형을 초과하면 오류가 발생합니다.

TIMESTAMP_DIFFdate_part에 다음 값을 지원합니다.

  • MICROSECOND
  • MILLISECOND
  • SECOND
  • MINUTE
  • HOUR. 60MINUTE에 해당합니다.

반환 데이터 유형

INT64

예시

SELECT
  TIMESTAMP "2010-07-07 10:20:00 UTC" as later_timestamp,
  TIMESTAMP "2008-12-25 15:30:00 UTC" as earlier_timestamp,
  TIMESTAMP_DIFF(TIMESTAMP "2010-07-07 10:20:00 UTC",
    TIMESTAMP "2008-12-25 15:30:00 UTC", HOUR) AS hours;

+------------------------+------------------------+-------+
| later_timestamp        | earlier_timestamp      | hours |
+------------------------+------------------------+-------+
| 2010-07-07 10:20:00+00 | 2008-12-25 15:30:00+00 | 13410 |
+------------------------+------------------------+-------+

다음 예시에서 첫 번째 타임스탬프가 두 번째 타임스탬프보다 먼저 발생하면 음수 출력이 생성됩니다.

SELECT TIMESTAMP_DIFF(TIMESTAMP "2018-08-14", TIMESTAMP "2018-10-14", DAY);

+---------------+
| negative_diff |
+---------------+
| -61           |
+---------------+

TIMESTAMP_TRUNC

TIMESTAMP_TRUNC(timestamp_expression, date_part[, time_zone])

설명

타임스탬프를 date_part의 단위로 자릅니다.

TIMESTAMP_TRUNCdate_part에 다음 값을 지원합니다.

  • MICROSECOND
  • MILLISECOND
  • SECOND
  • MINUTE
  • HOUR
  • DAY
  • WEEK
  • WEEK(<WEEKDAY>): timestamp_expression을 이전 주 경계로 자릅니다. 여기서 주는 WEEKDAY에 시작합니다. 유효한 WEEKDAY 값은 SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY입니다.
  • ISOWEEK: timestamp_expression을 이전 ISO 8601 주 경계로 자릅니다. ISOWEEK는 월요일에 시작합니다. 각 ISO 연도의 첫 번째 ISOWEEK는 해당 그레고리력 연도의 첫 번째 목요일을 포함합니다. 이보다 이전의 모든 date_expression은 이전 월요일로 자릅니다.
  • MONTH
  • QUARTER
  • YEAR
  • ISOYEAR: timestamp_expression을 이전 ISO 8601 주 번호 지정 연도 경계로 자릅니다. ISO 연도 경계는 목요일이 해당 그레고리력 연도에 속하는 첫 번째 주의 월요일입니다.

TIMESTAMP_TRUNC 함수는 선택적 time_zone 매개변수를 지원합니다. 이 매개변수는 다음 date_parts에 적용됩니다.

  • MINUTE
  • HOUR
  • DAY
  • WEEK
  • WEEK(<WEEKDAY>)
  • MONTH
  • QUARTER
  • YEAR

자르기 연산의 일부로 기본 시간대인 UTC가 아닌 다른 시간대를 사용하려면 이 매개변수를 사용하세요.

TIMESTAMPMINUTE 또는 HOUR로 자르면 TIMESTAMP_TRUNC는 지정된(또는 기본값) 시간대에서 TIMESTAMP의 상용시를 결정하고, 해당 TIMESTAMP에서 분과 초(HOUR로 자를 경우) 또는 초(MINUTE로 자를 경우)를 뺍니다. 이렇게 하면 대부분의 경우 직관적인 결과가 제공되지만, 순차 시간으로 나열되지 않는 일광 절약 시간 전환 무렵에는 직관적이지 않은 결과를 얻게 됩니다.

반환 데이터 유형

TIMESTAMP

예시

SELECT
  TIMESTAMP_TRUNC(TIMESTAMP '2008-12-25 15:30:00', DAY, 'UTC') as utc,
  TIMESTAMP_TRUNC(TIMESTAMP '2008-12-25 15:30:00', DAY, 'America/Los_Angeles') as la;

+------------------------+------------------------+
| utc                    | la                     |
+------------------------+------------------------+
| 2008-12-25 00:00:00+00 | 2008-12-25 08:00:00+00 |
+------------------------+------------------------+

다음 예시에서 timestamp_expression의 시간대 오프셋은 +12입니다. 첫 번째 열은 UTC 시간으로 timestamp_expression을 보여줍니다. 두 번째 열은 월요일에 시작하는 주를 사용하여 TIMESTAMP_TRUNC의 출력을 보여줍니다. timestamp_expression은 UTC에서 일요일이므로 TIMESTAMP_TRUNC에 의해 이전 월요일로 잘립니다. 세 번째 열은 선택적 시간대 정의 인수인 '태평양/오클랜드'와 동일한 함수를 보여 줍니다. 여기서 함수는 월요일인 뉴질랜드 일광 절약 시간을 사용하여 timestamp_expression을 자릅니다.

SELECT
  timestamp,
  TIMESTAMP_TRUNC(timestamp, WEEK(MONDAY)) AS utc_truncated,
  TIMESTAMP_TRUNC(timestamp, WEEK(MONDAY), 'Pacific/Auckland') AS nzdt_truncated
FROM (SELECT TIMESTAMP('2017-11-06 00:00:00+12') AS timestamp);

+------------------------+------------------------+------------------------+
| timestamp              | utc_truncated          | nzdt_truncated         |
+------------------------+------------------------+------------------------+
| 2017-11-05 12:00:00+00 | 2017-10-30 07:00:00+00 | 2017-11-05 11:00:00+00 |
+------------------------+------------------------+------------------------+

다음 예시에서 원본 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;

+------------------------+----------------+
| isoyear_boundary       | isoyear_number |
+------------------------+----------------+
| 2014-12-29 00:00:00+00 | 2015           |
+------------------------+----------------+

FORMAT_TIMESTAMP

FORMAT_TIMESTAMP(format_string, timestamp[, time_zone])

설명

지정된 format_string에 따라 타임스탬프의 형식을 지정합니다.

이 함수가 지원하는 형식 요소 목록은 TIMESTAMP에 지원되는 형식 요소를 참조하세요.

반환 데이터 유형

STRING

예시

SELECT FORMAT_TIMESTAMP("%c", TIMESTAMP "2008-12-25 15:30:00", "America/Los_Angeles")
  AS formatted;

+--------------------------+
| formatted                |
+--------------------------+
| Thu Dec 25 07:30:00 2008 |
+--------------------------+

PARSE_TIMESTAMP

PARSE_TIMESTAMP(format_string, string[, time_zone])

설명

format_string과 타임스탬프의 문자열 표현을 사용하여 TIMESTAMP 객체를 반환합니다.

PARSE_TIMESTAMP를 사용할 때는 다음 사항에 유의하세요.

  • 미지정 필드: 지정되지 않은 필드는 1970-01-01 00:00:00.0부터 초기화됩니다. 함수의 시간대 인수가 있으면 지정된 시간대가 이 초기화 값에 사용됩니다. 그렇지 않으면 기본 시간대인 UTC가 초기화 값에 사용됩니다. 예를 들어 연도가 지정되지 않으면 1970이 기본값이 되고 나머지도 마찬가지입니다.
  • 대소문자를 구분하지 않는 이름: Monday, February 등과 같은 이름은 대소문자를 구분하지 않습니다.
  • 공백: 형식 문자열에 하나 이상의 공백이 연달아 있는 경우는 날짜 문자열에 0개 이상의 공백이 연달아 있는 것과 같습니다. 또한 날짜 문자열의 선행 및 후행 공백은 형식 문자열에 없더라도 언제나 허용됩니다.
  • 형식 우선순위: 2개(또는 그 이상)의 형식 요소에 겹치는 정보가 있을 경우(예: %F%Y가 모두 연도에 적용되는 경우), 일반적으로 마지막 요소가 앞의 요소보다 우선하며 몇 가지 예외가 있습니다(%s, %C, %y 설명 참조).

이 함수가 지원하는 형식 요소 목록은 TIMESTAMP에 지원되는 형식 요소를 참조하세요.

반환 데이터 유형

TIMESTAMP

예시

SELECT PARSE_TIMESTAMP("%c", "Thu Dec 25 07:30:00 2008", "America/Los_Angeles") as parsed;

+-------------------------+
| parsed                  |
+-------------------------+
| 2008-12-25 15:30:00 UTC |
+-------------------------+

TIMESTAMP_SECONDS

TIMESTAMP_SECONDS(int64_expression)

설명

int64_expression을 1970-01-01 00:00:00 UTC 이후의 초 수로 해석합니다.

반환 데이터 유형

TIMESTAMP

예시

SELECT TIMESTAMP_SECONDS(1230219000) as timestamp;

+-------------------------+
| timestamp               |
+-------------------------+
| 2008-12-25 15:30:00 UTC |
+-------------------------+

TIMESTAMP_MILLIS

TIMESTAMP_MILLIS(int64_expression)

설명

int64_expression을 1970-01-01 00:00:00 UTC 이후의 밀리초 수로 해석합니다.

반환 데이터 유형

TIMESTAMP

예시

SELECT TIMESTAMP_MILLIS(1230219000000) as timestamp;

+-------------------------+
| timestamp               |
+-------------------------+
| 2008-12-25 15:30:00 UTC |
+-------------------------+

TIMESTAMP_MICROS

TIMESTAMP_MICROS(int64_expression)

설명

int64_expression을 1970-01-01 00:00:00 UTC 이후의 마이크로초 수로 해석합니다.

반환 데이터 유형

TIMESTAMP

예시

SELECT TIMESTAMP_MICROS(1230219000000000) as timestamp;

+-------------------------+
| timestamp               |
+-------------------------+
| 2008-12-25 15:30:00 UTC |
+-------------------------+

UNIX_SECONDS

UNIX_SECONDS(timestamp_expression)

설명

1970-01-01 00:00:00 UTC 이후의 초 수를 반환합니다. 나머지 단위는 자릅니다.

반환 데이터 유형

INT64

예시

SELECT UNIX_SECONDS(TIMESTAMP "2008-12-25 15:30: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 UTC") 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") as micros;

+------------------+
| micros           |
+------------------+
| 1230219000000000 |
+------------------+

TIMESTAMP에 지원되는 형식 요소

달리 명시되지 않는 한, 형식 문자열을 사용하는 TIMESTAMP 함수는 다음 요소를 지원합니다.

형식 요소 설명
%A 요일 이름입니다.
%a 요일 이름의 약어입니다.
%B 월 이름입니다.
%b 또는 %h 월 이름의 약어입니다.
%C 10진수(00~99)로 표현한 세기(연도를 100으로 나누어 정수로 자른 것)입니다.
%c 날짜 및 시간 표현입니다.
%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 한 해의 주 번호(월요일이 일주일의 첫 번째 날임)를 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는 연도를 완전히 렌더링하는 데 필요한 만큼의 문자 수를 생성하니 유의하세요.

시간대 정의

특정 날짜 및 타임스탬프 함수를 사용하면 기본 시간대를 재정의하여 다른 시간대를 지정할 수 있습니다. 다음 형식으로 시간대의 UTC 오프셋을 입력하여 시간대를 지정할 수 있습니다.

(+|-)H[H][:M[M]]

예:

-08:00

지리 함수

지리 함수는 BigQuery GEOGRAPHY 값에 대해 작동하거나 이러한 값을 생성합니다. 지리 함수의 서명은 ST_로 시작합니다. BigQuery는 지리 데이터 분석, 지형 지물 간의 공간적 관계 파악, GEOGRAPHY 구성 또는 조작에 사용할 수 있는 다음과 같은 함수를 지원합니다.

지리 함수는 함수 동작에 따라 다음과 같은 카테고리로 분류됩니다.

  • 생성자: ST_GEOGPOINT와 같은 기존 GEOGRAPHY나 좌표를 사용하여 새 GEOGRAPHY 값을 빌드하는 함수입니다.
  • 파서: WKTGeoJSON과 같은 외부 형식을 사용하여 GEOGRAPHY를 만드는 함수입니다. 예를 들어 ST_GEOGFROMTEXT는 WKT를 사용하여 GEOGRAPHY를 만듭니다.
  • 포맷터: GEOGRAPHY를 WKT 및 GeoJSON과 같은 외부 형식으로 내보내는 함수입니다. 예를 들어 ST_ASTEXTGEOGRAPHY를 WKT 형식으로 만듭니다.
  • 변환: 다른 GEOGRAPY에서 일부 속성은 유지하고 새 GEOGRAPHY를 생성하는 함수입니다. 예를 들어 ST_INTERSECTIONST_BOUNDARY가 이에 해당합니다.
  • 조건자: 두 GEOGRAPHY 간의 공간적 관계나 특정 지리 속성에 대해 TRUE 또는 FALSE를 반환하는 함수입니다. 이 함수는 일반적으로 필터 절에 사용됩니다. 예를 들어 ST_DWITHIN이 조건자입니다.
  • 접근자: GEOGRAPHY의 속성에 부작용 없이 액세스할 수 있도록 하는 함수입니다(예: ST_NUMPOINTS).
  • 측정자: GEOGRAPHY 한 개 이상의 측정값을 계산하는 함수입니다(예: ST_DISTANCE).
  • 집계 함수: 지리 관련 집계 함수입니다(예: ST_UNION_AGG).

입력 인수가 NULL이면 모든 BigQuery 지리 함수는 NULL을 반환합니다.

ST_GEOGPOINT

ST_GEOGPOINT(longitude, latitude)

설명

단일 점을 사용하여 GEOGRAPHY를 생성합니다. ST_GEOGPOINT는 지정된 FLOAT64 경도 및 위도 매개변수를 사용하여 단일 점을 생성한 후 GEOGRAPHY 값으로 반환합니다.

제약조건

  • 위도 범위는 [-90, 90]입니다. 위도가 이 범위를 벗어나면 오류가 발생합니다.
  • 경도는 [-180, 180] 범위를 벗어나도 됩니다. ST_GEOGPOINT는 입력 경도를 360으로 나눈 나머지를 사용하여 [-180, 180] 범위 내의 경도를 구합니다.

반환 유형

GEOGRAPHY

ST_MAKELINE

ST_MAKELINE(geography_1, geography_2)
ST_MAKELINE(array_of_geography)

설명

각 입력된 GEOGRAPHY의 점 또는 선 꼭짓점을 지정된 순서대로 연결하여 단일 유도선이 있는 GEOGRAPHY를 만듭니다.

ST_MAKELINE에는 2가지 유형이 있습니다. 첫 번째 유형에서는 GEOGRAPHY를 두 개 입력해야 합니다. 두 번째 유형에서는 GEOGRAPHY 유형의 ARRAY를 입력해야 합니다. 두 유형에서 입력된 각 GEOGRAPHY는 다음 값 중 하나로 구성되어야 합니다.

  • 정확하게 점 한 개
  • 정확하게 유도선 한 개

첫 번째 ST_MAKELINE 유형의 경우 입력된 GEOGRAPHYNULL이면 ST_MAKELINENULL을 반환합니다. 두 번째 유형의 경우 입력된 ARRAY 또는 입력된 ARRAY의 요소가 NULL이면 ST_MAKELINENULL을 반환합니다.

제약조건

모든 모서리의 범위는 180도 미만이어야 합니다.

참고: BigQuery의 맞추기 프로세스는 아주 짧은 모서리를 삭제하고 2개의 끝점을 함께 맞춥니다. 예를 들어 두 입력 GEOGRAPHY에 각각 점이 하나씩 포함되어 있고 두 점이 맞추기 반경보다 작은 거리로 분리되었으면 점이 함께 맞춰집니다. 이러한 경우 결과는 정확히 1개의 점만 있는 GEOGRAPHY가 됩니다.

반환 유형

GEOGRAPHY

ST_MAKEPOLYGON

ST_MAKEPOLYGON(geography_expression)
ST_MAKEPOLYGON(geography_expression, array_of_geography)

설명

입력 유도선을 사용하여 단일 다각형이 포함된 GEOGRAPHY를 만듭니다. 이때 각 입력 유도선은 다각형 링을 구성하는 데 사용됩니다.

ST_MAKEPOLYOGN에는 2가지 유형이 있습니다. 첫 번째 유형의 경우 정확하게 유도선 한 개가 포함된 단일 GEOGRAPHY가 입력 유도선을 제공합니다. 두 번째 유형의 경우 입력은 각각 정확하게 유도선 한 개가 포함된 단일 GEOGRAPHYGEOGRAPHY의 배열로 구성됩니다. 두 유형의 첫 번째 GEOGRAPHY는 다각형 셸을 생성하는 데 사용됩니다. 입력된 GEOGRAPHY에 제공되는 추가 ARRAY는 다각형 구멍을 지정합니다. 정확하게 유도선 한 개가 포함된 모든 입력 GEOGRAPHY는 다음 조건을 충족해야 합니다.

  • 유도선은 최소 3개 이상의 개별 꼭짓점으로 구성되어야 합니다.
  • 유도선은 닫혀 있어야 합니다. 즉, 첫 번째 꼭짓점과 마지막 꼭짓점이 동일해야 합니다. 첫 번째 꼭짓점과 마지막 꼭짓점이 다르면 이 함수는 첫 번째 꼭짓점에서 시작해 마지막 꼭짓점에서 끝나는 모서리를 생성합니다.

첫 번째 ST_MAKEPOLYGON 유형의 경우 입력된 GEOGRAPHYNULL이면 ST_MAKEPOLYGONNULL을 반환합니다. 두 번째 유형의 경우 입력된 ARRAY 또는 ARRAY의 요소가 NULL이면 ST_MAKEPOLYOGNNULL을 반환합니다.

참고: ST_MAKEPOLYGON에 빈 GEOGRAPHY를 입력할 수 있습니다. ST_MAKEPOLYGON은 빈 GEOGRAPHY를 빈 유도선이 있는 것으로 해석하여 완전한 루프, 즉 지구 전체를 포함하는 다각형을 생성합니다.

제약조건

입력 링을 결합하면 유효한 다각형이 형성되어야 합니다.

  • 다각형 셸에는 각 다각형 구멍이 포함되어야 합니다.
  • 다각형 셸은 하나만 있을 수 있으며 첫 번째 입력 링이어야 합니다. 즉, 다각형 구멍은 중첩될 수 없습니다.
  • 다각형 링은 두 링의 경계에 있는 꼭짓점에서만 교차할 수 있습니다.

모든 모서리의 범위는 180도 미만이어야 합니다.

각 다각형 링은 구를 2개의 영역으로 나눕니다. ST_MAKEPOLYGON의 첫 번째 입력 유도선은 다각형 셸을 형성하며 다각형 내부는 두 영역 중 더 작은 영역으로 선택됩니다. 이후의 각 입력 유도선은 다각형 구멍을 지정하므로 다각형의 내부가 정확하게 정의됩니다. 다각형 셸을 정의할 때 두 영역 중 더 큰 영역이 다각형 내부가 되도록 하려면 ST_MAKEPOLYGONORIENTED를 참조하세요.

참고: BigQuery의 맞추기 프로세스는 아주 짧은 모서리를 삭제하고 2개의 끝점을 함께 맞춥니다. 따라서 꼭짓점이 함께 맞춰질 때 아주 작은 다각형 구멍이 사라지거나 출력 GEOGRAPHY에 선 또는 점만 포함될 수 있습니다.

반환 유형

GEOGRAPHY

ST_MAKEPOLYGONORIENTED

ST_MAKEPOLYGONORIENTED(array_of_geography)

설명

ST_MAKEPOLYGON과 유사하지만 각 입력 유도선의 꼭짓점 순서에 따라 각 다각형 링의 방향이 결정된다는 차이점이 있습니다. 다각형 링의 방향은 다각형의 내부를 정의합니다. 다각형 경계를 입력 꼭짓점의 순서대로 이동할 때 왼쪽 영역이 다각형의 내부입니다. 지정된 각 다각형 링에 동일한 정의가 적용됩니다.

ST_MAKEPOLYGONORIENTED는 다각형 내부가 다각형 링의 어느 한 쪽으로 정의되는 다각형을 구성할 수 있으므로 이 변이된 다각형 생성자가 보다 유연합니다. 그러나 다각형을 원하는 대로 구성하려면 올바른 다각형 링 방향이 중요합니다.

입력된 ARRAY 또는 ARRAY의 요소가 NULL이면 ST_MAKEPOLYGONORIENTEDNULL을 반환합니다.

참고: ST_MAKEPOLYGONORIENTED의 입력 인수에 빈 GEOGRAPHY가 포함될 수 있습니다. ST_MAKEPOLYGONORIENTED는 빈 GEOGRAPHY를 빈 유도선이 있는 것으로 해석하여 완전한 루프, 즉 지구 전체를 포함하는 다각형을 만듭니다.

제약조건

입력 링을 결합하면 유효한 다각형이 형성되어야 합니다.

  • 다각형 셸에는 각 다각형 구멍이 포함되어야 합니다.
  • 다각형 셸은 하나만 있어야 하며 첫 번째 입력 링이어야 합니다. 즉, 다각형 구멍은 중첩될 수 없습니다.
  • 다각형 링은 두 링의 경계에 있는 꼭짓점에서만 교차할 수 있습니다.

모든 모서리의 범위는 180도 미만이어야 합니다.

ST_MAKEPOLYGONORIENTED는 각 유도선의 입력 꼭짓점 순서에 따라 다각형의 방향을 결정합니다. 다각형 셸과 모든 다각형 구멍에도 같은 방식이 적용됩니다. ST_MAKEPOLYGONORIENTED을 사용할 때 모든 다각형 구멍은 셸과 반대 방향이어야 합니다. 다른 다각형 생성자와 유효한 다각형 빌드 시의 기타 제약조건은 ST_MAKEPOLYGON을 참조하세요.

참고: BigQuery의 맞추기 프로세스로 인해 길이가 아주 짧은 모서리는 삭제되고 2개의 끝점이 단일 점으로 맞춰집니다. 따라서 하나 이상의 모서리가 사라지도록 유도선의 꼭짓점을 함께 맞출 수 있습니다. 결과적으로 아주 작은 다각형 구멍이 사라지거나 결과 GEOGRAPHY에 선이나 점만 포함될 수 있습니다.

반환 유형

GEOGRAPHY

ST_GEOGFROMGEOJSON

ST_GEOGFROMGEOJSON(geojson_string)

설명

입력된 GeoJSON 표현에 해당하는 GEOGRAPHY 값을 반환합니다.

ST_GEOGFROMGEOJSONRFC 7946을 준수하는 입력을 사용합니다.

BigQuery GEOGRAPHY에는 구면 측지 모서리가 사용되는 반면 GeoJSON Geometry 객체에는 명시적으로 평면 모서리가 사용됩니다. 이 두 유형의 모서리가 서로 변환되도록 BigQuery는 필요한 경우 선에 점을 추가하여 변환된 일련의 모서리가 원래 모서리로부터 10미터 이내에서 유지되도록 합니다.

GEOGRAPHY를 GeoJSON 형식으로 만들려면 ST_ASGEOJSON을 참조하세요.

제약조건

입력에는 다음과 같은 제약조건이 적용됩니다.

  • ST_GEOGFROMGEOJSON은 JSON 도형 조각만 허용하며 전체 JSON 문서를 수집하는 데 사용할 수는 없습니다.
  • 입력된 JSON 조각은 GeoJSON 도형 유형으로 구성되어야 하며, 여기에는 Point, MultiPoint, LineString, MultiLineString, Polygon, MultiPolygon, GeometryCollection이 포함됩니다. Feature, FeatureCollection 등의 다른 GeoJSON 유형이 있으면 오류가 발생합니다.
  • GeoJSON 도형 유형의 coordinates 멤버에 지정되는 위치는 정확히 2개의 요소로 구성되어야 합니다. 첫 번째 요소는 경도이고 두 번째 요소는 위도입니다. 따라서 ST_GEOGFROMGEOJSONcoordinates 멤버의 위치에 선택적인 세 번째 요소를 지원하지 않습니다.

반환 유형

GEOGRAPHY

ST_GEOGFROMTEXT

ST_GEOGFROMTEXT(wkt_string)
ST_GEOGFROMTEXT(wkt_string, oriented)

설명

입력된 WKT 표현에 해당하는 GEOGRAPHY 값을 반환합니다.

이 함수는 BOOL, oriented 유형의 선택적 매개변수를 지원합니다. 이 매개변수가 TRUE로 설정되었으면 입력에 포함된 모든 다각형의 방향을 특정 방식으로 간주하게 됩니다. 즉, 다각형 경계를 입력 꼭짓점의 순서대로 이동할 때 왼쪽 영역이 다각형의 내부가 됩니다. 이 경우 WKT는 반구보다 큰 다각형을 나타낼 수 있습니다. orientedFALSE이거나 생략되었으면 이 함수는 보다 작은 면적의 다각형을 반환합니다. oriented=TRUEST_GEOGFROMTEXT와 유사한 ST_MAKEPOLYGONORIENTED도 참조하세요.

GEOGRAPHY를 WKT 형식으로 만들려면 ST_ASTEXT를 사용합니다.

제약조건

모든 입력 모서리는 평면 직선이 아닌 구면 측지선으로 간주됩니다. 평면 투영 데이터를 읽으려면 ST_GEOGFROMGEOJSON을 사용하는 것이 좋습니다. 구면 측지선과 평면 선 간의 차이점에 대한 자세한 내용은 좌표계와 모서리를 참조하세요.

반환 유형

GEOGRAPHY

예시

다음 쿼리는 WKT 문자열 POLYGON((0 0, 0 2, 2 2, 0 2, 0 0))을 방향이 지정되지 않은 다각형과 방향이 지정된 다각형으로 읽고 각 결과에 점 (1, 1)이 포함되었는지 확인합니다.

WITH polygon AS (SELECT 'Polygon((0 0, 0 2, 2 2, 2 0, 0 0))' AS p)
SELECT
  ST_CONTAINS(ST_GEOGFROMTEXT(p), ST_GEOGPOINT(1, 1)) AS fromtext_default,
  ST_CONTAINS(ST_GEOGFROMTEXT(p, FALSE), ST_GEOGPOINT(1, 1)) AS non_oriented,
  ST_CONTAINS(ST_GEOGFROMTEXT(p, TRUE),  ST_GEOGPOINT(1, 1)) AS oriented
FROM polygon;

+-------------------+---------------+-----------+
| fromtext_default  | non_oriented  | oriented  |
+-------------------+---------------+-----------+
| true              | true          | false     |
+-------------------+---------------+-----------+

ST_GEOGFROMWKB

ST_GEOGFROMWKB(wkb_bytes)

설명

입력된 WKB 표현에 해당하는 GEOGRAPHY 값을 반환합니다.

GEOGRAPHY를 WKB 형식으로 만들려면 ST_ASBINARY를 사용합니다.

제약조건

모든 입력 모서리는 평면 직선이 아니라 구면 측지선으로 간주됩니다. 평면 투영 데이터를 읽으려면 ST_GEOGFROMGEOJSON을 사용하는 것이 좋습니다.

반환 유형

GEOGRAPHY

ST_GEOGPOINTFROMGEOHASH

ST_STGEOGPOINTFROMGEOHASH(geohash)

설명

GeoHash에서 정의된 경계 상자의 가운데 점에 해당하는 GEOGRAPHY 값을 반환합니다.

반환 유형

GEOGRAPHY

ST_ASGEOJSON

ST_ASGEOJSON(geography_expression)

설명

입력된 GEOGRAPHYRFC 7946 준수 GeoJSON 표현을 반환합니다.

BigQuery GEOGRAPHY에는 구면 측지 모서리가 사용되는 반면 GeoJSON Geometry 객체에는 명시적으로 평면 모서리가 사용됩니다. 이 두 유형의 모서리가 서로 변환되도록 BigQuery는 필요한 경우 선에 점을 추가하여 변환된 일련의 모서리가 원래 모서리로부터 10미터 이내에서 유지되도록 합니다.

GeoJSON을 사용하여 GEOGRAPHY를 생성하려면 ST_GEOGFROMGEOJSON을 참조하세요.

반환 유형

STRING

ST_ASTEXT

ST_ASTEXT(geography_expression)

설명

입력된 GEOGRAPHYWKT 표현을 반환합니다.

WKT를 사용하여 GEOGRAPHY를 생성하려면 ST_GEOGFROMTEXT를 참조하세요.

반환 유형

STRING

ST_GEOHASH

ST_GEOHASH(geography_expression, maxchars)

설명

geography_expressionGeoHash 표현을 반환합니다. 반환되는 GeoHash에는 최대 maxchars자(영문 기준)가 포함됩니다. 이보다 적은 수의 문자는 더 낮은 정밀도에 해당합니다. 달리 설명하면 더 큰 경계 상자에 해당합니다.

GEOGRAPHY 객체에 대한 ST_GeoHash는 NULL을 반환합니다.

제약조건

  • 단일 점을 나타내는 GEOGRAPHY 객체만 지원됩니다.
  • maxchars의 최댓값은 20입니다.

예시

시애틀 센터의 GeoHash를 10자 정밀도로 반환합니다.

SELECT ST_GEOHASH(ST_GEOGPOINT(-122.35, 47.62), 10) geohash

+--------------+
| geohash      |
+--------------+
| c22yzugqw7   |
+--------------+

반환 유형

STRING

ST_ASBINARY

ST_ASBINARY(geography_expression)

설명

입력된 GEOGRAPHYWKB 표현을 반환합니다.

WKB를 사용하여 GEOGRAPHY를 생성하려면 ST_GEOGFROMWKB를 참조하세요.

반환 유형

BYTES

ST_BOUNDARY

ST_BOUNDARY(geography_expression)

설명

지정된 입력 GEOGRAPHY에 있는 각 구성 요소 경계의 합집합을 포함하는 단일 GEOGRAPHY를 반환합니다.

GEOGRAPHY의 각 구성 요소 경계는 다음과 같이 정의됩니다.

  • 점의 경계는 비어 있습니다.
  • 유도선의 경계는 유도선의 끝점으로 구성됩니다.
  • 다각형의 경계는 다각형 셸을 형성하는 유도선과 각 다각형 구멍으로 구성됩니다.

반환 유형

GEOGRAPHY

ST_CENTROID

ST_CENTROID(geography_expression)

설명

입력된 GEOGRAPHY중심을 단일 점 GEOGRAPHY로 반환합니다.

GEOGRAPHY중심GEOGRAPHY에서 가장 고차원인 구성요소의 가중 평균 중심입니다. 각 차원의 구성요소 중심은 다음과 같이 정의됩니다.

  • 점의 중심은 입력 좌표의 산술 평균입니다.
  • 유도선의 중심은 길이에 따라 가중치가 적용된 모든 모서리의 중심입니다. 각 모서리의 중심은 모서리의 측지 중간점입니다.
  • 다각형의 중심은 질량 중심입니다.

입력 GEOGRAPHY가 비어 있으면 빈 GEOGRAPHY가 반환됩니다.

제약조건

드물지만 GEOGRAPHY의 중심을 지구 표면의 단일 점으로 정의할 수 없는 경우에는 확정된 점이나 임의의 점이 반환됩니다. 이러한 경우는 대척점 쌍의 중심과 같이 중심이 정확히 지구 중심에 존재하는 경우에만 발생할 수 있으며 발생 가능성이 거의 없습니다.

반환 유형

GEOGRAPHY

ST_CLOSESTPOINT

ST_CLOSESTPOINT(geography_1, geography_2)
ST_CLOSESTPOINT(geography_1, geography_2, use_spheroid)

설명

geography_1 상에서 geography_2와의 거리가 가능한 한 가장 짧은 한 점을 포함하는 GEOGRAPHY를 반환합니다. 이는 ST_CLOSESTPOINT에서 반환된 점과 geography_2 사이의 거리가 geography_1에 있는 어떤 점과 geography_2 사이의 거리보다도 짧거나 같다는 것을 의미합니다.

입력 GEOGRAPHY 중 어느 하나라도 비어 있으면 ST_CLOSESTPOINTNULL을 반환합니다.

선택적인 use_spheroid 매개변수는 이 함수의 거리 측정 방식을 결정합니다. use_spheroidFALSE이면 이 함수는 완전한 구의 표면에서 거리를 측정합니다.

use_spheroid 매개변수는 현재 FALSE 값만 지원합니다. use_spheroid의 기본값은 FALSE입니다.

반환 유형

GEOGRAPHY

ST_DIFFERENCE

ST_DIFFERENCE(geography_1, geography_2)

설명

geography_1geography_2의 점 차집합을 나타내는 GEOGRAPHY를 반환합니다.

geometry_1geometry_2에 완전히 포함되어 있으면 ST_DIFFERENCE는 빈 GEOGRAPHY를 반환합니다.

제약조건

BigQuery GEOGRAPHY가 나타내는 기본 도형 객체는 닫힌 점 집합에 해당합니다. 따라서 ST_DIFFERENCEgeography_1geography_2의 점 차집합을 닫은 것입니다. 이는 geography_1geography_2가 교차할 경우 geography_2의 경계 일부가 차이에 포함될 수 있음을 뜻합니다.

반환 유형

GEOGRAPHY

ST_INTERSECTION

ST_INTERSECTION(geography_1, geography_2)

설명

두 입력 GEOGRAPHY의 점 교집합을 나타내는 GEOGRAPHY를 반환합니다. 따라서 교집합의 모든 점은 geography_1geography_2 모두에 나타납니다.

두 입력 GEOGRAPHY가 분리된 경우, 즉 입력된 geometry_1geometry_2 모두에 나타나는 점이 없는 경우에는 빈 GEOGRAPHY가 반환됩니다.

관련 조건자 함수는 ST_INTERSECTS, ST_DISJOINT를 참조하세요.

반환 유형

GEOGRAPHY

ST_SNAPTOGRID

ST_SNAPTOGRID(geography_expression, grid_size)

설명

각 꼭짓점이 경도/위도 그리드에 맞춰진 입력 GEOGRAPHY를 반환합니다. 그리드 크기는 도 단위로 지정된 grid_size 매개변수에 따라 결정됩니다.

제약조건

임의의 그리드 크기는 지원되지 않습니다. grid_size 매개변수는 $$10^n$$ 형식(단, $$-10 < n < 0$$)이 되도록 반올림됩니다.

반환 유형

GEOGRAPHY

ST_UNION

ST_UNION(geography_1, geography_2)
ST_UNION(array_of_geography)

설명

입력된 모든 GEOGRAPHY의 점 합집합을 나타내는 GEOGRAPHY를 반환합니다.

ST_UNION에는 2가지 유형이 있습니다. 첫 번째 유형에서는 GEOGRAPHY를 두 개 입력해야 합니다. 두 번째 유형에서는 GEOGRAPHY 유형의 ARRAY를 입력해야 합니다.

첫 번째 ST_UNION 유형의 경우 입력된 GEOGRAPHYNULL이면 ST_UNIONNULL을 반환합니다. 두 번째 유형의 경우 입력된 ARRAY 값이 NULL이면 ST_UNIONNULL을 반환합니다. 입력된 ARRAYNULL이 아니면 합집합이 계산되고 출력에 영향을 주지 않도록 NULL 요소가 무시됩니다.

ST_UNION의 집계 버전은 ST_UNION_AGG를 참조하세요.

반환 유형

GEOGRAPHY

ST_X

ST_X(geography_expression)

설명

단일 점 입력 GEOGRAPHY의 경도를 도 단위로 반환합니다.

입력 GEOGRAPHY가 단일 점이 아니면(빈 GEOGRAPHY인 경우 포함) ST_X는 오류를 반환합니다. NULL이 반환되도록 하려면 SAFE. 프리픽스를 사용하세요.

반환 유형

FLOAT64

예시

다음 예에서는 ST_XST_Y를 사용하여 단일 점 지리 객체의 좌표를 추출합니다.

WITH points AS
   (SELECT ST_GEOGPOINT(i, i + 1) AS p FROM UNNEST([0, 5, 12]) AS i)
 SELECT
   p,
   ST_X(p) as longitude,
   ST_Y(p) as latitude
FROM points;

+--------------+-----------+----------+
| p            | longitude | latitude |
+--------------+-----------+----------+
| POINT(0 1)   | 0.0       | 1.0      |
| POINT(5 6)   | 5.0       | 6.0      |
| POINT(12 13) | 12.0      | 13.0     |
+--------------+-----------+----------+

ST_Y

ST_Y(geography_expression)

설명

단일 점 입력 GEOGRAPHY의 위도를 도 단위로 반환합니다.

입력 GEOGRAPHY가 단일 점이 아니면(빈 GEOGRAPHY인 경우 포함) ST_Y는 오류를 반환합니다. 대신 NULL이 반환되도록 하려면 SAFE. 프리픽스를 사용하세요.

반환 유형

FLOAT64

예시

사용 예시는 ST_X를 참조하세요.

ST_CONTAINS

ST_CONTAINS(geography_1, geography_2)

설명

geography_2의 어떤 점도 geography_1 외부에 있지 않고 내부가 교차하면 TRUE를 반환하고, 그렇지 않으면 FALSE를 반환합니다.

참고: GEOGRAPHY에는 고유한 경계가 포함되어 있지 않습니다. ST_COVERS와 비교하세요.

반환 유형

BOOL

예시

다음 쿼리는 다각형 POLYGON((1 1, 20 1, 10 20, 1 1))에 각각 다각형의 외부, 경계, 내부에 위치한 3개의 점 (0, 0), (1, 1), (10, 10)이 포함되어 있는지 테스트합니다.

SELECT
  ST_GEOGPOINT(i, i) AS p,
  ST_CONTAINS(ST_GEOGFROMTEXT('POLYGON((1 1, 20 1, 10 20, 1 1))'),
              ST_GEOGPOINT(i, i)) AS `contains`
FROM UNNEST([0, 1, 10]) AS i;

+--------------+----------+
| p            | contains |
+--------------+----------+
| POINT(0 0)   | false    |
| POINT(1 1)   | false    |
| POINT(10 10) | true     |
+--------------+----------+

ST_COVEREDBY

ST_COVEREDBY(geography_1, geography_2)

설명

geography_1 또는 geography_2가 비어 있으면 FALSE를 반환합니다. geography_1의 어떠한 점도 geography_2의 외부에 있지 않으면 TRUE를 반환합니다.

GEOGRAPHYab이면 ST_COVEREDBY(a, b)ST_COVERS(b, a)와 동일한 결과를 반환합니다. 인수 순서가 반대라는 점에 유의하세요.

반환 유형

BOOL

ST_COVERS

ST_COVERS(geography_1, geography_2)

설명

geography_1 또는 geography_2가 비어 있으면 FALSE를 반환합니다. geography_2의 어떤 점도 geography_1의 외부에 있지 않으면 TRUE를 반환합니다.

반환 유형

BOOL

예시

다음 쿼리는 다각형 POLYGON((1 1, 20 1, 10 20, 1 1))에 각각 다각형의 외부, 경계, 내부에 위치한 3개의 점 (0, 0), (1, 1), (10, 10)이 포함되어 있는지 테스트합니다.

SELECT
  ST_GEOGPOINT(i, i) AS p,
  ST_COVERS(ST_GEOGFROMTEXT('POLYGON((1 1, 20 1, 10 20, 1 1))'),
            ST_GEOGPOINT(i, i)) AS `covers`
FROM UNNEST([0, 1, 10]) AS i;

+--------------+--------+
| p            | covers |
+--------------+--------+
| POINT(0 0)   | false  |
| POINT(1 1)   | true   |
| POINT(10 10) | true   |
+--------------+--------+

ST_DISJOINT

ST_DISJOINT(geography_1, geography_2)

설명

geography_1geography_2의 교차 영역이 비어 있으면, 즉 geography_1geography_2에 모두 나타나는 점이 없으면 TRUE를 반환합니다.

ST_DISJOINTST_INTERSECTS의 논리적 부정입니다.

반환 유형

GEOGRAPHY

ST_DWITHIN

ST_DWITHIN(geography_1, geography_2), distance)
ST_DWITHIN(geography_1, geography_2, distance, use_spheroid)

설명

geography_1에 있는 하나 이상의 점과 geography_2에 있는 한 점 사이의 거리가 distance 인수로 지정된 거리보다 짧거나 같으면 TRUE를 반환하고, 그렇지 않으면 FALSE를 반환합니다. 두 입력 GEOGRAPHY 중 어느 하나가 비어 있으면 ST_DWithinFALSE를 반환합니다. 지정된 distance는 지구 표면 상의 미터 단위 거리입니다.

선택적인 use_spheroid 매개변수는 이 함수의 거리 측정 방식을 결정합니다. use_spheroidFALSE이면 이 함수는 완전한 구의 표면에서 거리를 측정합니다.

use_spheroid 매개변수는 현재 FALSE 값만 지원합니다. use_spheroid의 기본값은 FALSE입니다.

반환 유형

BOOL

ST_EQUALS

ST_EQUALS(geography_1, geography_2)

설명

geography_1geography_2가 동일한 GEOGRAPHY 값을 나타내면 TRUE를 반환합니다. 더 정확히 말해 이는 다음 조건 중 하나가 충족됨을 의미합니다.

  • ST_COVERS(geography_1, geography_2) = TRUE이고 ST_COVERS(geography_2, geography_1) = TRUE입니다.
  • geography_1geography_2가 모두 비어 있습니다.

따라서 점과 꼭짓점의 순서가 다르더라도 동일한 도형 구조를 나타내기만 하면 두 개의 GEOGRAPHY가 동일할 수 있습니다.

제약조건

ST_EQUALS는 전환 함수가 아닐 수도 있습니다.

반환 유형

BOOL

ST_INTERSECTS

ST_INTERSECTS(geography_1, geography_2)

설명

geography_1geography_2의 점 교집합이 비어 있지 않으면 TRUE를 반환합니다. 따라서 입력된 두 GEOGRAPHY에 나타나는 점이 최소 한 개 이상 있으면 이 함수는 TRUE를 반환합니다.

ST_INTERSECTSTRUE를 반환하면 ST_DISJOINTFALSE를 반환합니다.

반환 유형

BOOL

ST_INTERSECTSBOX

ST_INTERSECTSBOX(geography, lng1, lat1, lng2, lat2)

설명

geography[lng1, lng2][lat1, lat2] 사이의 직사각형과 교차하면 TRUE를 반환합니다. 직사각형의 모서리는 상수 경도 및 위도 선을 따릅니다. lng1lng2는 직사각형의 경계를 이루는 최소 및 최대 경도 선을 지정하고, lat1lat2은 직사각형의 경계를 이루는 최소 및 최대 상수 위도 선을 지정합니다.

모든 경도 및 위도 인수는 도 단위로 지정합니다.

제약조건

입력 인수에는 다음과 같은 제약조건이 적용됩니다.

  • 위도는 도 단위로 [-90, 90] 범위여야 합니다.
  • 경도는 도 단위로 [-180, 180] 범위여야 합니다.

반환 유형

BOOL

ST_TOUCHES

ST_TOUCHES(geography_1, geography_2)

설명

다음 두 조건이 충족되면 TRUE를 반환합니다.

  1. geography_1geography_2와 교차합니다.
  2. geography_1의 내부와 geography_2의 내부는 분리되어 있습니다.

반환 유형

BOOL

ST_WITHIN

ST_WITHIN(geography_1, geography_2)

설명

geography_1의 어떠한 점도 geography_2 외부에 있지 않고 geography_1geography_2의 내부가 교차하면 TRUE를 반환합니다.

두 지리 위치가 ab이면 ST_WITHIN(a, b)ST_CONTAINS(b, a)와 동일한 결과를 반환합니다. 인수 순서가 반대라는 점에 유의하세요.

반환 유형

BOOL

ST_ISEMPTY

ST_ISEMPTY(geography_expression)

설명

지정된 GEOGRAPHY가 비어 있으면, 즉 GEOGRAPHY에 점, 선 또는 다각형이 전혀 포함되어 있지 않으면 TRUE를 반환합니다.

참고: 빈 BigQuery GEOGRAPHY는 특정 도형과 연결되어 있지 않습니다. 예를 들어 표현식 ST_GEOGFROMTEXT('POINT EMPTY')ST_GEOGFROMTEXT('GEOMETRYCOLLECTION EMPTY')의 결과가 동일합니다.

반환 유형

BOOL

ST_ISCOLLECTION

ST_ISCOLLECTION(geography_expression)

설명

점, 유도선, 다각형의 총 개수가 1보다 크면 TRUE를 반환합니다.

GEOGRAPHY는 컬렉션이 아닙니다.

반환 유형

BOOL

ST_DIMENSION

ST_DIMENSION(geography_expression)

설명

입력 GEOGRAPHY의 요소 중 가장 고차원인 요소의 차원 수를 반환합니다.

가능한 각 요소의 차원은 다음과 같습니다.

  • 점의 차원 수는 0입니다.
  • 유도선의 차원 수는 1입니다.
  • 다각형의 차원 수는 2입니다.

입력 GEOGRAPHY가 비어 있으면 ST_DIMENSION-1을 반환합니다.

반환 유형

INT64

ST_NUMPOINTS

ST_NUMPOINTS(geography_expression)

설명

입력 GEOGRAPHY의 꼭짓점 수를 반환합니다. 이 수에는 점 수, 유도선 꼭짓점 수, 다각형 꼭짓점 수가 포함됩니다.

참고: 다각형 링의 첫 번째 꼭짓점과 마지막 꼭지점은 별개의 꼭지점으로 간주됩니다.

반환 유형

INT64

ST_AREA

ST_AREA(geography_expression)
ST_AREA(geography_expression, use_spheroid)

설명

입력 GEOGRAPHY에서 다각형이 차지하는 면적을 제곱미터 단위로 반환합니다.

geography_expression이 점 또는 선이면 0이 반환됩니다. geography_expression이 컬렉션이면 컬렉션의 다각형 면적이 반환됩니다. 컬렉션에 다각형이 포함되지 않았으면 0이 반환됩니다.

선택적인 use_spheroid 매개변수는 이 함수의 거리 측정 방식을 결정합니다. use_spheroidFALSE이면 이 함수는 완전한 구의 표면에서 거리를 측정합니다.

use_spheroid 매개변수는 현재 FALSE 값만 지원합니다. use_spheroid의 기본값은 FALSE입니다.

반환 유형

FLOAT64

ST_DISTANCE

ST_DISTANCE(geography_1, geography_2)
ST_DISTANCE(geography_1, geography_2, use_spheroid)

설명

비어 있지 않은 두 GEOGRAPHY 간의 최단 거리를 미터 단위로 반환합니다.

입력 GEOGRAPHY 중 어느 하나라도 비어 있으면 ST_DISTANCENULL을 반환합니다.

선택적인 use_spheroid 매개변수는 이 함수의 거리 측정 방식을 결정합니다. use_spheroidFALSE이면 이 함수는 완전한 구의 표면에서 거리를 측정합니다.

use_spheroid 매개변수는 현재 FALSE 값만 지원합니다. use_spheroid의 기본값은 FALSE입니다.

반환 유형

FLOAT64

ST_LENGTH

ST_LENGTH(geography_expression)
ST_LENGTH(geography_expression, use_spheroid)

설명

입력 GEOGRAPHY에 있는 선의 총 길이를 미터 단위로 반환합니다.

geography_expression이 점 또는 다각형이면 0이 반환됩니다. geography_expression이 컬렉션이면 컬렉션의 선 길이가 반환됩니다. 컬렉션에 선이 포함되지 않았으면 0이 반환됩니다.

선택적인 use_spheroid 매개변수는 이 함수의 거리 측정 방식을 결정합니다. use_spheroidFALSE이면 이 함수는 완전한 구의 표면에서 거리를 측정합니다.

use_spheroid 매개변수는 현재 FALSE 값만 지원합니다. use_spheroid의 기본값은 FALSE입니다.

반환 유형

FLOAT64

ST_MAXDISTANCE

ST_MAXDISTANCE(geography_1, geography_2)
ST_MAXDISTANCE(geography_1, geography_2, use_spheroid)

비어 있지 않은 두 GEOGRAPHY 사이의 최장 거리, 즉 첫 번째 GEOGRAPHY에 있는 꼭짓점과 두 번째 GEOGRAPHY에 있는 꼭짓점 사이의 최장 거리를 미터 단위로 반환합니다. geography_1geography_2가 동일한 GEOGRAPHY이면 이 함수는 해당 GEOGRAPHY에서 가장 멀리 떨어진 두 꼭짓점 사이의 거리를 반환합니다.

입력 GEOGRAPHY 중 어느 하나라도 비어 있으면 ST_MAXDISTANCENULL을 반환합니다.

선택적인 use_spheroid 매개변수는 이 함수의 거리 측정 방식을 결정합니다. use_spheroidFALSE이면 이 함수는 완전한 구의 표면에서 거리를 측정합니다.

use_spheroid 매개변수는 현재 FALSE 값만 지원합니다. use_spheroid의 기본값은 FALSE입니다.

반환 유형

FLOAT64

ST_PERIMETER

ST_PERIMETER(geography_expression)
ST_PERIMETER(geography_expression, use_spheroid)

설명

입력 GEOGRAPHY의 다각형 경계 길이를 미터 단위로 반환합니다.

geography_expression이 점 또는 선이면 0이 반환됩니다. geography_expression이 컬렉션이면 컬렉션의 다각형 둘레가 반환됩니다. 컬렉션에 다각형이 포함되지 않았으면 0이 반환됩니다.

선택적인 use_spheroid 매개변수는 이 함수의 거리 측정 방식을 결정합니다. use_spheroidFALSE이면 이 함수는 완전한 구의 표면에서 거리를 측정합니다.

use_spheroid 매개변수는 현재 FALSE 값만 지원합니다. use_spheroid의 기본값은 FALSE입니다.

반환 유형

FLOAT64

ST_UNION_AGG

ST_UNION_AGG(geography)

설명

입력된 모든 GEOGRAPHY의 점 합집합을 나타내는 GEOGRAPHY를 반환합니다.

ST_UNION_AGG는 입력된 NULLGEOGRAPHY 값을 무시합니다.

ST_UNION_AGG의 비집계 버전은 ST_UNION을 참조하세요.

반환 유형

GEOGRAPHY

ST_CENTROID_AGG

ST_CENTROID_AGG(geography)

설명

입력 GEOGRAPHY 집합의 중심을 단일 점 GEOGRAPHY로 계산합니다.

입력된 GEOGRAPHY 집합의 중심은 각 개별 GEOGRAPHY 중심의 가중 평균입니다. 전체 집합의 중심을 계산하는 데는 입력에 있는 가장 고차원인 GEOGRAPHY만 사용됩니다. 예를 들어 입력에 선이 있는 GEOGRAPHY와 점만 있는 GEOGRAPHY가 모두 포함되었으면 선이 있는 경우가 가장 차원이 높으므로 ST_CENTROID_AGG는 이 GEOGRAPHY의 가중 평균을 반환합니다. 이 예시에서 ST_CENTROID_AGG는 집계 중심을 계산할 때 점만 있는 GEOGRAPHY를 무시합니다.

ST_CENTROID_AGG는 입력된 NULLGEOGRAPHY 값을 무시합니다.

ST_CENTROID_AGG의 비집계 버전과 개별 GEOGRAPHY 값 중심에 대한 정의는 ST_CENTROID를 참조하세요.

반환 유형

GEOGRAPHY

예시

다음 쿼리는 GEOGRAPHY 값 집합의 집계 중심을 계산합니다. 첫 번째 쿼리의 입력에는 점만 포함되어 있으므로 각 값이 집계 중심을 계산하는 데 사용됩니다. 또한 ST_UNION_AGG 결과에 대해 ST_CENTROID를 호출할 경우 ST_CENTROID_AGG와 달리 합집합을 구하는 과정에서 중복 요소가 삭제되므로 ST_CENTROID_AGG와 같지 않습니다. 두 번째 쿼리의 입력에는 차원이 혼합되었으므로 집합에서 가장 고차원 값인 선만 집계 중심에 영향을 줍니다.

SELECT ST_CENTROID_AGG(points) AS st_centroid_agg,
ST_CENTROID(ST_UNION_AGG(points)) AS centroid_of_union
FROM UNNEST([ST_GEOGPOINT(1, 5),
             ST_GEOGPOINT(1, 2),
             ST_GEOGPOINT(1, -1),
             ST_GEOGPOINT(1, -1)]) points;

+---------------------------+-------------------+
| st_centroid_agg           | centroid_of_union |
+---------------------------+-------------------+
| POINT(1 1.24961422620969) | POINT(1 2)        |
+---------------------------+-------------------+

SELECT ST_CENTROID_AGG(points) AS st_centroid_agg
FROM UNNEST([ST_GEOGPOINT(50, 26),
             ST_GEOGPOINT(34, 33.3),
             ST_GEOGFROMTEXT('LINESTRING(0 -1, 0 1)')
             ST_GEOGFROMTEXT('LINESTRING(0 1, 0 3)')]) points;

+-----------------+
| st_centroid_agg |
+-----------------+
| POINT(0 1)      |
+-----------------+

https://en.wikipedia.org/wiki/Geohash "GeoHash"

보안 함수

BigQuery는 다음 보안 함수를 지원합니다.

SESSION_USER

SESSION_USER()

설명

쿼리를 실행 중인 사용자의 이메일 주소를 반환합니다.

반환 데이터 유형

STRING

예시

SELECT SESSION_USER() as user;

+----------------------+
| user                 |
+----------------------+
| jdoe@example.com     |
+----------------------+

UUID 함수

BigQuery는 다음과 같은 범용 고유 식별자(UUID) 함수를 지원합니다.

GENERATE_UUID

GENERATE_UUID()

설명

임의의 범용 고유 식별자(UUID)를 STRING으로 반환합니다. 반환되는 STRING은 16진수 32개가 하이픈으로 구분된 5개 그룹으로 나뉜 8-4-4-4-12 형식으로 구성됩니다. 16진수는 RFC 4122 섹션 4.4에 따라 임의 비트 122개와 고정 비트 6개를 나타냅니다. 반환되는 STRING은 소문자입니다.

반환 데이터 유형

STRING

예시

다음 쿼리는 임의의 UUID를 생성합니다.

SELECT GENERATE_UUID() AS uuid;

위 쿼리는 다음과 같은 결과를 생성합니다.

+--------------------------------------+
| uuid                                 |
+--------------------------------------+
| 4192bff0-e1e0-43ce-a4db-912808c32493 |
+--------------------------------------+

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_bytesprefix_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 주소의 최하위 비트는 호스트 또는 클라이언트 아키텍처에 상관없이 정수의 최하위 비트에 저장됩니다. 예를 들어 10.0.0.1을 뜻하며, 0x1FF0.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 주소의 최하위 비트는 호스트 또는 클라이언트 아키텍처에 상관없이 정수의 최하위 비트에 저장됩니다. 예를 들어 10.0.0.1을 뜻하며, 0x1FF0.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"
);
입력 설명 호스트 서픽스 도메인
"" 입력 잘못됨 NULL NULL NULL
"http://abc.xyz" 표준 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"
);
입력 설명 호스트 서픽스 도메인
"" 입력 잘못됨 NULL NULL NULL
"http://abc.xyz" 표준 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"
);
입력 설명 호스트 서픽스 도메인
"" 입력 잘못됨 NULL NULL NULL
"http://abc.xyz" 표준 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을 반환합니다.
  • 계산 결과가 오버플로인 경우 모든 연산자가 오류를 생성합니다.
  • 모든 부동 소수점 연산의 경우, +/-infNaN은 피연산자 중 하나가 +/-inf 또는 NaN일 때만 반환될 수 있습니다. 그 외의 경우에는 오류가 반환됩니다.

아래 표는 모든 BigQuery 연산자를 우선순위(즉, 문 내에서 평가되는 순서)대로 나열한 것입니다.

우선순위 연산자 입력 데이터 유형 이름 연산자 항
1 . STRUCT
멤버 필드 액세스 연산자 이항
  [ ] ARRAY 배열 위치. OFFSET 또는 ORDINAL과 함께 사용해야 함. ARRAY 함수 참조. 이항
2 - 모든 숫자 유형 단항 뺄셈 단항
  ~ 정수 또는 BYTES 비트 NOT 단항
3 * 모든 숫자 유형 곱셈 이항
  / 모든 숫자 유형 나눗셈 이항
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 또는 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 함수를 사용해 보세요.

덧셈과 곱셈의 결과 유형:

 INT64NUMERICFLOAT64
INT64INT64NUMERICFLOAT64
NUMERICNUMERICNUMERICFLOAT64
FLOAT64FLOAT64FLOAT64FLOAT64

뺄셈의 결과 유형:

 INT64NUMERICFLOAT64
INT64INT64NUMERICFLOAT64
NUMERICNUMERICNUMERICFLOAT64
FLOAT64FLOAT64FLOAT64FLOAT64

나눗셈의 결과 유형:

 INT64NUMERICFLOAT64
INT64FLOAT64NUMERICFLOAT64
NUMERICNUMERICNUMERICFLOAT64
FLOAT64FLOAT64FLOAT64FLOAT64

단항 뺄셈의 결과 유형:

입력 데이터 유형 결과 데이터 유형
INT64 INT64
NUMERIC NUMERIC
FLOAT64 FLOAT64

비트 연산자

모든 비트 연산자는 첫 번째 피연산자와 동일한 유형과 동일한 길이를 반환합니다.

이름 구문 입력 데이터 유형 설명
비트 NOT ~ X 정수 또는 BYTES 각 비트에 대해 논리 부정을 수행하며 주어진 2진수 값의 여집합을 형성합니다.
비트 OR X | Y X: 정수 또는 BYTES
Y: X와 동일한 유형
길이가 같은 2개의 비트 패턴을 취하며 해당 비트의 각 쌍에서 포괄적 논리합 연산을 수행합니다. 이 연산자는 X와 Y의 BYTES 길이가 다른 경우 오류를 생성합니다.
비트 XOR X ^ Y X: 정수 또는 BYTES
Y: X와 동일한 유형
길이가 같은 2개의 비트 패턴을 취하며 해당 비트의 각 쌍에서 배타적 논리합 연산을 수행합니다. 이 연산자는 X와 Y의 BYTES 길이가 다른 경우 오류를 생성합니다.
비트 AND X & Y X: 정수 또는 BYTES
Y: X와 동일한 유형
길이가 같은 2개의 비트 패턴을 취하며 해당 비트의 각 쌍에서 논리곱 연산을 수행합니다. 이 연산자는 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가 음수이면 오류를 생성합니다.

논리 연산자

모든 논리 연산자는 BOOL 입력만 허용합니다.

이름 구문 설명
논리 부정 NOT X 입력이 TRUE이면 FALSE를 반환합니다. 입력이 FALSE이면 TRUE를 반환합니다. 그 밖의 경우에는 NULL을 반환합니다.
논리곱 X AND Y 적어도 하나의 입력이 FALSE이면 FALSE를 반환합니다. X와 Y가 모두 TRUE이면 TRUE를 반환합니다. 그 밖의 경우에는 NULL을 반환합니다.
논리합 X OR Y X와 Y가 모두 FALSE이면 FALSE를 반환합니다. 적어도 하나의 입력이 TRUE이면 TRUE를 반환합니다. 그 밖의 경우에는 NULL을 반환합니다.

비교 연산자

비교는 항상 BOOL을 반환합니다. 비교를 하려면 일반적으로 두 피연산자가 동일한 유형이어야 합니다. 피연산자 유형이 다르고 BigQuery가 정밀도를 유지하면서 해당 유형의 값을 공통된 유형으로 변환할 수 있는 경우, 일반적으로 BigQuery는 비교를 위해 공통된 유형으로 값을 강제합니다. BigQuery는 일반적으로 리터럴을 비 리터럴 유형으로 강제합니다(존재하는 경우). 비교할 수 있는 데이터 유형은 데이터 유형에 정의되어 있습니다.

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가 지정한 패턴과 일치하는지 확인합니다. 표현식에 다음과 같은 문자를 포함할 수 있습니다.
  • 퍼센트 기호 '%'는 임의의 수의 문자나 바이트와 일치합니다.
  • 밑줄 '_'은 하나의 문자나 바이트와 일치합니다.
  • 백슬래시 2개를 사용하여 '\', '_', '%'를 이스케이프 처리할 수 있습니다. 예: "\\%". 원시 문자열을 사용할 경우, 백슬래시가 하나만 필요합니다. 예: r"\%".
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 목록에서 NULLNOT 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를 반환합니다.

조건식

조건식은 입력의 평가 순서에 제약을 적용하며 기본적으로 단락을 통해 왼쪽에서 오른쪽으로 평가되며 선택된 출력 값만을 평가합니다. 반대로, 정규 함수의 모든 입력은 함수를 호출하기 전에 평가됩니다. 조건식의 단락은 오류 처리나 성능 조정에 유용합니다.

구문 입력 데이터 유형 결과 데이터 유형 설명

CASE expr
  WHEN value THEN result
  [WHEN ...]
  [ELSE else_result]
  END
exprvalue: 모든 유형 resultelse_result: 입력 유형의 상위 유형. expr과 연속된 각각의 WHEN 절의 값을 비교하여 true를 반환하는 첫 번째 결과를 반환합니다. 나머지 WHEN 절과 else_result는 평가되지 않습니다. expr = value 비교가 모든 WHEN 절에 대해 false 또는 NULL을 반환하는 경우, 있으면 else_result를 반환하고, 없으면 NULL을 반환합니다. exprvalue 표현식은 암시적으로 일반적인 상위 유형으로 강제 변환될 수 있어야 합니다. 강제 변환된 값에서 동등 비교가 수행됩니다. resultelse_result 표현식은 일반적인 상위 유형으로 강제 변환될 수 있어야 합니다.

CASE
  WHEN cond1 THEN result
  [WHEN cond2...]
  [ELSE else_result]
  END
cond: BOOL resultelse_result: 입력 유형의 상위 유형. 연속된 각각의 WHEN 절에 대해 조건 cond를 평가하여 조건이 true인 첫 번째 결과를 반환합니다. 나머지 WHEN 절과 else_result는 평가되지 않습니다. 모든 조건이 false 또는 NULL인 경우, else_result가 있으면 이를 반환하고 없으면 NULL을 반환합니다. resultelse_result 표현식은 공통 상위 유형으로 묵시적 강제 변환이 가능해야 합니다.
COALESCE(expr1, ..., exprN) 모든 유형 입력 유형의 상위 유형 null이 아닌 첫 번째 표현식의 값을 반환합니다. 나머지 표현식은 평가되지 않습니다. 모든 입력 표현식은 공통 상위 유형으로 묵시적 강제 변환이 가능해야 합니다.
IF(cond, true_result, else_result) cond: BOOL true_resultelse_result: 모든 유형 cond가 true인 경우 true_result를 반환하고, 그 밖의 경우 else_result를 반환합니다. cond가 true인 경우 else_result가 평가되지 않습니다. cond가 false이거나 NULL이면 true_result가 평가되지 않습니다. true_resultelse_result는 공통 상위 유형으로 강제 변환될 수 있어야 합니다.
IFNULL(expr, null_result) 모든 유형 모든 유형 또는 입력 유형의 상위 유형. exprNULL이면 null_result를 반환합니다. 그렇지 않은 경우 expr을 반환합니다. exprNULL이 아닌 경우, null_result가 평가되지 않습니다. exprnull_result는 공통 상위 유형으로 묵시적으로 강제 변환될 수 있어야 합니다. COALESCE(expr, null_result)의 동의어입니다.
NULLIF(expression, expression_to_match) 모든 T 유형 또는 T의 하위 유형 모든 T 유형 또는 T의 하위 유형 NULL가 true이면 expression = expression_to_match을 반환하고 그렇지 않으면 expression을 반환합니다. expressionexpression_to_match는 공통 상위 유형으로 묵시적으로 강제 변환될 수 있어야 합니다. 강제 변환된 값에서 동등 비교가 수행됩니다.

표현식 하위 쿼리

표현식 서브 쿼리, 즉 표현식으로 사용되는 서브 쿼리에는 4가지 유형이 있습니다. 표현식 서브 쿼리는 열이나 테이블과 반대로 NULL 또는 단일 값을 반환하며 괄호로 묶여야 합니다. 서브 쿼리에 대한 자세한 내용은 서브 쿼리를 참조하세요.

서브 쿼리 유형 결과 데이터 유형 설명
Scalar 모든 T 유형 표현식 안에 괄호로 묶인 서브 쿼리(예: SELECT 목록 또는 WHERE 절 내)는 스칼라 서브 쿼리로 해석됩니다. 스칼라 서브 쿼리의 SELECT 목록은 정확히 1개의 필드를 가져야 합니다. 서브 쿼리가 정확히 1개의 행을 반환할 경우, 그 단일 값이 스칼라 서브 쿼리 결과입니다. 서브 쿼리가 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_arrayARRAY<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  

디버깅 함수

BigQuery는 다음 디버깅 함수를 지원합니다.

오류

ERROR(error_message)

설명

오류를 반환합니다. error_message 인수는 STRING입니다.

BigQuery는 오류가 발생할 수 있는 표현식과 같은 방법으로 ERROR를 취급합니다. 특별히 보장되는 평가 순서는 없습니다.

반환 데이터 유형

BigQuery는 컨텍스트에서 반환 유형을 추론합니다.

예시

다음 예시에서 쿼리는 행 값이 정의된 두 값 중 하나와 일치하지 않으면 오류 메시지를 반환합니다.

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

다음 예시에서 BigQuery는 x > 0 조건 전 또는 후에 ERROR 함수를 평가할 수 있습니다. 일반적으로 BigQuery는 WHERE 절 조건 간의 순서를 보장하지 않으며 ERROR 함수에는 특별한 보장이 없기 때문입니다.

SELECT *
FROM (SELECT -1 AS x)
WHERE x > 0 AND ERROR('Example error');

다음 예시에서 WHERE 절은 IF 조건을 평가하고 조건이 실패한 경우에만 BigQuery가 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
이 페이지가 도움이 되었나요? 평가를 부탁드립니다.

다음에 대한 의견 보내기...

도움이 필요하시나요? 지원 페이지를 방문하세요.