14.24 Miscellaneous Functions

14.24 Miscellaneous Functions

Table 14.34 Miscellaneous Functions

Name	Description
ANY_VALUE()	ONLY_FULL_GROUP_BY 값 거부를 억제
BIN_TO_UUID()	바이너리 UUID를 문자열로 변환
DEFAULT()	테이블 컬럼의 기본값을 반환
ETAG()	하나 이상의 컬럼 또는 기타 값들을 사용하여 각 행에 대한 해시 계산
GROUPING()	슈퍼 집계 ROLLUP 행과 일반 행을 구분
INET_ATON()	IP 주소의 숫자 값을 반환
INET_NTOA()	숫자 값으로부터 IP 주소를 반환
IS_UUID()	인자가 유효한 UUID인지 여부
NAME_CONST()	컬럼이 지정된 이름을 갖도록 함
SLEEP()	지정된 초 동안 슬립
UUID()	Universal Unique Identifier (UUID)를 반환
UUID_SHORT()	정수 값을 갖는 universal identifier 반환
UUID_TO_BIN()	문자열 UUID를 바이너리로 변환
VALUES()	INSERT 동안 사용될 값을 정의

Name	Description

• ANY_VALUE(arg)

이 함수는 ONLY_FULL_GROUP_BY SQL 모드가 활성화된 상태에서 GROUP BY 쿼리에 유용합니다. 이 모드 때문에 MySQL이 거부하지만 실제로는 유효하다는 것을 사용자가 아는 쿼리에 대해, MySQL이 그 유효성을 판단할 수 없을 때 사용합니다. 함수의 반환 값과 타입은 인자의 반환 값과 타입과 동일하지만, 함수 결과는 ONLY_FULL_GROUP_BY SQL 모드에 대해 검사되지 않습니다.

예를 들어, name이 인덱스가 없는 컬럼이면, 다음 쿼리는 ONLY_FULL_GROUP_BY가 활성화된 상태에서 실패합니다:

1mysql> SELECT name, address, MAX(age) FROM t GROUP BY name;
2ERROR 1055 (42000): Expression #2 of SELECT list is not in GROUP
3BY clause and contains nonaggregated column 'mydb.t.address' which
4is not functionally dependent on columns in GROUP BY clause; this
5is incompatible with sql_mode=only_full_group_by

실패 원인은 address가 비집계(nonaggregated) 컬럼인데 GROUP BY 컬럼에 포함되어 있지 않고, 그 컬럼들에 함수적으로 종속(functionally dependent)하지도 않기 때문입니다. 그 결과, 각 name 그룹 내에서 address 값은 비결정적입니다. MySQL이 쿼리를 허용하게 만드는 방법은 여러 가지가 있습니다:

• name을 프라이머리 키 또는 유니크 NOT NULL 컬럼이 되도록 테이블을 변경합니다. 이렇게 하면 MySQL은 address가 name에 함수적으로 종속한다고 판단할 수 있습니다. 즉, address는 name에 의해 유일하게 결정됩니다. (NULL이 유효한 name 값으로 허용되어야 한다면 이 기법은 적용할 수 없습니다.)

• address를 참조하는 데 ANY_VALUE()를 사용합니다:

1SELECT name, ANY_VALUE(address), MAX(age) FROM t GROUP BY name;

이 경우, MySQL은 각 name 그룹 내에서 address 값의 비결정성을 무시하고 쿼리를 허용합니다. 비집계 컬럼에 대해 그룹마다 어떤 값이 선택되는지 신경 쓰지 않을 때 유용할 수 있습니다. ANY_VALUE()는 SUM()이나 COUNT()와 같은 함수와 달리 집계 함수가 아닙니다. 단지 비결정성 검사를 억제하는 역할만 합니다.

• ONLY_FULL_GROUP_BY를 비활성화합니다. 이는 앞 항목에서 설명한 것처럼 ONLY_FULL_GROUP_BY가 활성화된 상태에서 ANY_VALUE()를 사용하는 것과 동일합니다.

ANY_VALUE()는 컬럼들 간에 함수적 종속성이 존재하지만 MySQL이 이를 판단할 수 없을 때도 유용합니다. 다음 쿼리는 age가 그룹화 컬럼 age-1에 함수적으로 종속이므로 유효하지만, MySQL은 이를 알 수 없고 ONLY_FULL_GROUP_BY가 활성화된 상태에서 쿼리를 거부합니다:

1SELECT age FROM t GROUP BY age-1;

MySQL이 쿼리를 허용하게 하려면 ANY_VALUE()를 사용합니다:

1SELECT ANY_VALUE(age) FROM t GROUP BY age-1;

ANY_VALUE()는 GROUP BY 절이 없는 상태에서 집계 함수를 참조하는 쿼리에도 사용할 수 있습니다:

1mysql> SELECT name, MAX(age) FROM t;
2ERROR 1140 (42000): In aggregated query without GROUP BY, expression
3#1 of SELECT list contains nonaggregated column 'mydb.t.name'; this
4is incompatible with sql_mode=only_full_group_by

GROUP BY가 없으면 그룹은 하나뿐이고, 그 그룹에 대해 어떤 name 값을 선택할지 비결정적입니다. ANY_VALUE()는 MySQL에 쿼리를 허용하라고 지시합니다:

1SELECT ANY_VALUE(name), MAX(age) FROM t;

특정 데이터 세트의 어떤 특성 때문에, 선택된 비집계 컬럼이 사실상 GROUP BY 컬럼에 함수적으로 종속임을 알고 있을 수도 있습니다. 예를 들어, 애플리케이션이 한 컬럼에 대해 다른 컬럼을 기준으로 유일성을 보장할 수 있습니다. 이 경우, 사실상 함수적으로 종속인 컬럼에 대해 ANY_VALUE()를 사용하는 것이 의미가 있을 수 있습니다.

추가 논의는 Section 14.19.3, “MySQL Handling of GROUP BY”를 참조하십시오.

• BIN_TO_UUID(binary_uuid), BIN_TO_UUID(binary_uuid, swap_flag)

BIN_TO_UUID()는 UUID_TO_BIN()의 역함수입니다. 바이너리 UUID를 문자열 UUID로 변환하여 결과를 반환합니다. 바이너리 값은 VARBINARY(16) 값으로 표현된 UUID여야 합니다. 반환 값은 대시로 구분된 5개의 16진수 숫자로 구성된 문자열입니다. (이 포맷에 대한 세부 사항은 UUID() 함수 설명을 참조하십시오.) UUID 인자가 NULL이면 반환 값은 NULL입니다. 인자 중 하나라도 유효하지 않으면 에러가 발생합니다.

BIN_TO_UUID()는 하나 또는 두 개의 인자를 받습니다:

• 인자 하나짜리 형식은 바이너리 UUID 값을 받습니다. UUID 값은 time-low와 time-high 부분이 스왑되지 않은 것으로 가정합니다. 문자열 결과는 바이너리 인자와 동일한 순서를 갖습니다.

• 인자 두 개짜리 형식은 바이너리 UUID 값과 스왑 플래그(swap-flag) 값을 받습니다:

  • _swap_flag_가 0이면, 인자 두 개짜리 형식은 인자 하나짜리 형식과 동일합니다. 문자열 결과는 바이너리 인자와 동일한 순서를 갖습니다.
  • _swap_flag_가 1이면, UUID 값은 time-low와 time-high 부분이 스왑된 것으로 가정합니다. 이 부분들은 결과 값에서 원래 위치로 다시 스왑됩니다.

사용 예 및 time-part 스와핑에 대한 정보는 UUID_TO_BIN() 함수 설명을 참조하십시오.

• DEFAULT(col_name)

테이블 컬럼의 기본값을 반환합니다. 컬럼에 기본값이 없으면 에러가 발생합니다.

DEFAULT(col_name)를 사용하여 지정된 컬럼의 기본값을 명시하는 것은, 표현식 기본값이 있는 컬럼이 아니라 리터럴 기본값이 있는 컬럼에만 허용됩니다.

1mysql> UPDATE t SET i = DEFAULT(i)+1 WHERE id < 100;

• ETAG(col [, col[, ...]])

콤마로 구분된 하나 이상의 컬럼 값 목록을 기반으로 각 행에 대해 128비트 해시를 계산합니다. 이 목록의 항목은 컬럼 이름, 상수 값 또는 표현식일 수 있으며, NULL일 수도 있습니다.

VECTOR 및 GEOMETRY 컬럼은 이 함수에서 지원되지 않습니다. 이들 타입 중 하나의 컬럼을 참조하려고 하면 에러가 발생합니다.

인자 목록 내 항목들의 순서는 함수의 반환 값에 영향을 주지 않습니다.

자세한 내용은 Section 27.7, “JSON Duality Views”를 참조하십시오.

• FORMAT(X,D)

숫자 _X_를 '#,###,###.##'와 같은 형식으로, 소수점 이하 D 자리까지 반올림하여 포맷하고, 결과를 문자열로 반환합니다. 자세한 내용은 Section 14.8, “String Functions and Operators”를 참조하십시오.

• GROUPING(expr [, expr] ...)

WITH ROLLUP 수정자가 포함된 GROUP BY 쿼리의 경우, ROLLUP 연산은 NULL이 모든 값 집합을 나타내는 슈퍼 집계 출력 행을 생성합니다. GROUPING() 함수는 슈퍼 집계 행의 NULL 값과 일반 그룹화된 행의 NULL 값을 구분할 수 있게 해줍니다.

GROUPING()는 select 리스트, HAVING 절, ORDER BY 절에서 사용할 수 있습니다.

GROUPING()의 각 인자는 GROUP BY 절의 표현식과 정확히 일치하는 표현식이어야 합니다. 표현식은 위치 지정자(positional specifier)가 될 수 없습니다. 각 표현식에 대해, GROUPING()는 현재 행에서 해당 표현식 값이 슈퍼 집계 값을 나타내는 NULL이면 1을 반환합니다. 그렇지 않으면, 즉 표현식 값이 일반 결과 행의 NULL이거나 NULL이 아니면 0을 반환합니다.

테이블 t1에 다음과 같은 행이 있고, 여기에서 NULL은 “other” 또는 “unknown”과 같은 것을 나타낸다고 가정합니다:

1mysql> SELECT * FROM t1;
2+------+-------+----------+
3| name | size  | quantity |
4+------+-------+----------+
5| ball | small |       10 |
6| ball | large |       20 |
7| ball | NULL  |        5 |
8| hoop | small |       15 |
9| hoop | large |        5 |
10| hoop | NULL  |        3 |
11+------+-------+----------+

WITH ROLLUP 없이 테이블을 요약하면 다음과 같습니다:

1mysql> SELECT name, size, SUM(quantity) AS quantity
2         FROM t1
3         GROUP BY name, size;
4+------+-------+----------+
5| name | size  | quantity |
6+------+-------+----------+
7| ball | small |       10 |
8| ball | large |       20 |
9| ball | NULL  |        5 |
10| hoop | small |       15 |
11| hoop | large |        5 |
12| hoop | NULL  |        3 |
13+------+-------+----------+

결과에는 NULL 값이 포함되어 있지만, 쿼리에 WITH ROLLUP이 포함되어 있지 않으므로 이는 슈퍼 집계 행을 나타내지 않습니다.

WITH ROLLUP을 추가하면 슈퍼 집계 요약 행이 생성되며, 추가적인 NULL 값이 포함됩니다. 그러나 이 결과를 이전 결과와 비교하지 않으면, 어떤 NULL 값이 슈퍼 집계 행에 있고 어떤 값이 일반 그룹화된 행에 있는지 쉽게 파악하기 어렵습니다:

1mysql> SELECT name, size, SUM(quantity) AS quantity
2         FROM t1
3         GROUP BY name, size WITH ROLLUP;
4+------+-------+----------+
5| name | size  | quantity |
6+------+-------+----------+
7| ball | NULL  |        5 |
8| ball | large |       20 |
9| ball | small |       10 |
10| ball | NULL  |       35 |
11| hoop | NULL  |        3 |
12| hoop | large |        5 |
13| hoop | small |       15 |
14| hoop | NULL  |       23 |
15| NULL | NULL  |       58 |
16+------+-------+----------+

슈퍼 집계 행의 NULL 값과 일반 그룹화된 행의 NULL 값을 구분하려면, 슈퍼 집계 NULL 값에 대해서만 1을 반환하는 GROUPING()를 사용합니다:

1mysql> SELECT
2           name, size, SUM(quantity) AS quantity,
3           GROUPING(name) AS grp_name,
4           GROUPING(size) AS grp_size
5         FROM t1
6         GROUP BY name, size WITH ROLLUP;
7+------+-------+----------+----------+----------+
8| name | size  | quantity | grp_name | grp_size |
9+------+-------+----------+----------+----------+
10| ball | NULL  |        5 |        0 |        0 |
11| ball | large |       20 |        0 |        0 |
12| ball | small |       10 |        0 |        0 |
13| ball | NULL  |       35 |        0 |        1 |
14| hoop | NULL  |        3 |        0 |        0 |
15| hoop | large |        5 |        0 |        0 |
16| hoop | small |       15 |        0 |        0 |
17| hoop | NULL  |       23 |        0 |        1 |
18| NULL | NULL  |       58 |        1 |        1 |
19+------+-------+----------+----------+----------+

GROUPING()의 일반적인 사용 예는 다음과 같습니다:

• 슈퍼 집계 NULL 값에 라벨을 대체:

1mysql> SELECT
2         IF(GROUPING(name) = 1, 'All items', name) AS name,
3         IF(GROUPING(size) = 1, 'All sizes', size) AS size,
4         SUM(quantity) AS quantity
5       FROM t1
6       GROUP BY name, size WITH ROLLUP;
7+-----------+-----------+----------+
8| name      | size      | quantity |
9+-----------+-----------+----------+
10| ball      | NULL      |        5 |
11| ball      | large     |       20 |
12| ball      | small     |       10 |
13| ball      | All sizes |       35 |
14| hoop      | NULL      |        3 |
15| hoop      | large     |        5 |
16| hoop      | small     |       15 |
17| hoop      | All sizes |       23 |
18| All items | All sizes |       58 |
19+-----------+-----------+----------+

• 일반 그룹화 행을 필터링하여 슈퍼 집계 행만 반환:

1mysql> SELECT name, size, SUM(quantity) AS quantity
2       FROM t1
3       GROUP BY name, size WITH ROLLUP
4       HAVING GROUPING(name) = 1 OR GROUPING(size) = 1;
5+------+------+----------+
6| name | size | quantity |
7+------+------+----------+
8| ball | NULL |       35 |
9| hoop | NULL |       23 |
10| NULL | NULL |       58 |
11+------+------+----------+

GROUPING()는 여러 개의 표현식 인자를 허용합니다. 이 경우, GROUPING() 반환 값은 각 표현식에 대한 결과를 결합한 비트마스크를 나타내며, 최하위 비트는 가장 오른쪽 표현식의 결과에 해당합니다. 예를 들어, 세 개의 표현식 인자에 대해 GROUPING(expr1, expr2, expr3)는 다음과 같이 계산됩니다:

1  result for GROUPING(expr3)
2+ result for GROUPING(expr2) << 1
3+ result for GROUPING(expr1) << 2

다음 쿼리는 여러 인자를 사용하는 호출에서 비트마스크 값을 생성하기 위해 단일 인자에 대한 GROUPING() 결과가 어떻게 결합되는지를 보여 줍니다:

1mysql> SELECT
2         name, size, SUM(quantity) AS quantity,
3         GROUPING(name) AS grp_name,
4         GROUPING(size) AS grp_size,
5       GROUPING(name, size) AS grp_all
6       FROM t1
7       GROUP BY name, size WITH ROLLUP;
8+------+-------+----------+----------+----------+---------+
9| name | size  | quantity | grp_name | grp_size | grp_all |
10+------+-------+----------+----------+----------+---------+
11| ball | NULL  |        5 |        0 |        0 |       0 |
12| ball | large |       20 |        0 |        0 |       0 |
13| ball | small |       10 |        0 |        0 |       0 |
14| ball | NULL  |       35 |        0 |        1 |       1 |
15| hoop | NULL  |        3 |        0 |        0 |       0 |
16| hoop | large |        5 |        0 |        0 |       0 |
17| hoop | small |       15 |        0 |        0 |       0 |
18| hoop | NULL  |       23 |        0 |        1 |       1 |
19| NULL | NULL  |       58 |        1 |        1 |       3 |
20+------+-------+----------+----------+----------+---------+

여러 표현식 인자가 있는 경우, GROUPING() 반환 값은 어떤 표현식이라도 슈퍼 집계 값을 나타내면 0이 아닌 값을 갖습니다. 따라서 여러 인자를 사용하는 GROUPING() 구문은 여러 개의 단일 인자 호출 대신 하나의 다중 인자 GROUPING() 호출을 사용하여 이전에 슈퍼 집계 행만 반환하던 쿼리를 더 단순하게 작성하는 방법을 제공합니다:

1mysql> SELECT name, size, SUM(quantity) AS quantity
2       FROM t1
3       GROUP BY name, size WITH ROLLUP
4       HAVING GROUPING(name, size) <> 0;
5+------+------+----------+
6| name | size | quantity |
7+------+------+----------+
8| ball | NULL |       35 |
9| hoop | NULL |       23 |
10| NULL | NULL |       58 |
11+------+------+----------+

GROUPING()의 사용에는 다음과 같은 제한 사항이 있습니다:

• GROUPING() 인자로 서브쿼리 GROUP BY 표현식을 사용하지 마십시오. 매칭이 실패할 수 있습니다. 예를 들어, 다음 쿼리에서 매칭이 실패합니다:

1mysql> SELECT GROUPING((SELECT MAX(name) FROM t1))
2       FROM t1
3       GROUP BY (SELECT MAX(name) FROM t1) WITH ROLLUP;
4ERROR 3580 (HY000): Argument #1 of GROUPING function is not in GROUP BY

• GROUP BY 리터럴 표현식은 HAVING 절 내에서 GROUPING() 인자로 사용하지 않아야 합니다. 옵티마이저가 GROUP BY와 HAVING을 평가하는 시점의 차이 때문에, 매칭은 성공할 수 있지만 GROUPING() 평가 결과는 예상과 다를 수 있습니다. 다음 쿼리를 고려해 보십시오:

1SELECT a AS f1, 'w' AS f2
2FROM t
3GROUP BY f1, f2 WITH ROLLUP
4HAVING GROUPING(f2) = 1;

GROUPING()는 리터럴 상수 표현식에 대해 HAVING 절 전체보다 먼저 평가되며 0을 반환합니다. 이와 같은 쿼리가 영향을 받는지 확인하려면, EXPLAIN을 사용하고 Extra 컬럼에서 Impossible having이 있는지 확인하십시오.

WITH ROLLUP 및 GROUPING()에 대한 자세한 내용은 Section 14.19.2, “GROUP BY Modifiers”를 참조하십시오.

• INET_ATON(expr)

IPv4 네트워크 주소의 dotted-quad 표현을 문자열로 받아, 네트워크 바이트 순서(빅 엔디언)의 숫자 값을 나타내는 정수를 반환합니다. INET_ATON()은 인자를 이해하지 못하거나 _expr_가 NULL이면 NULL을 반환합니다.

1mysql> SELECT INET_ATON('10.0.5.9');
2          -> 167773449

이 예제에서 반환 값은 10×2563 + 0×2562 + 5×256 + 9로 계산됩니다.

INET_ATON()은 short-form IP 주소(예: '127.0.0.1'를 나타내는 '127.1')에 대해 non-NULL 결과를 반환할 수도 있고 그렇지 않을 수도 있습니다. 이 때문에, INET_ATON()은 이러한 주소에 사용해서는 안 됩니다.

참고

INET_ATON()에 의해 생성된 값을 저장하려면, signed인 INT가 아니라 INT UNSIGNED 컬럼을 사용하십시오. signed 컬럼을 사용할 경우, 첫 번째 옥텟이 127보다 큰 IP 주소에 해당하는 값을 올바르게 저장할 수 없습니다. Section 13.1.7, “Out-of-Range and Overflow Handling”을 참조하십시오.

• INET_NTOA(expr)

네트워크 바이트 순서의 숫자 IPv4 네트워크 주소를 받아, 연결 캐릭터 세트의 문자열로 dotted-quad 문자열 표현을 반환합니다. INET_NTOA()는 인자를 이해하지 못하면 NULL을 반환합니다.

1mysql> SELECT INET_NTOA(167773449);
2          -> '10.0.5.9'

• INET6_ATON(expr)

IPv6 또는 IPv4 네트워크 주소를 문자열로 받아, 네트워크 바이트 순서(빅 엔디언)의 숫자 값을 나타내는 바이너리 문자열을 반환합니다. 숫자 형식 IPv6 주소는 가장 큰 정수 타입보다 많은 바이트가 필요하기 때문에, 이 함수가 반환하는 표현은 VARBINARY 데이터 타입을 사용합니다: IPv6 주소는 VARBINARY(16), IPv4 주소는 VARBINARY(4)입니다. 인자가 유효한 주소가 아니거나 NULL이면, INET6_ATON()은 NULL을 반환합니다.

다음 예제에서는 HEX()를 사용하여 INET6_ATON() 결과를 출력 가능한 형태로 표시합니다:

1mysql> SELECT HEX(INET6_ATON('fdfe::5a55:caff:fefa:9089'));
2          -> 'FDFE0000000000005A55CAFFFEFA9089'
3mysql> SELECT HEX(INET6_ATON('10.0.5.9'));
4          -> '0A000509'

INET6_ATON()은 유효한 인자에 대해 여러 제약을 따릅니다. 이는 아래 목록과 예제에 나와 있습니다.

• fe80::3%1 또는 fe80::3%eth0와 같은 trailing zone ID는 허용되지 않습니다.

• 2001:45f:3:ba::/64 또는 198.51.100.0/24와 같은 trailing 네트워크 마스크는 허용되지 않습니다.

• IPv4 주소를 나타내는 값의 경우, 클래스리스 주소만 지원됩니다. 198.51.1과 같은 클래스풀 주소는 거부됩니다. 198.51.100.2:8080과 같은 trailing 포트 번호는 허용되지 않습니다. 198.0xa0.1.2와 같이 주소 구성 요소에서 16진수 숫자는 허용되지 않습니다. 8진수 숫자는 지원되지 않습니다. 198.51.010.1은 198.51.10.1로 처리되며, 198.51.8.1로 처리되지 않습니다. 이러한 IPv4 제약은 IPv4-compatible 또는 IPv4-mapped 주소와 같이 IPv4 주소 부분을 갖는 IPv6 주소에도 적용됩니다.

숫자 형식의 INT 값으로 표현된 IPv4 주소 _expr_를, 숫자 형식의 VARBINARY 값으로 표현된 IPv6 주소로 변환하려면 다음 표현식을 사용합니다:

1INET6_ATON(INET_NTOA(expr))

예를 들면:

1mysql> SELECT HEX(INET6_ATON(INET_NTOA(167773449)));
2        -> '0A000509'

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

• INET6_NTOA(expr)

바이너리 문자열으로 숫자 형식의 IPv6 또는 IPv4 네트워크 주소를 받아, 연결 캐릭터 세트의 문자열으로 주소의 문자열 표현을 반환합니다. 인자가 유효한 주소가 아니거나 NULL이면, INET6_NTOA()는 NULL을 반환합니다.

INET6_NTOA()는 다음과 같은 특성을 갖습니다:

• 변환을 수행하는 데 운영체제 함수를 사용하지 않으므로, 출력 문자열은 플랫폼 독립적입니다.

• 반환 문자열의 최대 길이는 39(4 x 8 + 7)입니다. 다음 문장이 있다고 가정해 보십시오:

1CREATE TABLE t AS SELECT INET6_NTOA(expr) AS c1;

생성된 테이블은 다음 정의를 갖습니다:

1CREATE TABLE t (c1 VARCHAR(39) CHARACTER SET utf8mb3 DEFAULT NULL);

• 반환 문자열은 IPv6 주소에 대해 소문자 letter를 사용합니다.

1mysql> SELECT INET6_NTOA(INET6_ATON('fdfe::5a55:caff:fefa:9089'));
2        -> 'fdfe::5a55:caff:fefa:9089'
3mysql> SELECT INET6_NTOA(INET6_ATON('10.0.5.9'));
4        -> '10.0.5.9'
5
6mysql> SELECT INET6_NTOA(UNHEX('FDFE0000000000005A55CAFFFEFA9089'));
7        -> 'fdfe::5a55:caff:fefa:9089'
8mysql> SELECT INET6_NTOA(UNHEX('0A000509'));
9        -> '10.0.5.9'

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

• IS_IPV4(expr)

인자가 문자열로 지정된 유효한 IPv4 주소이면 1을, 그렇지 않으면 0을 반환합니다. _expr_이 NULL이면 NULL을 반환합니다.

1mysql> SELECT IS_IPV4('10.0.5.9'), IS_IPV4('10.0.5.256');
2          -> 1, 0

주어진 인자에 대해, IS_IPV4()가 1을 반환하면 INET_ATON()(및 INET6_ATON())은 non-NULL을 반환합니다. 그 역은 항상 참이 아닙니다. 일부 경우, INET_ATON()은 IS_IPV4()가 0을 반환할 때 non-NULL을 반환합니다.

앞의 설명에서 알 수 있듯이, IS_IPV4()는 유효한 IPv4 주소의 기준에 대해 INET_ATON()보다 더 엄격하므로, 유효하지 않은 값에 대한 강력한 검사가 필요한 애플리케이션에 유용할 수 있습니다. 또는 INET6_ATON()을 사용하여 IPv4 주소를 내부 형식으로 변환하고 NULL 결과를 확인하여(이는 유효하지 않은 주소를 의미합니다) 검사할 수 있습니다. INET6_ATON()은 IPv4 주소를 검사하는 데 있어 IS_IPV4()만큼이나 엄격합니다.

• IS_IPV4_COMPAT(expr)

이 함수는 INET6_ATON()에 의해 반환되는 것처럼 바이너리 문자열으로 숫자 형식의 IPv6 주소를 받습니다. 인자가 유효한 IPv4-compatible IPv6 주소이면 1을, 그렇지 않으면 0을 반환합니다(_expr_이 NULL이면 NULL을 반환합니다). IPv4-compatible 주소는 ::ipv4_address 형식을 갖습니다.

1mysql> SELECT IS_IPV4_COMPAT(INET6_ATON('::10.0.5.9'));
2          -> 1
3mysql> SELECT IS_IPV4_COMPAT(INET6_ATON('::ffff:10.0.5.9'));
4          -> 0

IPv4-compatible 주소의 IPv4 부분은 16진수 표기법으로도 표현할 수 있습니다. 예를 들어, 198.51.100.1의 raw 16진수 값은 다음과 같습니다:

1mysql> SELECT HEX(INET6_ATON('198.51.100.1'));
2          -> 'C6336401'

IPv4-compatible 형식으로 표현하면, ::198.51.100.1은 ::c0a8:0001 또는(선행 0 없이) ::c0a8:1과 동일합니다.

1mysql> SELECT
2      ->   IS_IPV4_COMPAT(INET6_ATON('::198.51.100.1')),
3      ->   IS_IPV4_COMPAT(INET6_ATON('::c0a8:0001')),
4      ->   IS_IPV4_COMPAT(INET6_ATON('::c0a8:1'));
5          -> 1, 1, 1

• IS_IPV4_MAPPED(expr)

이 함수는 INET6_ATON()에 의해 반환되는 것처럼 바이너리 문자열으로 숫자 형식의 IPv6 주소를 받습니다. 인자가 유효한 IPv4-mapped IPv6 주소이면 1을, 그렇지 않으면 0을 반환합니다. 단, _expr_이 NULL이면 NULL을 반환합니다. IPv4-mapped 주소는 ::ffff:ipv4_address 형식을 갖습니다.

1mysql> SELECT IS_IPV4_MAPPED(INET6_ATON('::10.0.5.9'));
2          -> 0
3mysql> SELECT IS_IPV4_MAPPED(INET6_ATON('::ffff:10.0.5.9'));
4          -> 1

IS_IPV4_COMPAT()와 마찬가지로, IPv4-mapped 주소의 IPv4 부분은 16진수 표기법으로도 표현할 수 있습니다:

1mysql> SELECT
2      ->   IS_IPV4_MAPPED(INET6_ATON('::ffff:198.51.100.1')),
3      ->   IS_IPV4_MAPPED(INET6_ATON('::ffff:c0a8:0001')),
4      ->   IS_IPV4_MAPPED(INET6_ATON('::ffff:c0a8:1'));
5          -> 1, 1, 1

• IS_IPV6(expr)

인자가 문자열로 지정된 유효한 IPv6 주소이면 1을, 그렇지 않으면 0을 반환합니다. 단, _expr_이 NULL이면 NULL을 반환합니다. 이 함수는 IPv4 주소를 유효한 IPv6 주소로 간주하지 않습니다.

1mysql> SELECT IS_IPV6('10.0.5.9'), IS_IPV6('::1');
2          -> 0, 1

주어진 인자에 대해, IS_IPV6()가 1을 반환하면 INET6_ATON()은 non-NULL을 반환합니다.

• IS_UUID(string_uuid)

인자가 유효한 문자열 형식 UUID이면 1을, 유효한 UUID가 아니면 0을, 인자가 NULL이면 NULL을 반환합니다.

“유효함”은 값이 파싱될 수 있는 포맷에 있다는 의미입니다. 즉, 길이가 올바르고 허용된 문자(어떤 lettercase의 16진수 숫자 및, 선택적으로 대시와 중괄호)만 포함해야 합니다. 다음 포맷이 가장 일반적입니다:

1aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee

다음과 같은 다른 포맷도 허용됩니다:

1aaaaaaaabbbbccccddddeeeeeeeeeeee
2{aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee}

값 내 필드의 의미는 UUID() 함수 설명을 참조하십시오.

1mysql> SELECT IS_UUID('6ccd780c-baba-1026-9564-5b8c656024db');
2+-------------------------------------------------+
3| IS_UUID('6ccd780c-baba-1026-9564-5b8c656024db') |
4+-------------------------------------------------+
5|                                               1 |
6+-------------------------------------------------+
7mysql> SELECT IS_UUID('6CCD780C-BABA-1026-9564-5B8C656024DB');
8+-------------------------------------------------+
9| IS_UUID('6CCD780C-BABA-1026-9564-5B8C656024DB') |
10+-------------------------------------------------+
11|                                               1 |
12+-------------------------------------------------+
13mysql> SELECT IS_UUID('6ccd780cbaba102695645b8c656024db');
14+---------------------------------------------+
15| IS_UUID('6ccd780cbaba102695645b8c656024db') |
16+---------------------------------------------+
17|                                           1 |
18+---------------------------------------------+
19mysql> SELECT IS_UUID('{6ccd780c-baba-1026-9564-5b8c656024db}');
20+---------------------------------------------------+
21| IS_UUID('{6ccd780c-baba-1026-9564-5b8c656024db}') |
22+---------------------------------------------------+
23|                                                 1 |
24+---------------------------------------------------+
25mysql> SELECT IS_UUID('6ccd780c-baba-1026-9564-5b8c6560');
26+---------------------------------------------+
27| IS_UUID('6ccd780c-baba-1026-9564-5b8c6560') |
28+---------------------------------------------+
29|                                           0 |
30+---------------------------------------------+
31mysql> SELECT IS_UUID(RAND());
32+-----------------+
33| IS_UUID(RAND()) |
34+-----------------+
35|               0 |
36+-----------------+

• NAME_CONST(name,value)

지정된 value를 반환합니다. 결과 집합 컬럼을 생성할 때 사용되면, NAME_CONST()는 컬럼이 지정된 이름을 갖도록 합니다. 인자는 상수여야 합니다.

1mysql> SELECT NAME_CONST('myname', 14);
2+--------+
3| myname |
4+--------+
5|     14 |
6+--------+

이 함수는 내부 용도로만 사용됩니다. 서버는 Section 27.9, “Stored Program Binary Logging”에 설명된 것처럼, 로컬 프로그램 변수 참조를 포함하는 저장 프로그램에서 문장을 쓸 때 이 함수를 사용합니다. mysqlbinlog의 출력에서 이 함수를 볼 수 있습니다.

애플리케이션에서는 다음과 같이 간단한 별칭(alias)을 사용하여 앞의 예와 정확히 같은 결과를 얻을 수 있습니다:

1mysql> SELECT 14 AS myname;
2+--------+
3| myname |
4+--------+
5|     14 |
6+--------+
71 row in set (0.00 sec)

컬럼 별칭에 대한 자세한 내용은 Section 15.2.13, “SELECT Statement”를 참조하십시오.

• SLEEP(duration)

duration 인자로 지정된 초 수만큼 슬립(일시 정지)한 후 0을 반환합니다. duration은 소수 부분을 가질 수 있습니다. 인자가 NULL이거나 음수이면, SLEEP()는 경고를 생성하거나, strict SQL 모드에서는 에러를 생성합니다.

슬립이 정상적으로(중단되지 않고) 반환되면 0을 반환합니다:

1mysql> SELECT SLEEP(1000);
2+-------------+
3| SLEEP(1000) |
4+-------------+
5|           0 |
6+-------------+

SLEEP()만이 쿼리에서 호출되는 내용이고 그 쿼리가 중단되면, SLEEP()은 1을 반환하고 쿼리 자체는 에러를 반환하지 않습니다. 이는 쿼리가 kill되거나 timeout되는 경우 모두에 해당합니다:

• 이 문장은 다른 세션에서 KILL QUERY를 사용하여 중단됩니다:

1mysql> SELECT SLEEP(1000);
2+-------------+
3| SLEEP(1000) |
4+-------------+
5|           1 |
6+-------------+

• 이 문장은 timeout으로 인해 중단됩니다:

1mysql> SELECT /*+ MAX_EXECUTION_TIME(1) */ SLEEP(1000);
2+-------------+
3| SLEEP(1000) |
4+-------------+
5|           1 |
6+-------------+

SLEEP()이 중단된 쿼리의 일부일 뿐인 경우, 쿼리는 에러를 반환합니다:

• 이 문장은 다른 세션에서 KILL QUERY를 사용하여 중단됩니다:

1mysql> SELECT 1 FROM t1 WHERE SLEEP(1000);
2ERROR 1317 (70100): Query execution was interrupted

• 이 문장은 timeout으로 인해 중단됩니다:

1mysql> SELECT /*+ MAX_EXECUTION_TIME(1000) */ 1 FROM t1 WHERE SLEEP(1000);
2ERROR 3024 (HY000): Query execution was interrupted, maximum statement
3execution time exceeded

이 함수는 statement-based replication에서 unsafe합니다. binlog_format이 STATEMENT로 설정되어 있을 때 이 함수를 사용하면 경고가 로그에 기록됩니다.

• UUID()

RFC 4122, “A Universally Unique IDentifier (UUID) URN Namespace” ( http://www.ietf.org/rfc/rfc4122.txt)에 따라 생성된 Universal Unique Identifier(UUID)를 반환합니다.

UUID는 공간과 시간 전체에 걸쳐 전역적으로 고유하도록 설계된 숫자입니다. 서로 연결되지 않은 두 개의 장치에서 수행된 호출이라 하더라도, UUID()를 두 번 호출하면 서로 다른 값을 생성할 것으로 예상됩니다.

주의

UUID() 값은 고유하도록 설계되었지만, 반드시 예측 불가능하거나 추측 불가능한 것은 아닙니다. 예측 불가능성이 필요한 경우, UUID 값은 다른 방식으로 생성해야 합니다.

UUID()는 RFC 4122에 설명된 UUID version 1을 준수하는 값을 반환합니다. 이 값은 128비트 숫자이며, aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee 형식의 다섯 개 16진수 숫자로 구성된 utf8mb3 문자열로 표현됩니다:

• 처음 세 숫자는 timestamp의 low, middle, high 부분에서 생성됩니다. high 부분에는 UUID 버전 번호도 포함됩니다.

• 네 번째 숫자는 timestamp 값의 단조성(monotonicity)이 손실되는 경우(예: 서머타임(daylight saving time) 때문) 시간상의 유일성을 유지합니다.

• 다섯 번째 숫자는 공간적 유일성(spatial uniqueness)을 제공하는 IEEE 802 노드 번호입니다. (예: 호스트 장치에 Ethernet 카드가 없거나, 호스트 운영체제에서 인터페이스의 하드웨어 주소를 찾는 방법을 알 수 없는 경우처럼) 노드 번호를 사용할 수 없는 경우에는 random number가 대신 사용됩니다. 이 경우 공간적 유일성은 보장할 수 없습니다. 그럼에도 불구하고, 충돌의 확률은 매우 낮아야 합니다.

  인터페이스의 MAC 주소는 FreeBSD, Linux, Windows에서만 고려됩니다. 다른 운영체제에서는 MySQL이 무작위로 생성된 48비트 숫자를 사용합니다.

1mysql> SELECT UUID();
2        -> '6ccd780c-baba-1026-9564-5b8c656024db'

문자열과 바이너리 UUID 값 사이를 변환하려면 UUID_TO_BIN() 및 BIN_TO_UUID() 함수를 사용하십시오. 문자열이 유효한 UUID 값인지 확인하려면 IS_UUID() 함수를 사용하십시오.

이 함수는 statement-based replication에서 unsafe합니다. binlog_format이 STATEMENT로 설정되어 있을 때 이 함수를 사용하면 경고가 로그에 기록됩니다.

• UUID_SHORT()

64비트 unsigned 정수로 된 “short” universal identifier를 반환합니다. UUID_SHORT()가 반환하는 값은 UUID() 함수가 반환하는 문자열 형식 128비트 identifier와 다르며, 유일성 특성도 다릅니다. 다음 조건이 충족되면 UUID_SHORT()의 값은 고유함이 보장됩니다:

• 현재 서버의 server_id 값이 0과 255 사이이며, source 및 replica 서버 집합 내에서 고유해야 합니다.

• mysqld가 다시 시작되는 동안 서버 호스트의 시스템 시간을 되돌리지 않습니다.

• mysqld가 다시 시작되는 동안 평균적으로 UUID_SHORT()를 초당 1,600만 번 미만으로 호출합니다.

UUID_SHORT() 반환 값은 다음과 같이 구성됩니다:

1  (server_id & 255) << 56
2+ (server_startup_time_in_seconds << 24)
3+ incremented_variable++;

1mysql> SELECT UUID_SHORT();
2        -> 92395783831158784

참고

UUID_SHORT()는 statement-based replication과 함께 사용할 수 없습니다.

• UUID_TO_BIN(string_uuid), UUID_TO_BIN(string_uuid, swap_flag)

문자열 UUID를 바이너리 UUID로 변환하여 반환합니다. (허용되는 문자열 UUID 포맷 목록은 IS_UUID() 함수 설명을 참조하십시오.) 반환되는 바이너리 UUID는 VARBINARY(16) 값입니다. UUID 인자가 NULL이면 반환 값은 NULL입니다. 인자 중 하나라도 유효하지 않으면 에러가 발생합니다.

UUID_TO_BIN()는 하나 또는 두 개의 인자를 받습니다:

• 인자 하나짜리 형식은 문자열 UUID 값을 받습니다. 바이너리 결과는 문자열 인자와 동일한 순서를 갖습니다.

• 인자 두 개짜리 형식은 문자열 UUID 값과 플래그 값을 받습니다:

  • _swap_flag_가 0이면, 인자 두 개짜리 형식은 인자 하나짜리 형식과 동일합니다. 바이너리 결과는 문자열 인자와 동일한 순서를 갖습니다.
  • _swap_flag_가 1이면, 반환 값의 포맷은 달라집니다. time-low와 time-high 부분(각각 첫 번째와 세 번째 16진수 숫자 그룹)이 스왑됩니다. 이렇게 하면 더 빠르게 변하는 부분이 오른쪽으로 이동하여, 결과가 인덱스된 컬럼에 저장될 때 인덱싱 효율을 향상시킬 수 있습니다.

time-part 스와핑은 UUID() 함수가 생성하는 것처럼 UUID version 1 값을 사용할 것을 전제로 합니다. version 1 포맷을 따르지 않는 다른 방식으로 생성된 UUID 값에 대해서는 time-part 스와핑이 이점을 제공하지 않습니다. version 1 포맷에 대한 자세한 내용은 UUID() 함수 설명을 참조하십시오.

다음과 같은 문자열 UUID 값이 있다고 가정합니다:

1mysql> SET @uuid = '6ccd780c-baba-1026-9564-5b8c656024db';

문자열 UUID를 time-part 스와핑을 사용하거나 사용하지 않고 바이너리로 변환하려면 UUID_TO_BIN()를 사용합니다:

1mysql> SELECT HEX(UUID_TO_BIN(@uuid));
2+----------------------------------+
3| HEX(UUID_TO_BIN(@uuid))          |
4+----------------------------------+
5| 6CCD780CBABA102695645B8C656024DB |
6+----------------------------------+
7mysql> SELECT HEX(UUID_TO_BIN(@uuid, 0));
8+----------------------------------+
9| HEX(UUID_TO_BIN(@uuid, 0))       |
10+----------------------------------+
11| 6CCD780CBABA102695645B8C656024DB |
12+----------------------------------+
13mysql> SELECT HEX(UUID_TO_BIN(@uuid, 1));
14+----------------------------------+
15| HEX(UUID_TO_BIN(@uuid, 1))       |
16+----------------------------------+
17| 1026BABA6CCD780C95645B8C656024DB |
18+----------------------------------+

UUID_TO_BIN()이 반환한 바이너리 UUID를 문자열 UUID로 변환하려면 BIN_TO_UUID()를 사용합니다. time 부분을 스왑하기 위해 두 번째 인자로 1을 사용하여 UUID_TO_BIN()를 호출하여 바이너리 UUID를 생성한 경우, 바이너리 UUID를 문자열 UUID로 다시 변환할 때 time 부분을 다시 되돌리기 위해 BIN_TO_UUID()에도 두 번째 인자로 1을 전달해야 합니다:

1mysql> SELECT BIN_TO_UUID(UUID_TO_BIN(@uuid));
2+--------------------------------------+
3| BIN_TO_UUID(UUID_TO_BIN(@uuid))      |
4+--------------------------------------+
5| 6ccd780c-baba-1026-9564-5b8c656024db |
6+--------------------------------------+
7mysql> SELECT BIN_TO_UUID(UUID_TO_BIN(@uuid,0),0);
8+--------------------------------------+
9| BIN_TO_UUID(UUID_TO_BIN(@uuid,0),0)  |
10+--------------------------------------+
11| 6ccd780c-baba-1026-9564-5b8c656024db |
12+--------------------------------------+
13mysql> SELECT BIN_TO_UUID(UUID_TO_BIN(@uuid,1),1);
14+--------------------------------------+
15| BIN_TO_UUID(UUID_TO_BIN(@uuid,1),1)  |
16+--------------------------------------+
17| 6ccd780c-baba-1026-9564-5b8c656024db |
18+--------------------------------------+

양 방향 변환에서 time-part 스와핑 사용 방식이 동일하지 않으면, 원래 UUID는 올바르게 복원되지 않습니다:

1mysql> SELECT BIN_TO_UUID(UUID_TO_BIN(@uuid,0),1);
2+--------------------------------------+
3| BIN_TO_UUID(UUID_TO_BIN(@uuid,0),1)  |
4+--------------------------------------+
5| baba1026-780c-6ccd-9564-5b8c656024db |
6+--------------------------------------+
7mysql> SELECT BIN_TO_UUID(UUID_TO_BIN(@uuid,1),0);
8+--------------------------------------+
9| BIN_TO_UUID(UUID_TO_BIN(@uuid,1),0)  |
10+--------------------------------------+
11| 1026baba-6ccd-780c-9564-5b8c656024db |
12+--------------------------------------+

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

• VALUES(col_name)

INSERT ... ON DUPLICATE KEY UPDATE 문장에서, UPDATE 절 내에서 VALUES(col_name) 함수를 사용하여 문장의 INSERT 부분의 컬럼 값을 참조할 수 있습니다. 즉, UPDATE 절의 VALUES(col_name)은 중복 키 충돌이 발생하지 않았더라면 삽입되었을 col_name 값에 해당합니다. 이 함수는 특히 다중 행 insert에서 유용합니다. VALUES() 함수는 INSERT 문장의 ON DUPLICATE KEY UPDATE 절에서만 의미가 있으며, 그 외에는 NULL을 반환합니다. Section 15.2.7.2, “INSERT ... ON DUPLICATE KEY UPDATE Statement”를 참조하십시오.

1mysql> INSERT INTO table (a,b,c) VALUES (1,2,3),(4,5,6)
2      -> ON DUPLICATE KEY UPDATE c=VALUES(a)+VALUES(b);

주의

이 사용법은 더 이상 사용되지 않으며(deprecated), 향후 MySQL 릴리스에서 제거될 수 있습니다. 대신 행 별칭(row alias) 또는 행 및 컬럼 별칭을 사용하십시오. 자세한 내용과 예제는 Section 15.2.7.2, “INSERT ... ON DUPLICATE KEY UPDATE Statement”를 참조하십시오.