데브러너 (DevRunner)

14.19.1 Aggregate Function Descriptions

이 섹션에서는 값 집합에 대해 동작하는 집계 함수(aggregate function)를 설명합니다. 이 함수들은 값을 부분집합으로 묶기 위해 GROUP BY 절과 함께 자주 사용됩니다.

Table 14.29 Aggregate Functions

Name	Description
`AVG()`	인수의 평균 값을 반환
`BIT_AND()`	비트 단위 AND를 반환
`BIT_OR()`	비트 단위 OR를 반환
`BIT_XOR()`	비트 단위 XOR를 반환
`COUNT()`	반환된 행 수를 카운트하여 반환
`COUNT(DISTINCT)`	서로 다른 값의 개수를 반환
`GROUP_CONCAT()`	연결된 문자열을 반환
`JSON_ARRAYAGG()`	결과 집합을 단일 JSON 배열로 반환
`JSON_OBJECTAGG()`	결과 집합을 단일 JSON 객체로 반환
`MAX()`	최대 값을 반환
`MIN()`	최소 값을 반환
`STD()`	모집단 표준편차를 반환
`STDDEV()`	모집단 표준편차를 반환
`STDDEV_POP()`	모집단 표준편차를 반환
`STDDEV_SAMP()`	표본 표준편차를 반환
`SUM()`	합계를 반환
`VAR_POP()`	모집단 분산을 반환
`VAR_SAMP()`	표본 분산을 반환
`VARIANCE()`	모집단 분산을 반환

Name	Description

별도로 명시되지 않은 한, 집계 함수는 NULL 값을 무시합니다.

GROUP BY 절이 없는 문장에서 집계 함수를 사용하면, 모든 행을 하나의 그룹으로 묶는 것과 동일합니다. 자세한 내용은 Section 14.19.3, “MySQL Handling of GROUP BY”를 참조하십시오.

대부분의 집계 함수는 윈도 함수로 사용할 수 있습니다. 이렇게 사용할 수 있는 함수들은 구문 설명에서 선택적 OVER 절을 나타내는 [over_clause]로 표시됩니다.

over_clause 에 대해서는 Section 14.20.2, “Window Function Concepts and Syntax”에 설명되어 있으며, 여기에는 윈도 함수 사용에 대한 기타 정보도 포함되어 있습니다.

숫자 인수의 경우, 분산과 표준편차 함수는 DOUBLE 값을 반환합니다.

SUM()과 AVG() 함수는 정확값 인수 (정수 또는 DECIMAL)에 대해서는 DECIMAL 값을, 근사값 인수 ( FLOAT 또는 DOUBLE)에 대해서는 DOUBLE 값을 반환합니다.

SUM()과 AVG() 집계 함수는 시간 값과 함께 동작하지 않습니다. (이 함수들은 값을 숫자로 변환하면서 첫 번째 비숫자 문자 이후의 모든 것을 잃어버립니다.) 이 문제를 우회하려면, 숫자 단위로 변환한 후 집계 연산을 수행하고, 다시 시간 값으로 변환하십시오. 예:

1SELECT SEC_TO_TIME(SUM(TIME_TO_SEC(time_col))) FROM tbl_name;
2SELECT FROM_DAYS(SUM(TO_DAYS(date_col))) FROM tbl_name;

SUM() 또는 AVG()처럼 숫자 인수를 기대하는 함수는 필요하다면 인수를 숫자로 캐스팅합니다.

SET 또는 ENUM 값의 경우, 캐스트 연산으로 인해 내부 숫자 값이 사용됩니다.

BIT_AND(), BIT_OR(), BIT_XOR() 집계 함수는 비트 연산을 수행합니다.

MySQL 비트 함수와 연산자는 바이너리 문자열 타입 인수 ( BINARY, VARBINARY, 및 BLOB 타입)를 허용하며, 이와 같은 타입의 값을 반환합니다. 이를 통해 64비트보다 큰 인수와 반환 값을 사용할 수 있습니다. 인수 평가와 비트 연산에 대한 결과 타입에 대한 논의는 Section 14.12, “Bit Functions and Operators”의 도입부 논의를 참조하십시오.

AVG([DISTINCT] expr) [over_clause]

expr의 평균 값을 반환합니다. DISTINCT 옵션을 사용하면, expr 의 서로 다른 값들의 평균을 반환할 수 있습니다.

일치하는 행이 없으면 AVG()는 NULL을 반환합니다. expr 이 NULL인 경우에도 함수값은 NULL입니다.

over_clause 가 존재하면 이 함수는 윈도 함수로 실행됩니다. over_clause 에 대해서는 Section 14.20.2, “Window Function Concepts and Syntax”에 설명되어 있으며, DISTINCT와 함께 사용할 수 없습니다.

1mysql> SELECT student_name, AVG(test_score)
2         FROM student
3         GROUP BY student_name;

BIT_AND(expr) [over_clause]

expr 의 모든 비트에 대한 비트 단위 AND를 반환합니다.

결과 타입은 함수 인수 값이 바이너리 문자열로 평가되는지 숫자로 평가되는지에 따라 달라집니다:

인수 값이 바이너리 문자열 타입이고, 인수가 16진 리터럴, 비트 리터럴, 또는 NULL 리터럴이 아니면 바이너리 문자열 평가가 발생합니다. 그 외의 경우에는 숫자 평가가 수행되며, 필요 시 인수 값은 부호 없는 64비트 정수로 변환됩니다.
바이너리 문자열 평가는 인수 값과 동일한 길이의 바이너리 문자열을 생성합니다. 인수 값의 길이가 서로 다르면 ER_INVALID_BITWISE_OPERANDS_SIZE 오류가 발생합니다. 인수 크기가 511바이트를 초과하면 ER_INVALID_BITWISE_AGGREGATE_OPERANDS_SIZE 오류가 발생합니다. 숫자 평가는 부호 없는 64비트 정수를 생성합니다.

일치하는 행이 없으면, BIT_AND()는 인수 값과 동일한 길이를 가지는 중립값(모든 비트가 1로 설정된 값)을 반환합니다.

NULL 값은 모든 값이 NULL인 경우를 제외하고 결과에 영향을 미치지 않습니다. 이 경우 결과는 인수 값과 동일한 길이를 가지는 중립값입니다.

인수 평가와 결과 타입에 대한 보다 자세한 논의는 Section 14.12, “Bit Functions and Operators”의 도입부 논의를 참조하십시오.

BIT_AND()가 mysql 클라이언트 내에서 호출되면, 바이너리 문자열 결과는 --binary-as-hex 값에 따라 16진수 표기법으로 표시됩니다. 이 옵션에 대한 자세한 내용은 Section 6.5.1, “mysql — The MySQL Command-Line Client”를 참조하십시오.

over_clause 가 존재하면 이 함수는 윈도 함수로 실행됩니다. over_clause 에 대해서는 Section 14.20.2, “Window Function Concepts and Syntax”에 설명되어 있습니다.

BIT_OR(expr) [over_clause]

expr 의 모든 비트에 대한 비트 단위 OR를 반환합니다.

결과 타입은 함수 인수 값이 바이너리 문자열로 평가되는지 숫자로 평가되는지에 따라 달라집니다:

인수 값이 바이너리 문자열 타입이고, 인수가 16진 리터럴, 비트 리터럴, 또는 NULL 리터럴이 아니면 바이너리 문자열 평가가 발생합니다. 그 외의 경우에는 숫자 평가가 수행되며, 필요 시 인수 값은 부호 없는 64비트 정수로 변환됩니다.
바이너리 문자열 평가는 인수 값과 동일한 길이의 바이너리 문자열을 생성합니다. 인수 값의 길이가 서로 다르면 ER_INVALID_BITWISE_OPERANDS_SIZE 오류가 발생합니다. 인수 크기가 511바이트를 초과하면 ER_INVALID_BITWISE_AGGREGATE_OPERANDS_SIZE 오류가 발생합니다. 숫자 평가는 부호 없는 64비트 정수를 생성합니다.

일치하는 행이 없으면, BIT_OR()는 인수 값과 동일한 길이를 가지는 중립값(모든 비트가 0으로 설정된 값)을 반환합니다.

NULL 값은 모든 값이 NULL인 경우를 제외하고 결과에 영향을 미치지 않습니다. 이 경우 결과는 인수 값과 동일한 길이를 가지는 중립값입니다.

인수 평가와 결과 타입에 대한 보다 자세한 논의는 Section 14.12, “Bit Functions and Operators”의 도입부 논의를 참조하십시오.

BIT_OR()가 mysql 클라이언트 내에서 호출되면, 바이너리 문자열 결과는 --binary-as-hex 값에 따라 16진수 표기법으로 표시됩니다. 이 옵션에 대한 자세한 내용은 Section 6.5.1, “mysql — The MySQL Command-Line Client”를 참조하십시오.

BIT_XOR(expr) [over_clause]

expr 의 모든 비트에 대한 비트 단위 XOR를 반환합니다.

결과 타입은 함수 인수 값이 바이너리 문자열로 평가되는지 숫자로 평가되는지에 따라 달라집니다:

인수 값이 바이너리 문자열 타입이고, 인수가 16진 리터럴, 비트 리터럴, 또는 NULL 리터럴이 아니면 바이너리 문자열 평가가 발생합니다. 그 외의 경우에는 숫자 평가가 수행되며, 필요 시 인수 값은 부호 없는 64비트 정수로 변환됩니다.
바이너리 문자열 평가는 인수 값과 동일한 길이의 바이너리 문자열을 생성합니다. 인수 값의 길이가 서로 다르면 ER_INVALID_BITWISE_OPERANDS_SIZE 오류가 발생합니다. 인수 크기가 511바이트를 초과하면 ER_INVALID_BITWISE_AGGREGATE_OPERANDS_SIZE 오류가 발생합니다. 숫자 평가는 부호 없는 64비트 정수를 생성합니다.

일치하는 행이 없으면, BIT_XOR()는 인수 값과 동일한 길이를 가지는 중립값(모든 비트가 0으로 설정된 값)을 반환합니다.

NULL 값은 모든 값이 NULL인 경우를 제외하고 결과에 영향을 미치지 않습니다. 이 경우 결과는 인수 값과 동일한 길이를 가지는 중립값입니다.

인수 평가와 결과 타입에 대한 보다 자세한 논의는 Section 14.12, “Bit Functions and Operators”의 도입부 논의를 참조하십시오.

BIT_XOR()가 mysql 클라이언트 내에서 호출되면, 바이너리 문자열 결과는 --binary-as-hex 값에 따라 16진수 표기법으로 표시됩니다. 이 옵션에 대한 자세한 내용은 Section 6.5.1, “mysql — The MySQL Command-Line Client”를 참조하십시오.

COUNT(expr) [over_clause]

SELECT 문에 의해 검색된 행들 중, expr 의 non-NULL 값 개수를 카운트하여 반환합니다. 결과는 BIGINT 값입니다.

일치하는 행이 없으면 COUNT()는 0을 반환합니다. COUNT(NULL)은 0을 반환합니다.

1mysql> SELECT student.student_name,COUNT(*)
2         FROM student,course
3         WHERE student.student_id=course.student_id
4         GROUP BY student_name;

COUNT(*)는 약간 다르게, 행이 NULL 값을 포함하는지 여부와 관계없이 검색된 행 수를 카운트하여 반환합니다.

InnoDB와 같은 트랜잭션 스토리지 엔진의 경우, 정확한 행 수를 저장하는 것은 문제가 있습니다. 동시에 여러 트랜잭션이 발생할 수 있으며, 각각이 카운트에 영향을 미칠 수 있습니다.

InnoDB는 테이블의 행 수에 대한 내부 카운트를 유지하지 않습니다. 이는 동시에 수행되는 트랜잭션들이 서로 다른 행 수를 “볼” 수 있기 때문입니다. 따라서 SELECT COUNT(*) 문은 현재 트랜잭션에서 볼 수 있는 행만 카운트합니다.

SELECT COUNT(*) FROM tbl_name 쿼리의 성능은, WHERE나 GROUP BY 같은 추가 절이 없고, 싱글 스레드 워크로드인 경우 InnoDB 테이블에 대해 최적화됩니다.

InnoDB는 가능한 가장 작은 보조 인덱스를 탐색하여 SELECT COUNT(*) 문을 처리합니다. 단, 인덱스나 옵티마이저 힌트가 옵티마이저에게 다른 인덱스를 사용하도록 지시하는 경우는 예외입니다. 보조 인덱스가 없으면, InnoDB는 클러스터형 인덱스를 스캔하여 SELECT COUNT(*) 문을 처리합니다.

인덱스 레코드가 버퍼 풀에 완전히 들어 있지 않으면 SELECT COUNT(*) 문을 처리하는 데 시간이 걸립니다. 더 빠르게 카운트를 얻으려면, 카운터 테이블을 생성하고 애플리케이션이 수행하는 insert 및 delete에 따라 이를 갱신하도록 하십시오. 하지만 이 방법은 수천 개의 동시 트랜잭션이 동일한 카운터 테이블에 대한 update를 시작하는 상황에서는 잘 확장되지 않을 수 있습니다. 대략적인 행 수로 충분하다면 SHOW TABLE STATUS를 사용하십시오.

InnoDB는 SELECT COUNT(*)와 SELECT COUNT(1) 연산을 동일한 방식으로 처리합니다. 성능 차이는 없습니다.

MyISAM 테이블의 경우, COUNT(*)는 SELECT가 하나의 테이블에서만 검색을 수행하고, 다른 컬럼을 검색하지 않으며, WHERE 절이 없으면 매우 빠르게 결과를 반환하도록 최적화되어 있습니다. 예:

1mysql> SELECT COUNT(*) FROM student;

이 최적화는 정확한 행 수가 저장되어 있고 매우 빠르게 접근할 수 있는 스토리지 엔진이 MyISAM 이기 때문에 MyISAM 테이블에만 적용됩니다. 첫 번째 컬럼이 NOT NULL로 정의된 경우에만 COUNT(1)이 같은 최적화의 대상이 됩니다.

COUNT(DISTINCT expr,[expr...])

서로 다른 non-NULL expr 값들을 가진 행의 개수를 반환합니다.

일치하는 행이 없으면 COUNT(DISTINCT)는 0을 반환합니다.

1mysql> SELECT COUNT(DISTINCT results) FROM student;

MySQL에서는 식 목록을 제공함으로써 NULL을 포함하지 않는 distinct 식 조합의 개수를 얻을 수 있습니다. 표준 SQL에서는 COUNT(DISTINCT ...) 내부에서 모든 식을 연결해야 합니다.

GROUP_CONCAT(expr)

이 함수는 그룹의 non-NULL 값들을 연결한 문자열 결과를 반환합니다. non-NULL 값이 없으면 NULL을 반환합니다. 전체 구문은 다음과 같습니다:

1GROUP_CONCAT([DISTINCT] expr [,expr ...]
2               [ORDER BY {unsigned_integer | col_name | expr}
3                   [ASC | DESC] [,col_name ...]]
4               [SEPARATOR str_val])

1mysql> SELECT student_name,
2           GROUP_CONCAT(test_score)
3         FROM student
4         GROUP BY student_name;

또는:

1mysql> SELECT student_name,
2           GROUP_CONCAT(DISTINCT test_score
3                        ORDER BY test_score DESC SEPARATOR ' ')
4         FROM student
5         GROUP BY student_name;

MySQL에서는 식 조합의 연결된 값을 얻을 수 있습니다. 중복 값을 제거하려면 DISTINCT 절을 사용하십시오. 결과의 값을 정렬하려면 ORDER BY 절을 사용하십시오. 역순으로 정렬하려면, 정렬할 컬럼 이름에 DESC (내림차순) 키워드를 ORDER BY 절에 추가하십시오. 기본값은 오름차순이며, ASC 키워드를 사용하여 명시적으로 지정할 수 있습니다. 그룹 내 값 사이의 기본 구분 기호는 쉼표 (,)입니다. 구분 기호를 명시적으로 지정하려면, SEPARATOR 뒤에 그룹 값 사이에 삽입할 문자열 리터럴 값을 지정하십시오. 구분 기호를 완전히 제거하려면 SEPARATOR ''를 지정하십시오.

결과는 기본값이 1024인 시스템 변수 group_concat_max_len에 의해 주어지는 최대 길이까지 잘립니다. 이 값은 더 크게 설정할 수 있지만, 반환 값의 실질적인 최대 길이는 max_allowed_packet 값에 의해 제한됩니다. 런타임에서 group_concat_max_len 값을 변경하는 구문은 다음과 같으며, 여기서 val 은 부호 없는 정수입니다:

1SET [GLOBAL | SESSION] group_concat_max_len = val;

반환 값은 인수가 nonbinary 문자열인지 바이너리 문자열인지에 따라 nonbinary 또는 바이너리 문자열입니다. 결과 타입은 group_concat_max_len이 512 이하인 경우 VARCHAR 또는 VARBINARY이고, 그렇지 않으면 TEXT 또는 BLOB입니다.

GROUP_CONCAT()가 mysql 클라이언트 내에서 호출되면, 바이너리 문자열 결과는 --binary-as-hex 값에 따라 16진수 표기법으로 표시됩니다. 이 옵션에 대한 자세한 내용은 Section 6.5.1, “mysql — The MySQL Command-Line Client”를 참조하십시오.

CONCAT() 및 CONCAT_WS()도 참조하십시오: Section 14.8, “String Functions and Operators”.

JSON_ARRAYAGG(col_or_expr) [over_clause]

행들로 구성된 단일 JSON 배열로 결과 집합을 집계합니다. 이 배열 내 요소의 순서는 정의되어 있지 않습니다. 이 함수는 단일 값으로 평가되는 컬럼 또는 식에 대해 동작합니다. 결과에 행이 없거나 오류가 발생하면 NULL을 반환합니다. col_or_expr 이 NULL이면, 이 함수는 JSON [null] 요소들로 이루어진 배열을 반환합니다.

1mysql> SELECT o_id, attribute, value FROM t3;
2+------+-----------+-------+
3| o_id | attribute | value |
4+------+-----------+-------+
5|    2 | color     | red   |
6|    2 | fabric    | silk  |
7|    3 | color     | green |
8|    3 | shape     | square|
9+------+-----------+-------+
104 rows in set (0.00 sec)
11
12mysql> SELECT o_id, JSON_ARRAYAGG(attribute) AS attributes
13      -> FROM t3 GROUP BY o_id;
14+------+---------------------+
15| o_id | attributes          |
16+------+---------------------+
17|    2 | ["color", "fabric"] |
18|    3 | ["color", "shape"]  |
19+------+---------------------+
202 rows in set (0.00 sec)

JSON_OBJECTAGG(key, value) [over_clause]

두 개의 컬럼 이름 또는 식을 인수로 받는데, 첫 번째는 key로, 두 번째는 value로 사용되며, key-value 쌍을 포함하는 JSON 객체를 반환합니다. 결과에 행이 없거나 오류가 발생하면 NULL을 반환합니다. key 이름이 NULL이거나 인수 개수가 2가 아닌 경우 오류가 발생합니다.

1mysql> SELECT o_id, attribute, value FROM t3;
2+------+-----------+-------+
3| o_id | attribute | value |
4+------+-----------+-------+
5|    2 | color     | red   |
6|    2 | fabric    | silk  |
7|    3 | color     | green |
8|    3 | shape     | square|
9+------+-----------+-------+
104 rows in set (0.00 sec)
11
12mysql> SELECT o_id, JSON_OBJECTAGG(attribute, value)
13      -> FROM t3 GROUP BY o_id;
14+------+---------------------------------------+
15| o_id | JSON_OBJECTAGG(attribute, value)      |
16+------+---------------------------------------+
17|    2 | {"color": "red", "fabric": "silk"}    |
18|    3 | {"color": "green", "shape": "square"} |
19+------+---------------------------------------+
202 rows in set (0.00 sec)

Duplicate key handling.

이 함수의 결과가 정규화될 때, 중복 key를 가진 value는 버려집니다. 중복 key를 허용하지 않는 MySQL JSON 데이터 타입 사양에 따라, 반환된 객체에서 해당 key에 대해 마지막으로 발견된 value만 사용됩니다 (“last duplicate key wins”). 이는 SELECT에서 가져온 컬럼에 대해 이 함수를 사용할 때, 행이 반환되는 순서(보장되지 않음)에 따라 결과가 달라질 수 있음을 의미합니다.

윈도 함수로 사용할 때, 프레임 안에 중복 key가 있으면 해당 key에 대해 결과에는 마지막 value만 남습니다. ORDER BY 지정이 value에 특정 순서를 보장하는 경우, 프레임 내 마지막 행의 key value는 결정적입니다. 그렇지 않으면, key의 결과 value는 비결정적입니다.

다음 예를 고려하십시오:

1mysql> CREATE TABLE t(c VARCHAR(10), i INT);
2Query OK, 0 rows affected (0.33 sec)
3
4mysql> INSERT INTO t VALUES ('key', 3), ('key', 4), ('key', 5);
5Query OK, 3 rows affected (0.10 sec)
6Records: 3  Duplicates: 0  Warnings: 0
7
8mysql> SELECT c, i FROM t;
9+------+------+
10| c    | i    |
11+------+------+
12| key  |    3 |
13| key  |    4 |
14| key  |    5 |
15+------+------+
163 rows in set (0.00 sec)
17
18mysql> SELECT JSON_OBJECTAGG(c, i) FROM t;
19+----------------------+
20| JSON_OBJECTAGG(c, i) |
21+----------------------+
22| {"key": 5}           |
23+----------------------+
241 row in set (0.00 sec)
25
26mysql> DELETE FROM t;
27Query OK, 3 rows affected (0.08 sec)
28
29mysql> INSERT INTO t VALUES ('key', 3), ('key', 5), ('key', 4);
30Query OK, 3 rows affected (0.06 sec)
31Records: 3  Duplicates: 0  Warnings: 0
32
33mysql> SELECT c, i FROM t;
34+------+------+
35| c    | i    |
36+------+------+
37| key  |    3 |
38| key  |    5 |
39| key  |    4 |
40+------+------+
413 rows in set (0.00 sec)
42
43mysql> SELECT JSON_OBJECTAGG(c, i) FROM t;
44+----------------------+
45| JSON_OBJECTAGG(c, i) |
46+----------------------+
47| {"key": 4}           |
48+----------------------+
491 row in set (0.00 sec)

마지막 쿼리에서 선택된 key는 비결정적입니다. 쿼리가 GROUP BY를 사용하지 않고 (대개 GROUP BY는 나름의 정렬을 강제함), 특정 key 정렬을 선호하는 경우, ORDER BY가 포함된 OVER 절을 지정하여 프레임 행에 특정 순서를 부여하는 방식으로 JSON_OBJECTAGG()를 윈도 함수로 호출할 수 있습니다. 다음 예제는 몇 가지 다른 프레임 지정에서 ORDER BY가 있을 때와 없을 때의 동작을 보여 줍니다.

ORDER BY 없이, 프레임은 전체 파티션입니다:

1mysql> SELECT JSON_OBJECTAGG(c, i)
2         OVER () AS json_object FROM t;
3+-------------+
4| json_object |
5+-------------+
6| {"key": 4}  |
7| {"key": 4}  |
8| {"key": 4}  |
9+-------------+

ORDER BY가 있고, 프레임이 기본값인 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW인 경우 (오름차순과 내림차순 모두):

1mysql> SELECT JSON_OBJECTAGG(c, i)
2         OVER (ORDER BY i) AS json_object FROM t;
3+-------------+
4| json_object |
5+-------------+
6| {"key": 3}  |
7| {"key": 4}  |
8| {"key": 5}  |
9+-------------+
10mysql> SELECT JSON_OBJECTAGG(c, i)
11         OVER (ORDER BY i DESC) AS json_object FROM t;
12+-------------+
13| json_object |
14+-------------+
15| {"key": 5}  |
16| {"key": 4}  |
17| {"key": 3}  |
18+-------------+

ORDER BY와 전체 파티션에 대한 명시적인 프레임을 사용하는 경우:

1mysql> SELECT JSON_OBJECTAGG(c, i)
2         OVER (ORDER BY i
3              ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING)
4          AS json_object
5         FROM t;
6+-------------+
7| json_object |
8+-------------+
9| {"key": 5}  |
10| {"key": 5}  |
11| {"key": 5}  |
12+-------------+

특정 key value(예: 최솟값 또는 최댓값)를 반환하려면, 적절한 쿼리에 LIMIT 절을 포함하십시오. 예를 들어:

1mysql> SELECT JSON_OBJECTAGG(c, i)
2         OVER (ORDER BY i) AS json_object FROM t LIMIT 1;
3+-------------+
4| json_object |
5+-------------+
6| {"key": 3}  |
7+-------------+
8mysql> SELECT JSON_OBJECTAGG(c, i)
9         OVER (ORDER BY i DESC) AS json_object FROM t LIMIT 1;
10+-------------+
11| json_object |
12+-------------+
13| {"key": 5}  |
14+-------------+

추가 정보와 예시는 Normalization, Merging, and Autowrapping of JSON Values를 참조하십시오.

MAX([DISTINCT] expr) [over_clause]

expr 의 최대 값을 반환합니다. MAX()는 문자열 인수를 받을 수 있으며, 이 경우 최대 문자열 값을 반환합니다. Section 10.3.1, “How MySQL Uses Indexes”를 참조하십시오. DISTINCT 키워드는 expr 의 distinct 값들 중 최대 값을 찾는 데 사용할 수 있지만, DISTINCT를 생략한 것과 동일한 결과를 생성합니다.

일치하는 행이 없거나 expr 이 NULL이면, MAX()는 NULL을 반환합니다.

1mysql> SELECT student_name, MIN(test_score), MAX(test_score)
2         FROM student
3         GROUP BY student_name;

MAX()의 경우, 현재 MySQL은 ENUM 및 SET 컬럼을 집합 내의 상대적 위치가 아니라 문자열 값으로 비교합니다. 이는 ORDER BY가 이들을 비교하는 방식과 다릅니다.

MIN([DISTINCT] expr) [over_clause]

expr 의 최소 값을 반환합니다. MIN()는 문자열 인수를 받을 수 있으며, 이 경우 최소 문자열 값을 반환합니다. Section 10.3.1, “How MySQL Uses Indexes”를 참조하십시오. DISTINCT 키워드는 expr 의 distinct 값들 중 최소 값을 찾는 데 사용할 수 있지만, DISTINCT를 생략한 것과 동일한 결과를 생성합니다.

일치하는 행이 없거나 expr 이 NULL이면, MIN()는 NULL을 반환합니다.

1mysql> SELECT student_name, MIN(test_score), MAX(test_score)
2         FROM student
3         GROUP BY student_name;

MIN()의 경우, 현재 MySQL은 ENUM 및 SET 컬럼을 집합 내의 상대적 위치가 아니라 문자열 값으로 비교합니다. 이는 ORDER BY가 이들을 비교하는 방식과 다릅니다.

STD(expr) [over_clause]

expr 의 모집단 표준편차를 반환합니다. STD()는 표준 SQL 함수 STDDEV_POP()에 대한 MySQL 확장 동의어(synonym)입니다.

일치하는 행이 없거나 expr 이 NULL이면, STD()는 NULL을 반환합니다.

STDDEV(expr) [over_clause]

expr 의 모집단 표준편차를 반환합니다. STDDEV()는 Oracle과의 호환성을 위해 제공되는 표준 SQL 함수 STDDEV_POP()의 동의어입니다.

일치하는 행이 없거나 expr 이 NULL이면, STDDEV()는 NULL을 반환합니다.

STDDEV_POP(expr) [over_clause]

expr 의 모집단 표준편차( VAR_POP()의 제곱근)를 반환합니다. STD() 또는 STDDEV()도 사용할 수 있으며, 이들은 동일하지만 표준 SQL이 아닙니다.

일치하는 행이 없거나 expr 이 NULL이면, STDDEV_POP()는 NULL을 반환합니다.

STDDEV_SAMP(expr) [over_clause]

expr 의 표본 표준편차( VAR_SAMP()의 제곱근)를 반환합니다.

일치하는 행이 없거나 expr 이 NULL이면, STDDEV_SAMP()는 NULL을 반환합니다.

SUM([DISTINCT] expr) [over_clause]

expr 의 합계를 반환합니다. 반환 집합에 행이 없으면 SUM()은 NULL을 반환합니다. DISTINCT 키워드를 사용하면 expr 의 distinct 값만 합산할 수 있습니다.

일치하는 행이 없거나 expr 이 NULL이면, SUM()은 NULL을 반환합니다.

VAR_POP(expr) [over_clause]

expr 의 모집단 분산을 반환합니다. 이 함수는 행들을 표본이 아닌 전체 모집단으로 간주하므로 분모로 행 수를 사용합니다. VARIANCE()도 사용할 수 있으며, 이 함수와 동일하지만 표준 SQL은 아닙니다.

일치하는 행이 없거나 expr 이 NULL이면, VAR_POP()는 NULL을 반환합니다.

VAR_SAMP(expr) [over_clause]

expr 의 표본 분산을 반환합니다. 즉, 분모는 행 수에서 1을 뺀 값입니다.

일치하는 행이 없거나 expr 이 NULL이면, VAR_SAMP()는 NULL을 반환합니다.

VARIANCE(expr) [over_clause]

expr 의 모집단 분산을 반환합니다. VARIANCE()는 표준 SQL 함수 VAR_POP()에 대한 MySQL 확장 동의어입니다.

일치하는 행이 없거나 expr 이 NULL이면, VARIANCE()는 NULL을 반환합니다.