14.15 Information Functions

14.15 Information Functions

Table 14.20 Information Functions

Name	Description
BENCHMARK()	expression을 반복적으로 실행
CHARSET()	인수의 문자 집합을 반환
COERCIBILITY()	문자열 인수의 콜레이션 강제(coercibility) 값을 반환
COLLATION()	문자열 인수의 콜레이션을 반환
CONNECTION_ID()	커넥션의 커넥션 ID(스레드 ID)를 반환
CURRENT_ROLE()	현재 활성화된 롤들을 반환
CURRENT_USER(), CURRENT_USER	인증된 사용자 이름과 호스트 이름
DATABASE()	기본(현재) 데이터베이스 이름을 반환
FOUND_ROWS()	LIMIT 절이 있는 SELECT에 대해, LIMIT 절이 없었다면<br> 반환되었을 행 수
ICU_VERSION()	ICU 라이브러리 버전
LAST_INSERT_ID()	마지막 INSERT에 대한 AUTO_INCREMENT 열 값
ROLES_GRAPHML()	메모리 롤 서브그래프를 나타내는 GraphML 문서를 반환
ROW_COUNT()	갱신된 행 수
SCHEMA()	DATABASE()의 동의어
SESSION_USER()	USER()의 동의어
SYSTEM_USER()	USER()의 동의어
USER()	클라이언트가 제공한 사용자 이름과 호스트 이름
VERSION()	MySQL 서버 버전을 나타내는 문자열을 반환

Name	Description

• BENCHMARK(count,expr)

BENCHMARK() 함수는 expression _expr_을 count 회 반복해서 실행합니다. 이는 MySQL이 expression을 얼마나 빠르게 처리하는지 측정하는 데 사용될 수 있습니다. 결과 값은 0이며, NULL 또는 음수 반복 횟수와 같은 부적절한 인수에 대해서는 NULL입니다.

이 함수는 쿼리 실행 시간을 보고하는 mysql 클라이언트 내에서 사용하는 것을 의도합니다:

1mysql> SELECT BENCHMARK(1000000,AES_ENCRYPT('hello','goodbye'));
2+---------------------------------------------------+
3| BENCHMARK(1000000,AES_ENCRYPT('hello','goodbye')) |
4+---------------------------------------------------+
5|                                                 0 |
6+---------------------------------------------------+
71 row in set (4.74 sec)

보고되는 시간은 서버 측 CPU 시간(타임)이지 않고 클라이언트 측 경과 시간입니다. BENCHMARK()를 여러 번 실행하고, 서버 머신의 부하 정도를 고려하여 결과를 해석하는 것이 좋습니다.

BENCHMARK()는 스칼라 expression의 런타임 성능을 측정하기 위한 것으로, 이를 사용하는 방식과 결과 해석에 대해 몇 가지 중요한 함의를 가집니다:

• 오직 스칼라 expression만 사용할 수 있습니다. expression은 서브쿼리가 될 수 있지만, 단일 열 및 최대 한 개의 행만 반환해야 합니다. 예를 들어, BENCHMARK(10, (SELECT * FROM t))는 테이블 t에 열이 하나 이상이거나 행이 두 개 이상이면 실패합니다.

• SELECT expr 문장을 N 회 실행하는 것은, SELECT BENCHMARK(N, expr)을 실행하는 것과 오버헤드 측면에서 다릅니다. 두 방식은 매우 다른 실행 프로파일을 가지며, 동일한 시간이 걸릴 것으로 기대해서는 안 됩니다. 전자는 파서, 옵티마이저, 테이블 잠금, 런타임 평가를 각각 N 회 수행합니다. 후자는 런타임 평가만 N 회 수행하며, 다른 모든 컴포넌트는 한 번만 수행됩니다. 이미 할당된 메모리 구조는 재사용되며, 집계 함수에 대해 이미 평가된 결과의 로컬 캐싱과 같은 런타임 최적화가 결과를 변경할 수 있습니다. 따라서 BENCHMARK()를 사용하면 네트워크, 파서, 옵티마이저 등으로 인한 “노이즈”를 제거하고 런타임 컴포넌트에 더 큰 가중치를 부여하여 런타임 컴포넌트의 성능을 측정하게 됩니다.

• CHARSET(str)

문자열 인수의 문자 집합을 반환하며, 인수가 NULL이면 NULL을 반환합니다.

1mysql> SELECT CHARSET('abc');
2          -> 'utf8mb3'
3mysql> SELECT CHARSET(CONVERT('abc' USING latin1));
4          -> 'latin1'
5mysql> SELECT CHARSET(USER());
6          -> 'utf8mb3'

• COERCIBILITY(str)

문자열 인수의 콜레이션 강제(coercibility) 값을 반환합니다.

1mysql> SELECT COERCIBILITY('abc' COLLATE utf8mb4_swedish_ci);
2          -> 0
3mysql> SELECT COERCIBILITY(USER());
4          -> 3
5mysql> SELECT COERCIBILITY('abc');
6          -> 4
7mysql> SELECT COERCIBILITY(1000);
8          -> 5

반환 값의 의미는 다음 표와 같습니다. 값이 낮을수록 우선순위가 더 높습니다.

Coercibility	Meaning	Example
0	명시적 콜레이션	COLLATE 절이 있는 값
2	암시적 콜레이션	열 값, 저장 루틴 매개변수 또는 로컬 변수
3	시스템 상수	USER() 반환 값
4	강제 가능	리터럴 문자열
5	숫자형	숫자 또는 시간값
6	Null	NULL 또는<br> NULL에서 파생된 expression
7	콜레이션 없음	서로 다른 콜레이션을 가진 문자열들의 연결

1은 이전에 “콜레이션 없음”에 사용되었습니다. MySQL 9.5에서는 사용되지 않지만, 하위 호환성을 위해 여전히 유효한 값으로 간주됩니다. (Bug #37285902)

자세한 내용은 Section 12.8.4, “Collation Coercibility in Expressions”를 참조하십시오.

• COLLATION(str)

문자열 인수의 콜레이션을 반환합니다.

1mysql> SELECT COLLATION('abc');
2          -> 'utf8mb4_0900_ai_ci'
3mysql> SELECT COLLATION(_utf8mb4'abc');
4          -> 'utf8mb4_0900_ai_ci'
5mysql> SELECT COLLATION(_latin1'abc');
6          -> 'latin1_swedish_ci'

• CONNECTION_ID()

커넥션에 대한 커넥션 ID(스레드 ID)를 반환합니다. 각 커넥션은 현재 연결된 클라이언트 집합 내에서 유일한 ID를 가집니다.

CONNECTION_ID()가 반환하는 값은 Information Schema PROCESSLIST 테이블의 ID 열, SHOW PROCESSLIST 출력의 Id 열, Performance Schema threads 테이블의 PROCESSLIST_ID 열에 표시되는 값과 동일한 유형입니다.

1mysql> SELECT CONNECTION_ID();
2          -> 23786

주의

세션 단위 시스템 변수인 pseudo_thread_id의 값을 변경하면 CONNECTION_ID() 함수가 반환하는 값이 변경됩니다.

• CURRENT_ROLE()

현재 세션에 대해 현재 활성화된 롤들을 콤마로 구분하여 포함하는 utf8mb3 문자열을 반환하며, 롤이 없으면 NONE을 반환합니다. 이 값은 sql_quote_show_create 시스템 변수의 설정을 반영합니다.

다음과 같이 계정에 롤이 GRANT되었다고 가정합니다:

1GRANT 'r1', 'r2' TO 'u1'@'localhost';
2SET DEFAULT ROLE ALL TO 'u1'@'localhost';

u1에 대한 세션에서 초기 CURRENT_ROLE() 값은 계정의 기본 롤들을 나타냅니다. [SET ROLE](https://dev.mysql.com/doc/refman/9.5/en/set-role.html "15.7.1.11 SET ROLE Statement)을 사용하면 다음과 같이 변경됩니다:

1mysql> SELECT CURRENT_ROLE();
2+-------------------+
3| CURRENT_ROLE()    |
4+-------------------+
5| `r1`@`%`,`r2`@`%` |
6+-------------------+
7mysql> SET ROLE 'r1'; SELECT CURRENT_ROLE();
8+----------------+
9| CURRENT_ROLE() |
10+----------------+
11| `r1`@`%`       |
12+----------------+

• CURRENT_USER, CURRENT_USER()

서버가 현재 클라이언트를 인증하는 데 사용한 MySQL 계정의 사용자 이름과 호스트 이름 조합을 반환합니다. 이 계정이 접근 권한을 결정합니다. 반환 값은 utf8mb3 문자 집합의 문자열입니다.

CURRENT_USER()의 값은 USER()의 값과 다를 수 있습니다.

1mysql> SELECT USER();
2          -> 'davida@localhost'
3mysql> SELECT * FROM mysql.user;
4ERROR 1044: Access denied for user ''@'localhost' to
5database 'mysql'
6mysql> SELECT CURRENT_USER();
7          -> '@localhost'

이 예는 클라이언트가 USER() 함수 값에서 볼 수 있듯이 사용자 이름으로 davida를 지정했음에도, 서버가 익명 사용자 계정(비어 있는 사용자 이름 부분을 갖는 CURRENT_USER() 값에서 보이듯이)을 사용해 클라이언트를 인증했음을 보여 줍니다. 이는 예를 들어 GRANT 테이블에 davida에 대한 계정이 존재하지 않는 경우 발생할 수 있습니다.

저장 프로그램 또는 뷰 내에서는, CURRENT_USER()가 해당 오브젝트를 정의한 사용자의 계정(그 오브젝트의 DEFINER 값에 의해 주어짐)을 반환합니다. 단, SQL SECURITY INVOKER 속성으로 정의된 경우는 예외입니다. 후자의 경우 CURRENT_USER()는 오브젝트의 호출자(invoker)를 반환합니다.

트리거와 이벤트는 SQL SECURITY 속성을 정의할 옵션이 없으므로, 이들 오브젝트에 대해서는 CURRENT_USER()가 오브젝트를 정의한 사용자의 계정을 반환합니다. 호출자를 반환하려면 USER() 또는 SESSION_USER()를 사용하십시오.

다음 문장들은 영향을 받는 사용자 또는 definer의 이름(그리고 필요 시 호스트) 대신 CURRENT_USER() 함수를 사용하는 것을 지원합니다. 이러한 경우 CURRENT_USER()는 필요에 따라 적절한 위치에 확장됩니다:

• DROP USER

• RENAME USER

• GRANT

• REVOKE

• CREATE FUNCTION

• CREATE PROCEDURE

• CREATE TRIGGER

• CREATE EVENT

• CREATE VIEW

• ALTER EVENT

• ALTER VIEW

• SET PASSWORD

이러한 CURRENT_USER()의 확장이 복제에 미치는 영향에 대한 정보는 Section 19.5.1.8, “Replication of CURRENT_USER()”를 참조하십시오.

이 함수는 다음 [CREATE TABLE](https://dev.mysql.com/doc/refman/9.5/en/create-table.html "15.1.24 CREATE TABLE Statement)에 나온 것처럼 VARCHAR 또는 TEXT 열의 기본값으로 사용될 수 있습니다:

1CREATE TABLE t (c VARCHAR(288) DEFAULT (CURRENT_USER()));

• DATABASE()

기본(현재) 데이터베이스 이름을 utf8mb3 문자 집합의 문자열으로 반환합니다. 기본 데이터베이스가 없으면 DATABASE()는 NULL을 반환합니다. 저장 루틴 내에서는, 기본 데이터베이스가 루틴이 연관된 데이터베이스이며, 이는 호출 컨텍스트에서의 기본 데이터베이스와 반드시 같지는 않습니다.

1mysql> SELECT DATABASE();
2          -> 'test'

기본 데이터베이스가 없으면 DATABASE()는 NULL을 반환합니다.

• FOUND_ROWS()

참고

SQL_CALC_FOUND_ROWS 쿼리 수정자와 이에 수반되는 FOUND_ROWS() 함수는 deprecated 상태이며, 향후 MySQL 버전에서 제거될 예정입니다. 쿼리를 LIMIT와 함께 실행한 뒤, 추가 행이 있는지 판단하기 위해 COUNT(*)를 사용하고 LIMIT 없이 두 번째 쿼리를 실행하십시오. 예를 들어 다음 쿼리 대신:

1SELECT SQL_CALC_FOUND_ROWS * FROM tbl_name WHERE id > 100 LIMIT 10;
2SELECT FOUND_ROWS();

대신 다음 쿼리를 사용하십시오:

1SELECT * FROM tbl_name WHERE id > 100 LIMIT 10;
2SELECT COUNT(*) FROM tbl_name WHERE id > 100;

COUNT(*)는 특정 최적화의 대상이 됩니다. SQL_CALC_FOUND_ROWS는 일부 최적화를 비활성화합니다.

SELECT 문장에는 서버가 클라이언트에 반환하는 행 수를 제한하기 위한 LIMIT 절이 포함될 수 있습니다. 어떤 경우에는, 문장을 다시 실행하지 않고도 LIMIT이 없었다면 문장이 몇 개의 행을 반환했을지 아는 것이 바람직할 수 있습니다. 이 행 수를 얻으려면 SELECT 문장에 SQL_CALC_FOUND_ROWS 옵션을 포함하고, 그 후에 FOUND_ROWS()를 호출하십시오:

1mysql> SELECT SQL_CALC_FOUND_ROWS * FROM tbl_name
2      -> WHERE id > 100 LIMIT 10;
3mysql> SELECT FOUND_ROWS();

두 번째 SELECT는, 첫 번째 SELECT가 LIMIT 절 없이 작성되었다면 반환했을 행 수를 나타내는 숫자를 반환합니다.

가장 최근에 성공한 SELECT 문장에 SQL_CALC_FOUND_ROWS 옵션이 없는 경우, FOUND_ROWS()는 해당 문장이 반환한 결과 집합(result set)의 행 수를 반환합니다. 문장에 LIMIT 절이 포함되어 있으면, FOUND_ROWS()는 limit까지의 행 수를 반환합니다. 예를 들어, 문장에 LIMIT 10 또는 LIMIT 50, 10이 포함되어 있으면, FOUND_ROWS()는 각각 10 또는 60을 반환합니다.

FOUND_ROWS()를 통해 얻을 수 있는 행 카운트는 일시적이며, SELECT SQL_CALC_FOUND_ROWS 문장 바로 다음 문장 이후까지 사용하도록 의도된 것이 아닙니다. 나중에 이 값을 참조해야 한다면, 다음과 같이 저장하십시오:

1mysql> SELECT SQL_CALC_FOUND_ROWS * FROM ... ;
2mysql> SET @rows = FOUND_ROWS();

SELECT SQL_CALC_FOUND_ROWS를 사용하면, MySQL은 전체 결과 집합에 몇 개의 행이 있는지 계산해야 합니다. 그러나 이 결과 집합을 클라이언트에 전송할 필요가 없기 때문에, LIMIT 없이 쿼리를 다시 실행하는 것보다 더 빠릅니다.

SQL_CALC_FOUND_ROWS와 FOUND_ROWS()는 쿼리가 반환하는 행 수를 제한하면서도 쿼리를 다시 실행하지 않고 전체 결과 집합의 행 수를 알아내고자 할 때 유용할 수 있습니다. 한 예로, 검색 결과의 다른 부분을 보여 주는 페이지에 대한 링크를 포함하는 페이지 단위(paged) 디스플레이를 제공하는 웹 스크립트가 있습니다. FOUND_ROWS()를 사용하면 나머지 결과에 필요한 다른 페이지 수를 파악할 수 있습니다.

UNION 문장에서는 간단한 SELECT 문장보다 SQL_CALC_FOUND_ROWS와 FOUND_ROWS()의 사용이 더 복잡합니다. 이는 UNION에서 LIMIT이 여러 위치에 나타날 수 있기 때문입니다. LIMIT은 UNION 내의 개별 SELECT 문장에 적용될 수도 있고, UNION 전체 결과에 전역적으로 적용될 수도 있습니다.

UNION에 대해 SQL_CALC_FOUND_ROWS가 의도하는 바는, 전역 LIMIT이 없을 때 반환될 행 카운트를 반환해야 한다는 것입니다. UNION에서 SQL_CALC_FOUND_ROWS를 사용할 수 있는 조건은 다음과 같습니다:

• SQL_CALC_FOUND_ROWS 키워드는 UNION의 첫 번째 SELECT에 나타나야 합니다.

• FOUND_ROWS()의 값이 정확하려면 [UNION ALL](https://dev.mysql.com/doc/refman/9.5/en/union.html "15.2.18 UNION Clause)을 사용해야 합니다. ALL 없는 UNION을 사용하면, 중복 제거가 발생하고, FOUND_ROWS()의 값은 근사치에 불과합니다.

• UNION에 LIMIT이 없으면, SQL_CALC_FOUND_ROWS는 무시되며, UNION를 처리하기 위해 생성되는 임시 테이블의 행 수를 반환합니다.

여기에 설명된 경우를 넘어서는 상황(예를 들어, 에러로 실패한 SELECT 문장 이후의 값)에 대해서는 FOUND_ROWS()의 동작이 정의되어 있지 않습니다.

주의

FOUND_ROWS()는 statement 기반 복제를 사용할 때 신뢰할 수 있게 복제되지 않습니다. 이 함수는 행 기반 복제를 사용할 때 자동으로 복제됩니다.

• ICU_VERSION()

정규 표현식 연산을 지원하는 데 사용되는 International Components for Unicode(ICU) 라이브러리의 버전입니다(Section 14.8.2, “Regular Expressions” 참조). 이 함수는 주로 테스트 케이스에서 사용하기 위한 것입니다.

• LAST_INSERT_ID(), LAST_INSERT_ID(expr)

인수가 없으면, LAST_INSERT_ID()는 가장 최근에 실행된 INSERT 문장의 결과로 AUTO_INCREMENT 열에 대해 성공적으로 insert된 첫 번째 자동 생성 값을 나타내는 BIGINT UNSIGNED(64비트) 값을 반환합니다. 행이 성공적으로 insert되지 않으면 LAST_INSERT_ID()의 값은 변하지 않습니다.

인수가 있는 경우, LAST_INSERT_ID()는 부호 없는 정수를 반환하며, 인수가 NULL이면 NULL을 반환합니다.

예를 들어 AUTO_INCREMENT 값을 생성하는 행을 insert한 후, 다음과 같이 값을 얻을 수 있습니다:

1mysql> SELECT LAST_INSERT_ID();
2          -> 195

현재 실행 중인 문장은 LAST_INSERT_ID()의 값에 영향을 주지 않습니다. 예를 들어, 한 문장에서 AUTO_INCREMENT 값을 생성한 다음, 자체 AUTO_INCREMENT 열을 가진 테이블에 행들을 insert하는 다중 행 INSERT 문장에서 LAST_INSERT_ID()를 참조한다고 가정합니다. 이 두 번째 문장에서 LAST_INSERT_ID()의 값은 안정적으로 유지되며, 두 번째 및 이후 행에 대해서는 앞선 행 insert의 영향을 받지 않습니다. (단, LAST_INSERT_ID()와 LAST_INSERT_ID(expr)에 대한 참조를 섞어 쓰는 경우, 그 효과는 정의되어 있지 않습니다.)

이전 문장이 에러를 반환했다면, LAST_INSERT_ID()의 값은 정의되어 있지 않습니다. 트랜잭션 테이블의 경우, 에러로 인해 문장이 롤백되면 LAST_INSERT_ID()의 값은 정의되지 않은 상태로 남습니다. 수동 [ROLLBACK](https://dev.mysql.com/doc/refman/9.5/en/commit.html "15.3.1 START TRANSACTION, COMMIT, and ROLLBACK Statements)의 경우, LAST_INSERT_ID()의 값은 트랜잭션 이전 값으로 복원되지 않고, ROLLBACK 시점의 값으로 유지됩니다.

저장 루틴(프로시저 또는 함수) 또는 트리거의 본문(body) 내에서는, LAST_INSERT_ID()의 값이 이들 오브젝트 본문 밖에서 실행된 문장의 경우와 동일한 방식으로 변경됩니다. 저장 루틴 또는 트리거가 이후 문장에서 보게 되는 LAST_INSERT_ID() 값에 미치는 영향은 루틴의 종류에 따라 달라집니다:

• 저장 프로시저가 LAST_INSERT_ID() 값을 바꾸는 문장을 실행하면, 프로시저 호출 뒤에 오는 문장에서 변경된 값을 볼 수 있습니다.

• 값을 변경하는 저장 함수 및 트리거의 경우, 함수 또는 트리거가 끝날 때 값이 복원되므로, 그 뒤에 오는 문장에서는 변경된 값을 볼 수 없습니다.

생성된 ID는 서버에서 _커넥션별_로 유지됩니다. 즉, 주어진 클라이언트에 대해 이 함수가 반환하는 값은 _그 클라이언트_가 AUTO_INCREMENT 열에 영향을 주는 가장 최근 문장에서 생성된 첫 번째 AUTO_INCREMENT 값입니다. 다른 클라이언트가 자신의 AUTO_INCREMENT 값을 생성하더라도 이 값은 영향을 받지 않습니다. 이 동작은 각 클라이언트가 다른 클라이언트의 활동을 신경 쓰지 않고, 잠금이나 트랜잭션 없이도 자체 ID를 검색할 수 있도록 보장합니다.

행의 AUTO_INCREMENT 열을 “매직”이 아닌 값(즉, NULL도 아니고 0도 아닌 값)으로 설정해도 LAST_INSERT_ID()의 값은 변경되지 않습니다.

주의

단일 INSERT 문장으로 여러 행을 insert하는 경우, LAST_INSERT_ID()는 _첫 번째_로 insert된 행에 대해 생성된 값만 반환합니다. 이렇게 하는 이유는 동일한 INSERT 문장을 다른 서버에 대해 쉽게 재현할 수 있도록 하기 위함입니다.

예:

1mysql> USE test;
2
3mysql> CREATE TABLE t (
4       id INT AUTO_INCREMENT NOT NULL PRIMARY KEY,
5       name VARCHAR(10) NOT NULL
6       );
7
8mysql> INSERT INTO t VALUES (NULL, 'Bob');
9
10mysql> SELECT * FROM t;
11+----+------+
12| id | name |
13+----+------+
14|  1 | Bob  |
15+----+------+
16
17mysql> SELECT LAST_INSERT_ID();
18+------------------+
19| LAST_INSERT_ID() |
20+------------------+
21|                1 |
22+------------------+

1mysql> INSERT INTO t VALUES
2       (NULL, 'Mary'), (NULL, 'Jane'), (NULL, 'Lisa');
3
4mysql> SELECT * FROM t;
5+----+------+
6| id | name |
7+----+------+
8|  1 | Bob  |
9|  2 | Mary |
10|  3 | Jane |
11|  4 | Lisa |
12+----+------+
13
14mysql> SELECT LAST_INSERT_ID();
15+------------------+
16| LAST_INSERT_ID() |
17+------------------+
18|                2 |
19+------------------+

두 번째 INSERT 문장이 t에 세 개의 새 행을 insert했지만, 이 중 첫 번째 행에 대해 생성된 ID는 2였고, 이에 따라 그 다음 SELECT 문장에서 LAST_INSERT_ID()가 이 값을 반환합니다.

INSERT IGNORE를 사용했는데 행이 무시되면, LAST_INSERT_ID()는 현재 값에서 변경되지 않으며(또는 연결에서 아직 성공적인 INSERT를 수행하지 않았다면 0을 반환), 비(非)트랜잭션 테이블의 경우 AUTO_INCREMENT 카운터는 증가하지 않습니다. InnoDB 테이블의 경우, innodb_autoinc_lock_mode가 1 또는 2로 설정되어 있으면 AUTO_INCREMENT 카운터가 증가합니다. 다음 예에서와 같이 동작합니다:

1mysql> USE test;
2
3mysql> SELECT @@innodb_autoinc_lock_mode;
4+----------------------------+
5| @@innodb_autoinc_lock_mode |
6+----------------------------+
7|                          1 |
8+----------------------------+
9
10mysql> CREATE TABLE `t` (
11       `id` INT(11) NOT NULL AUTO_INCREMENT,
12       `val` INT(11) DEFAULT NULL,
13       PRIMARY KEY (`id`),
14       UNIQUE KEY `i1` (`val`)
15       ) ENGINE=InnoDB;
16
17# 두 개의 행 insert
18
19mysql> INSERT INTO t (val) VALUES (1),(2);
20
21# auto_increment_offset=1인 경우,
22# insert된 행으로 인해 AUTO_INCREMENT 값은 3이 됨
23
24mysql> SHOW CREATE TABLE t\G
25*************************** 1. row ***************************
26       Table: t
27Create Table: CREATE TABLE `t` (
28  `id` int(11) NOT NULL AUTO_INCREMENT,
29  `val` int(11) DEFAULT NULL,
30  PRIMARY KEY (`id`),
31  UNIQUE KEY `i1` (`val`)
32) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci
33
34# LAST_INSERT_ID()는 AUTO_INCREMENT 열에 대해
35# 성공적으로 insert된 첫 번째 자동 생성 값을 반환
36
37mysql> SELECT LAST_INSERT_ID();
38+------------------+
39| LAST_INSERT_ID() |
40+------------------+
41|                1 |
42+------------------+

1# 중복 행 insert 시도는 실패하지만 에러는 무시됨
2
3mysql> INSERT IGNORE INTO t (val) VALUES (1),(2);
4Query OK, 0 rows affected (0.00 sec)
5Records: 2  Duplicates: 2  Warnings: 0
6
7# innodb_autoinc_lock_mode=1인 경우,
8# 무시된 행에 대해서도 AUTO_INCREMENT 카운터가 증가함
9
10mysql> SHOW CREATE TABLE t\G
11*************************** 1. row ***************************
12       Table: t
13Create Table: CREATE TABLE `t` (
14  `id` int(11) NOT NULL AUTO_INCREMENT,
15  `val` int(11) DEFAULT NULL,
16  PRIMARY KEY (`id`),
17  UNIQUE KEY `i1` (`val`)
18) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci
19
20# 이전 insert가 성공하지 않았기 때문에 LAST_INSERT_ID는 변경되지 않음
21
22mysql> SELECT LAST_INSERT_ID();
23+------------------+
24| LAST_INSERT_ID() |
25+------------------+
26|                1 |
27+------------------+

자세한 내용은 Section 17.6.1.6, “AUTO_INCREMENT Handling in InnoDB”를 참조하십시오.

_expr_이 LAST_INSERT_ID()의 인수로 제공되면, 함수는 인수의 값을 반환하고, 해당 값을 LAST_INSERT_ID()가 다음에 반환할 값으로 기억합니다. 이는 시퀀스를 시뮬레이션하는 데 사용할 수 있습니다:

1. 시퀀스 카운터를 저장할 테이블을 생성하고 초기화합니다:

   1mysql> CREATE TABLE sequence (id INT NOT NULL);
   2mysql> INSERT INTO sequence VALUES (0);

2. 다음과 같이 테이블을 사용해 시퀀스 번호를 생성합니다:

   1mysql> UPDATE sequence SET id=LAST_INSERT_ID(id+1);
   2mysql> SELECT LAST_INSERT_ID();

   UPDATE 문장은 시퀀스 카운터를 증가시키고, 다음 LAST_INSERT_ID() 호출이 이 갱신된 값을 반환하도록 합니다. SELECT 문장은 그 값을 검색합니다. mysql_insert_id() C API 함수 역시 이 값을 얻는 데 사용할 수 있습니다. mysql_insert_id()를 참조하십시오.

LAST_INSERT_ID()를 호출하지 않고도 시퀀스를 생성할 수 있지만, 이 함수를 이런 방식으로 사용하는 유용성은 ID 값이 서버에서 마지막 자동 생성 값으로 유지된다는 점입니다. 여러 클라이언트가 UPDATE 문장을 실행하고 SELECT 문장(또는 mysql_insert_id())으로 자신의 시퀀스 값을 얻을 수 있으며, 서로의 시퀀스 값 생성에 영향을 주거나 영향을 받지 않습니다.

mysql_insert_id()는 INSERT 및 UPDATE 문장 이후에만 업데이트되므로, C API 함수로는 LAST_INSERT_ID(expr)의 값을, [SELECT](https://dev.mysql.com/doc/refman/9.5/en/select.html "15.2.13 SELECT Statement)나 SET 같은 다른 SQL 문장을 실행한 후에는 가져올 수 없습니다.

• ROLES_GRAPHML()

메모리 롤 서브그래프를 나타내는 GraphML 문서를 포함하는 utf8mb3 문자열을 반환합니다. ROLE_ADMIN 권한(또는 deprecated된 SUPER 권한)이 있어야 <graphml> 엘리먼트 안의 내용을 볼 수 있습니다. 그렇지 않으면 결과에는 빈 엘리먼트만 표시됩니다:

1mysql> SELECT ROLES_GRAPHML();
2+---------------------------------------------------+
3| ROLES_GRAPHML()                                   |
4+---------------------------------------------------+
5| <?xml version="1.0" encoding="UTF-8"?><graphml /> |
6+---------------------------------------------------+

• ROW_COUNT()

ROW_COUNT()는 다음과 같은 값을 반환합니다:

• DDL 문장: 0. 이는 CREATE TABLE, DROP TABLE과 같은 문장에 적용됩니다.

• SELECT 이외의 DML 문장: 영향을 받은 행 수. 이는 UPDATE, INSERT, DELETE (이전과 동일)뿐 아니라 이제는 ALTER TABLE, LOAD DATA 같은 문장에도 적용됩니다.

• SELECT: 문장이 결과 집합을 반환하면 -1, 그렇지 않으면 “영향받은” 행 수. 예를 들어 SELECT * FROM t1에 대해 ROW_COUNT()는 -1을 반환합니다. SELECT * FROM t1 INTO OUTFILE 'file_name'에 대해서는 ROW_COUNT()가 파일에 기록된 행 수를 반환합니다.

• SIGNAL 문장: 0.

UPDATE 문장의 경우, 기본적으로 affected-rows 값은 실제로 변경된 행 수입니다. mysqld에 연결할 때 mysql_real_connect()에 CLIENT_FOUND_ROWS 플래그를 지정하면, affected-rows 값은 WHERE 절에 의해 “찾은” 행 수가 됩니다.

REPLACE 문장의 경우, 새 행이 기존 행을 대체하면 한 행이 중복 삭제 후 insert되므로 affected-rows 값은 2입니다.

INSERT ... ON DUPLICATE KEY UPDATE 문장에 대해서는, 행당 affected-rows 값이, 새로운 행이 insert된 경우 1, 기존 행이 update된 경우 2, 기존 행이 현재 값으로 다시 설정된 경우 0입니다. CLIENT_FOUND_ROWS 플래그를 지정하면, 기존 행이 현재 값으로 다시 설정된 경우에도 affected-rows 값은 0이 아니라 1입니다.

ROW_COUNT() 값은 mysql_affected_rows() C API 함수와, 문장 실행 후 mysql 클라이언트에 표시되는 행 카운트와 유사합니다.

1mysql> INSERT INTO t VALUES(1),(2),(3);
2Query OK, 3 rows affected (0.00 sec)
3Records: 3  Duplicates: 0  Warnings: 0
4
5mysql> SELECT ROW_COUNT();
6+-------------+
7| ROW_COUNT() |
8+-------------+
9|           3 |
10+-------------+
111 row in set (0.00 sec)
12
13mysql> DELETE FROM t WHERE i IN(1,2);
14Query OK, 2 rows affected (0.00 sec)
15
16mysql> SELECT ROW_COUNT();
17+-------------+
18| ROW_COUNT() |
19+-------------+
20|           2 |
21+-------------+
221 row in set (0.00 sec)

주의

ROW_COUNT()는 statement 기반 복제를 사용할 때 신뢰할 수 있게 복제되지 않습니다. 이 함수는 행 기반 복제를 사용할 때 자동으로 복제됩니다.

• SCHEMA()

이 함수는 DATABASE()의 동의어입니다.

• SESSION_USER()

SESSION_USER()는 USER()의 동의어입니다.

USER()와 마찬가지로, 이 함수는 다음 [CREATE TABLE](https://dev.mysql.com/doc/refman/9.5/en/create-table.html "15.1.24 CREATE TABLE Statement)에 보이는 것처럼 VARCHAR 또는 TEXT 열의 기본값으로 사용될 수 있습니다:

1CREATE TABLE t (c VARCHAR(288) DEFAULT (SESSION_USER()));

• SYSTEM_USER()

SYSTEM_USER()는 USER()의 동의어입니다.

참고

SYSTEM_USER() 함수는 SYSTEM_USER 권한과 구별됩니다. 전자는 현재 MySQL 계정 이름을 반환합니다. 후자는 시스템 사용자와 일반 사용자 계정 카테고리를 구분합니다(Section 8.2.11, “Account Categories” 참조).

USER()와 마찬가지로, 이 함수는 다음 [CREATE TABLE](https://dev.mysql.com/doc/refman/9.5/en/create-table.html "15.1.24 CREATE TABLE Statement)에 보이는 것처럼 VARCHAR 또는 TEXT 열의 기본값으로 사용될 수 있습니다:

1CREATE TABLE t (c VARCHAR(288) DEFAULT (SYSTEM_USER()));

• USER()

현재 MySQL 사용자 이름과 호스트 이름을 utf8mb3 문자 집합의 문자열으로 반환합니다.

1mysql> SELECT USER();
2          -> 'davida@localhost'

이 값은 서버에 연결할 때 지정한 사용자 이름과 연결을 수행한 클라이언트 호스트를 나타냅니다. 이 값은 CURRENT_USER()의 값과 다를 수 있습니다.

이 함수는 다음 [CREATE TABLE](https://dev.mysql.com/doc/refman/9.5/en/create-table.html "15.1.24 CREATE TABLE Statement)에 보이는 것처럼 VARCHAR 또는 TEXT 열의 기본값으로 사용될 수 있습니다:

1CREATE TABLE t (c VARCHAR(288) DEFAULT (USER()));

• VERSION()

MySQL 서버 버전을 나타내는 문자열을 반환합니다. 이 문자열은 utf8mb3 문자 집합을 사용합니다. 값에는 버전 번호 외에 접미사가 추가로 붙을 수 있습니다. version 시스템 변수에 대한 설명은 Section 7.1.8, “Server System Variables”를 참조하십시오.

이 함수는 statement 기반 복제에 대해 안전하지 않습니다. binlog_format이 STATEMENT로 설정된 상태에서 이 함수를 사용하면 warning이 로그에 기록됩니다.

1mysql> SELECT VERSION();
2          -> '9.5.0-standard'