표준 SQL의 집계 함수

집계 함수는 값 집합에서 계산을 수행하는 함수입니다. 집계 함수의 예로는 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은 최소 가능 값입니다. 즉, ASC 정렬에서는 NULL이 가장 먼저 나타나고 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은 최소 가능 값입니다. 즉, ASC 정렬에서는 NULL이 가장 먼저 나타나고 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. expression 이외의 값으로 평가된 NULL이 있는 행의 수를 반환합니다.

지원되는 인수 유형

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은 최소 가능 값입니다. 즉, ASC 정렬에서는 NULL이 가장 먼저 나타나고 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   |
+---+-----+

이 페이지가 도움이 되었나요? 평가를 부탁드립니다.

다음에 대한 의견 보내기...

도움이 필요하시나요? 지원 페이지를 방문하세요.