MySQL5.6 정보 함수

12.14 정보 함수

표 12.18 정보 함수

이름	설명
`BENCHMARK ()`	식을 반복합니다
`CHARSET ()`	인수의 캐릭터 세트를 돌려줍니다
`COERCIBILITY ()`	문자열 인수의 데이터 정렬 강제성 값을 반환합니다
`COLLATION ()`	문자열 인수의 데이터 정렬을 반환합니다
`CONNECTION_ID ()`	연결을위한 연결 ID (쓰레드 ID)를 반환합니다
`CURRENT_USER()` , `CURRENT_USER`	인증 된 사용자 이름과 호스트 이름
`DATABASE ()`	디폴트 (현재) 데이터베이스 명을 돌려줍니다
`FOUND_ROWS ()`	LIMIT 절있는 SELECT는 LIMIT 절이 없으면 리턴 될 수있는 행의 수입니다
`LAST_INSERT_ID ()`	이전의 INSERT에서 AUTOINCREMENT 컬럼의 값입니다
`ROW_COUNT ()`	업데이트 된 행 수
`SCHEMA ()`	DATABASE ()의 동의어입니다
`SESSION_USER ()`	USER ()의 동의어입니다
`SYSTEM_USER ()`	USER ()의 동의어입니다
`USER ()`	사용자 이름 및 클라이언트에 의해 제공되는 호스트 이름입니다
`VERSION ()`	MySQL 서버의 버전을 나타내는 문자열을 반환합니다

BENCHMARK ( count , expr )

BENCHMARK() 함수는 수식 expr 를 count 횟수만큼 반복 실행합니다. MySQL에 의한 식의 처리 속도를 측정하는 데 사용되는 경우도 있습니다. 결과 값은 항상 0 입니다. 이 사용 목적은 mysql 클라이언트 내에서 쿼리 실행 시간을보고하는 것입니다.
```
mysql> SELECT BENCHMARK(1000000,ENCODE('hello','goodbye'));
+----------------------------------------------+
| BENCHMARK(1000000,ENCODE('hello','goodbye')) |
+----------------------------------------------+
|                                            0 |
+----------------------------------------------+
1 row in set (4.74 sec)
```
보고되는 시간은 클라이언트 측의 경과 시간이며, 서버 측의 CPU 시간이 없습니다. BENCHMARK() 을 여러 번 실행 서버 시스템의 부하량에 대한 결과를 해석하는 것이 좋습니다.

BENCHMARK() 의 목적은 스칼라 식의 런타임 성능을 측정하는 것입니다. 그러면 그 사용 방법 및 결과의 해석 방법 중요한 몇 가지 추측이 제공됩니다.
- 스칼라 식 밖에 사용할 수 없습니다. 식을 서브 쿼리 할 수 있지만 단일 컬럼 및 최대조차도 행을 반환해야합니다. 예를 들어, 테이블 t 에 여러 컬럼과 여러 행이 포함되어 있으면 BENCHMARK(10, (SELECT * FROM t)) 는 실패합니다.
- SELECT expr 문을 N 번 수행하는 경우와 SELECT BENCHMARK( N , expr ) 를 실행하는 경우와는 오버 헤드의 양이 다릅니다. 이 둘은 매우 다른 실행 프로파일을 가지고 있기 때문에 양자의 소요 시간은 동일해야합니다. 전자는 파서 최적화 테이블 잠금 및 런타임 평가가 각각 N 번씩 발생합니다. 후자는 실행시 평가 만 N 번 발생하고 다른 모든 구성 요소는 한 번만 발생합니다. 할당 된 메모리 구조는 재사용 된 집계 함수에서 평가 된 결과를 로컬 캐시 등의 실행시 최적화에 의해 결과가 바뀔 가능성도 있습니다. 따라서 BENCHMARK() 를 사용하여 런타임 구성 요소에 높은 가중치를 부가하여 네트워크 파서 최적화 등으로 도입 된 "노이즈"를 제거하는 것으로, 그 구성 요소의 성능을 측정됩니다.

CHARSET ( str )

문자열 인수의 캐릭터 세트를 돌려줍니다.

 mysql> SELECT CHARSET('abc');
         -> 'latin1'
 mysql> SELECT CHARSET(CONVERT('abc' USING utf8));
         -> 'utf8'
 mysql> SELECT CHARSET(USER());
         -> 'utf8'

COERCIBILITY ( str )

문자열 인수의 데이터 정렬 강제성 값을 반환합니다.

 mysql> SELECT COERCIBILITY('abc' COLLATE latin1_swedish_ci);
         -> 0
 mysql> SELECT COERCIBILITY(USER());
         -> 3
 mysql> SELECT COERCIBILITY('abc');
         -> 4

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

형식 변환 특성	의미	예
`0`	명시적인 데이터 정렬	`COLLATE` 절 값
`1`	데이터 정렬 없음	다양한 데이터 정렬의 문자열 연결
`2`	암시 적 데이터 정렬	컬럼 값 스토어드 루틴 파라미터 또는 로컬 변수
`3`	계통 상수	`USER()` 의 반환 값
`4`	형식 변환 가능	리터럴 문자열
`5`	무시 가능	`NULL` 또는 `NULL` 에서 파생 된 식

COLLATION ( str )

문자열 인수의 데이터 정렬을 반환합니다.

 mysql> SELECT COLLATION('abc');
         -> 'latin1_swedish_ci'
 mysql> SELECT COLLATION(_utf8'abc');
         -> 'utf8_general_ci'

CONNECTION_ID ()

연결의 연결 ID (쓰레드 ID)를 반환합니다. 모든 연결은 현재 연결되어있는 클라이언트의 세트에서 고유 ID를 가지고 있습니다.

CONNECTION_ID() 에서 반환되는 값의 형태는 INFORMATION_SCHEMA.PROCESSLIST 테이블의 ID 컬럼, SHOW PROCESSLIST 출력의 Id 컬럼 및 성능 스키마 threads 테이블 PROCESSLIST_ID 컬럼에 표시된 값과 동일합니다.
```
 mysql> SELECT CONNECTION_ID();
         -> 23786
```
CURRENT_USER , CURRENT_USER()

현재의 클라이언트를 인증 할 때 서버에서 사용 된 MySQL 계정을 나타내는 사용자 이름과 호스트 이름의 조합을 리턴합니다. 이 계정에 액세스 권한을 결정합니다. 반환 값은 utf8 문자 집합의 문자열입니다.

CURRENT_USER() 의 값은 USER() 의 값과는 다를 수 있습니다.
```
 mysql> SELECT USER();
         -> 'davida @ localhost'
 mysql> SELECT * FROM mysql.user;
 ERROR 1044 : Access denied for user ''@ 'localhost'to
 database 'mysql'
 mysql> SELECT CURRENT_USER();
         -> '@localhost'
```
이 예제는 클라이언트가 davida 의 사용자 이름 ( USER() 함수의 값으로 지정됩니다)했지만, 서버는 익명의 사용자 계정 ( CURRENT_USER() 값의 빈 사용자 이름 부분에 표시됩니다)를 사용하여 클라이언트를 인증하는 것을 보여줍니다. 이것이 발생하는 원인으로 davida 부여 테이블에 계정이 나열되지 않은 것일 수 있습니다.

저장 프로그램 또는 뷰는 SQL SECURITY INVOKER 특성에 정의되어 있지 않으면, CURRENT_USER() 는 객체를 정의한 사용자 (그 DEFINER 값으로 지정됩니다) 계정을 반환합니다. 후자의 경우, CURRENT_USER() 는 객체를 호출 한 사용자를 반환합니다.

트리거 및 이벤트는 SQL SECURITY 특성을 정의하는 옵션이 없습니다. 따라서 이러한 객체의 경우, CURRENT_USER() 는 객체를 정의한 사용자 계정을 반환합니다. 호출 한 사용자를 반환하려면 USER() 또는 SESSION_USER() 를 사용합니다.

다음 문은 영향을받는 사용자 나 정의 된 사용자 이름 (호스트 가능성도 있습니다) 대신 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() 의 확장이 다양한 MySQL 5.6 릴리즈 복제에 갖는 의미에 대해서는 섹션 17.4.1.7 "CURRENT_USER () 복제" 를 참조하십시오.
DATABASE ()

디폴트 (현재) 데이터베이스 이름을 utf8 문자 집합의 문자열로 반환합니다. 기본 데이터베이스가없는 경우, DATABASE() 는 NULL 을 반환합니다. 스토어드 루틴 내에서는 기본 데이터베이스는 루틴이 연결된 데이터베이스이지만, 이것은 호출자의 컨텍스트에서 기본 데이터베이스와 동일하다고는 아닙니다.
```
 mysql> SELECT DATABASE();
         -> 'test'
```
기본 데이터베이스가없는 경우, DATABASE() 는 NULL 을 반환합니다.
FOUND_ROWS ()

서버에서 클라이언트에 반환되는 행의 수를 제한하기 위해 SELECT 문에 LIMIT 절이 포함되어있는 경우가 있습니다. 경우에 따라서는 문을 다시 실행하지 않고 LIMIT 를 붙여 않은 경우 문에서 반환되어야 할 행 수를 알아 두는 것이 바람직 수 있습니다. 이 행수를 취득하려면 SELECT 문에 SQL_CALC_FOUND_ROWS 옵션을 넣은 후 FOUND_ROWS() 를 호출합니다.
```
 mysql> SELECT SQL_CALC_FOUND_ROWS * FROM tbl_name
     -> WHERE id > 100 LIMIT 10;
 mysql> SELECT FOUND_ROWS();
```
두 번째 SELECT 는 첫 번째 SELECT 을 LIMIT 절없이 기술 한 경우 반환되는 행 수를 나타내는 숫자를 반환합니다.

최근 성공한 SELECT 문에 SQL_CALC_FOUND_ROWS 옵션을 붙이지 않으면, FOUND_ROWS() 는 그 문에서 반환 된 결과 집합의 행 수를 반환합니다. 문에 LIMIT 절이 포함되어있는 경우 FOUND_ROWS() 는 그 한계 이하의 행수를 돌려줍니다. 예를 들어, 문에 LIMIT 10 또는 LIMIT 50, 10 이 포함되어있는 경우, FOUND_ROWS() 는 각각 10과 60를 반환합니다.

FOUND_ROWS() 에서 얻을 수있는 행수는 일시적인 것으로, SELECT SQL_CALC_FOUND_ROWS 명령문 다음에이 문을 실행해도 얻을 수 있도록 설계되어 있지 않습니다. 나중에 값을 참조 할 필요가있는 경우 저장하십시오.
```
 mysql> SELECT SQL_CALC_FOUND_ROWS * FROM ... ;
 mysql> SET @rows = FOUND_ROWS();
```
SELECT SQL_CALC_FOUND_ROWS 를 사용하는 경우, MySQL 그럼 완전한 결과 세트의 행 수를 계산해야합니다. 그러나 결과 세트는 클라이언트로 전송 될 필요가 없기 때문에 LIMIT 없이 쿼리를 다시 실행하는 것보다 빨라집니다.

SQL_CALC_FOUND_ROWS 및 FOUND_ROWS() 는 쿼리에서 반환되는 행 수를 제한하지만 쿼리를 다시 실행하지 않고 전체 결과 집합의 행 수를 확인해야하는 상황에서도 도움이됩니다. 예를 들어, 검색 결과의 다른 섹션을 표시하는 페이지에 대한 링크가 포함 된 페이지가 나타날 Web 스크립트가 있습니다. FOUND_ROWS() 를 사용하면 나머지 결과를 표시하는 데 필요한 추가 페이지 수를 확인할 수 있습니다.

SQL_CALC_FOUND_ROWS 및 FOUND_ROWS() 를 사용하면 UNION 내의 여러 곳에서 LIMIT 가 발생할 수 있기 때문에 간단한 SELECT 문보다 UNION 문에서 사용하는 것이 복잡해집니다. 이것은 UNION 의 개별 SELECT 문에 적용되는 경우와 UNION 의 결과에 글로벌하게 적용되는 경우가 있습니다.

UNION 에서 SQL_CALC_FOUND_ROWS 를 사용하는 목적은 글로벌 LIMIT 없이 반환 된 행 수를 반환합니다. UNION 에서 SQL_CALC_FOUND_ROWS 를 사용하는 조건은 다음과 같습니다.
- UNION 의 첫 번째 SELECT 에 SQL_CALC_FOUND_ROWS 키워드가 표시되어야합니다.
- FOUND_ROWS() 의 값은 UNION ALL 이 사용되는 경우에만 정확합니다. ALL 없이 UNION 이 사용되는 경우, 중복 제거가 발생하고 FOUND_ROWS() 의 값이 단순한 근사치입니다.
- UNION 에서 LIMIT 가 표시되지 않는 경우, SQL_CALC_FOUND_ROWS 은 무시되고 UNION 을 처리하기 위해 만든 임시 테이블의 행 수를 반환합니다.
여기에 설명 된 이외의 경우에는 FOUND_ROWS() 의 동작 (오류가 발생하고 SELECT 문에 실패한 뒤의 값 등)가 정의되지 않습니다.
중요
문 기반 복제는 확실히 FOUND_ROWS() 를 복제 할 수 없습니다. 행 기반 복제를 사용하면이 함수는 자동으로 복제됩니다.
LAST_INSERT_ID() , LAST_INSERT_ID( expr )

LAST_INSERT_ID() 에 인수를 붙이지 않는 경우는 최근에 실행 된 INSERT 문의 결과로 먼저 자동으로 생성되어 성공적으로 AUTO_INCREMENT 컬럼에 삽입 된 값을 나타내는 64 비트 값이 반환됩니다. 이 값의 형식은 MySQL 5.6.9의 시점에서는 BIGINT UNSIGNED , 그 이전에는 BIGINT (부호)입니다. 성공적으로 삽입 된 행이없는 경우는 LAST_INSERT_ID() 의 값은 변경되지 않은 상태입니다.

LAST_INSERT_ID() 에 인수를 붙이지 않는 경우는 MySQL 5.6.9의 시점에서는 부호없는 정수 그보다 앞에서는 부호있는 정수를 반환합니다.

예를 들어, AUTO_INCREMENT 값을 생성하는 행을 삽입 한 후에는 다음과 같이 값을 얻을 수 있습니다.
```
 mysql> SELECT LAST_INSERT_ID();
         -> 195
```
현재 실행중인 문은 LAST_INSERT_ID() 의 값은 영향을받지 않습니다. 하나의 문에서 AUTO_INCREMENT 값을 생성하고 자신의 AUTO_INCREMENT 컬럼을 포함하는 테이블에 행을 삽입하는 복 수행의 INSERT 문에서 LAST_INSERT_ID() 를 참조한다고 가정합니다. LAST_INSERT_ID() 값은 두 번째 문에서 변경되지 않은 상태입니다. 2 번째 이후의 행에서도 그 값은 이전에 행해진 행 삽입에 의한 영향을받지 않습니다. (단, LAST_INSERT_ID() 와 LAST_INSERT_ID( expr ) 에 대한 참조를 혼합하면 효과는 정의되지 않습니다.)

이전 문에서 오류가 반환 된 경우, LAST_INSERT_ID() 의 값이 정의되지 않습니다. 트랜잭션 테이블에서 오류로 문이 롤백되는 경우, LAST_INSERT_ID() 의 값은 정의되지 않은 상태입니다. 수동 ROLLBACK 은 LAST_INSERT_ID() 의 값은 트랜잭션 이전 값으로 복원되지 않고 ROLLBACK 시점과 동일합니다.

MySQL 5.6.15 이전에서는 복제 필터링 규칙이 사용되는 경우,이 함수가 성공적으로 복제되지 않았습니다. (Bug # 17234370, Bug # 69861)

스토어드 루틴 (프로 시저 및 함수) 또는 트리거의 본문은 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 문을 사용하여 여러 행을 삽입 할 경우 LAST_INSERT_ID() 는 처음에 삽입 된 행에 대해서만 생성 된 값을 반환합니다. 이 이유는, 다른 일부 서버에 대해 동일한 INSERT 문을 쉽게 재현 할 수있게하는 것입니다.
예 :
```
mysql> USE test;
Database changed
mysql> CREATE TABLE t (
    ->   id INT AUTO_INCREMENT NOT NULL PRIMARY KEY,
    ->   name VARCHAR(10) NOT NULL
    -> );
Query OK, 0 rows affected (0.09 sec)

mysql> INSERT INTO t VALUES (NULL, 'Bob');
Query OK, 1 row affected (0.01 sec)

mysql> SELECT * FROM t;
+----+------+
| id | name |
+----+------+
|  1 | Bob  |
+----+------+
1 row in set (0.01 sec)

mysql> SELECT LAST_INSERT_ID();
+------------------+
| LAST_INSERT_ID() |
+------------------+
|                1 |
+------------------+
1 row in set (0.00 sec)

mysql> INSERT INTO t VALUES
    -> (NULL, 'Mary'), (NULL, 'Jane'), (NULL, 'Lisa');
Query OK, 3 rows affected (0.00 sec)
Records: 3  Duplicates: 0  Warnings: 0

mysql> SELECT * FROM t;
+----+------+
| id | name |
+----+------+
|  1 | Bob  |
|  2 | Mary |
|  3 | Jane |
|  4 | Lisa |
+----+------+
4 rows in set (0.01 sec)

mysql> SELECT LAST_INSERT_ID();
+------------------+
| LAST_INSERT_ID() |
+------------------+
|                2 |
+------------------+
1 row in set (0.00 sec)
```
두 번째 INSERT 문에서 3 개의 새로운 행이 t 에 삽입되었지만 이러한 행의 첫 번째 생성 된 ID는 2 이며, 이후의 SELECT 문에서도이 값이 LAST_INSERT_ID() 에 의해 반환 됩니다.

INSERT IGNORE 를 사용하고 그 행이 무시 된 경우 LAST_INSERT_ID() 는 현재 값에서 변경되지 않은 상태입니다 (연결에서 정상적인 INSERT 가 실행되고 있지 않은 경우는 0을 반환합니다). 트랜잭션 이외의 테이블에서 AUTO_INCREMENT 카운터가 증가되지 않습니다. InnoDB 테이블에서는 innodb_autoinc_lock_mode 가 1 또는 2 로 설정되어있는 경우 다음의 예와 같이 AUTO_INCREMENT 가 증가됩니다.
```
mysql> USE test;
Database changed

mysql> SELECT @@innodb_autoinc_lock_mode;
+----------------------------+
| @@innodb_autoinc_lock_mode |
+----------------------------+
|                          1 |
+----------------------------+
1 row in set (0.00 sec)

mysql> CREATE TABLE `t` (
`id` INT(11) NOT NULL AUTO_INCREMENT,
`val` INT(11) DEFAULT NULL,
PRIMARY KEY (`id`),
UNIQUE KEY `i1` (`val`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;
Query OK, 0 rows affected (0.02 sec)

-- Insert two rows

mysql> INSERT INTO t (val) VALUES (1),(2);
Query OK, 2 rows affected (0.00 sec)
Records: 2  Duplicates: 0  Warnings: 0

-- With auto_increment_offset=1, the inserted rows
-- result in an AUTO_INCREMENT value of 3

mysql> SHOW CREATE TABLE t\G
*************************** 1. row ***************************
       Table: t
Create Table: CREATE TABLE `t` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `val` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`),
  UNIQUE KEY `i1` (`val`)
) ENGINE=MyISAM AUTO_INCREMENT=3 DEFAULT CHARSET=latin1
1 row in set (0.00 sec)

-- LAST_INSERT_ID() returns the first automatically generated 
-- value that is successfully inserted for the AUTO_INCREMENT column

mysql> SELECT LAST_INSERT_ID();
+------------------+
| LAST_INSERT_ID() |
+------------------+
|                1 |
+------------------+
1 row in set (0.00 sec)

-- The attempted insertion of duplicate rows fail but errors are ignored     

mysql> INSERT IGNORE INTO t (val) VALUES (1),(2);
Query OK, 0 rows affected (0.00 sec)
Records: 2  Duplicates: 2  Warnings: 0

-- With innodb_autoinc_lock_mode=1, the AUTO_INCREMENT counter 
-- is incremented for the ignored rows

mysql> SHOW CREATE TABLE t\G
*************************** 1. row ***************************
       Table: t
Create Table: CREATE TABLE `t` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `val` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`),
  UNIQUE KEY `i1` (`val`)
) ENGINE=MyISAM AUTO_INCREMENT=5 DEFAULT CHARSET=latin1
1 row in set (0.00 sec)

-- The LAST_INSERT_ID is unchanged becuase the previous insert was unsuccessful

mysql> SELECT LAST_INSERT_ID();
+------------------+
| LAST_INSERT_ID() |
+------------------+
|                1 |
+------------------+
1 row in set (0.00 sec)    
```
자세한 내용은 섹션 14.6.5 "InnoDB에서 AUTO_INCREMENT 처리" 를 참조하십시오.

expr 이 LAST_INSERT_ID() 에 인수로서 지정되는 경우, 그 인수의 값이 함수에 의해 반환되고 LAST_INSERT_ID() 에 의해 다음에 반환 된 값으로 기억됩니다. 이것을 사용하면 시퀀스의 시뮬레이션을 할 수 있습니다.
1. 시퀀스 카운터를 유지 테이블을 만들고 그것을 초기화합니다.
```
 mysql> CREATE TABLE sequence (id INT NOT NULL);
 mysql> INSERT INTO sequence VALUES (0);
```
2. 그 테이블을 사용하여 다음과 같이 일련 번호를 생성합니다.
```
 mysql> UPDATE sequence SET id=LAST_INSERT_ID(id+1);
 mysql> SELECT LAST_INSERT_ID();
```
  UPDATE 문은 시퀀스 카운터를 증가시키고 LAST_INSERT_ID() 에 대한 다음 호출에서 업데이트 된 값을 반환합니다. SELECT 문은 값을 가져옵니다. mysql_insert_id() C API 함수를 사용하여 값을 얻을 수 있습니다. 섹션 23.8.7.37 "mysql_insert_id ()" 를 참조하십시오.
LAST_INSERT_ID() 를 호출하지 않고 시퀀스를 생성 할 수 있습니다. 이처럼 함수를 사용하는 유용성은 ID 값이 마지막에 자동으로 생성 된 값으로 유지되는 것입니다. 자신의 시퀀스 값을 생성하는 다른 클라이언트와 상호 작용하도록하지 않고 여러 클라이언트가 UPDATE 문을 실행하고 SELECT 문 (또는 mysql_insert_id() )에서 자신의 순서 값을 얻을 수 있기 때문에 다중 사용자 안전 입니다.

mysql_insert_id() 함수는 INSERT 및 UPDATE 문 뒤에 만 업데이트되지 않기 때문에, SELECT 나 SET 등의 다른 SQL 문을 실행 한 후에이 C API 함수를 사용하여도 LAST_INSERT_ID( expr ) 의 값을 얻을 수 없습니다.
ROW_COUNT ()

MySQL 5.6에서는 ROW_COUNT() 는 다음과 같이 값을 반환합니다.
- DDL 문 : 0. 이것은 CREATE TABLE 이나 DROP TABLE 등의 문에 적용됩니다.
- SELECT 이외의 DML 문 : 영향을받는 행의 수입니다. 이것은 (이전과) UPDATE , INSERT , DELETE 등의 문에 적용되지만 ALTER TABLE 과 LOAD DATA INFILE 등의 문에도 적용되게되었습니다.
- SELECT : 문에서 결과 집합을 반환 할 경우는 -1, 그렇지 않은 경우는 "영향을받는 '행수. 예를 들어, SELECT * FROM t1 의 경우 ROW_COUNT() 는 -1을 돌려줍니다. SELECT * FROM t1 INTO OUTFILE ' file_name ' 의 경우 ROW_COUNT() 는 파일에 기록 된 행의 수를 돌려줍니다.
- SIGNAL 문 : 0.
UPDATE 문의 경우, 기본적으로 영향을받은 행의 값은 실제로 변경된 행의 수입니다. mysqld에 연결할 때 CLIENT_FOUND_ROWS 플래그를 mysql_real_connect() 에 지정된 경우, 영향을받은 행의 값은 '발견', 즉 WHERE 절에 일치하는 행의 수입니다.

REPLACE 문에 영향을받은 행의 값은 새로운 행이 이전 행으로 바뀐 경우 2입니다. 이 경우 중복이 제거 된 후에 행이 삽입 된 것입니다.

INSERT ... ON DUPLICATE KEY UPDATE 문의 경우, 각 행의 영향을받은 행의 값은 행이 새로운 행으로 삽입 된 경우는 1 기존의 행이 갱신 된 경우 2 기존의 행이 현재 값에 설정된 경우 0입니다. CLIENT_FOUND_ROWS 플래그를 지정하면 영향을받는 행의 값은 기존 행을 현재 값으로 설정된 경우 (0이 아닌) 1입니다.

ROW_COUNT() 는 mysql_affected_rows() C API 함수로부터 취득되는 값과 같고, 문 다음에 mysql 클라이언트에 표시되는 행 수입니다.
```
mysql> INSERT INTO t VALUES(1),(2),(3);
Query OK, 3 rows affected (0.00 sec)
Records: 3  Duplicates: 0  Warnings: 0

mysql> SELECT ROW_COUNT();
+-------------+
| ROW_COUNT() |
+-------------+
|           3 |
+-------------+
1 row in set (0.00 sec)

mysql> DELETE FROM t WHERE i IN(1,2);
Query OK, 2 rows affected (0.00 sec)

mysql> SELECT ROW_COUNT();
+-------------+
| ROW_COUNT() |
+-------------+
|           2 |
+-------------+
1 row in set (0.00 sec)
```
중요
문 기반 복제는 확실히 ROW_COUNT() 을 복제 할 수 없습니다. 행 기반 복제를 사용하면이 함수는 자동으로 복제됩니다.
SCHEMA ()

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

SESSION_USER() 은 USER() 의 동의어입니다.
SYSTEM_USER ()

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

현재의 MySQL 사용자 이름과 호스트 이름을 utf8 문자 집합의 문자열로 반환합니다.
```
 mysql> SELECT USER();
         -> 'davida @ localhost'
```
이 값은 서버에 연결할 때 지정한 사용자 이름과 연결하는 클라이언트 호스트를 나타냅니다. CURRENT_USER() 의 값과는 다를 수 있습니다.

다음과 같이 사용자 이름 부분 만 추출 할 수 있습니다.
```
 mysql> SELECT SUBSTRING_INDEX(USER(),'@',1);
         -> 'davida'
```
VERSION ()

MySQL 서버의 버전을 나타내는 문자열을 반환합니다. 이 문자열은 utf8 문자 세트가 사용됩니다. 값은 버전 번호 이외에 접미사가 붙어있는 경우도 있습니다. 섹션 5.1 "서버 시스템 변수" 에서 version 시스템 변수의 설명을 참조하십시오.

이 함수는 명령문 기반의 복제는 안전하게 사용할 수 없습니다. binlog_format 가 STATEMENT 로 설정되어있을 때이 함수를 사용하면 경고가 기록됩니다.
```
mysql> SELECT VERSION();
        -> '5.6.29-standard'
```