• MySQL매뉴얼
    • MySQL 5.6 매뉴얼
    • MySQL 5.1 매뉴얼
    • MySQL 5.0 매뉴얼
    • MySQL HA 매뉴얼
  • 기술문서
    • Xtrabackup 구성
    • 메모리 사용량 모니터링
  • 라이선스
  • 온라인문의
  • 회사소개
  • → 목 록 (MySQL5.6 한글메뉴얼) [close]
  • 1. MySQL 5.6 새로운 기능
  • 2. MySQL 설치 및 업그레이드
  • 3. MySQL Tutorial
  • 4. MySQL 프로그램
  • 5. MySQL 서버관리
  • 6. 보안
  • 7. 백업 및 복구
  • 8. 최적화
  • 9. Language Structure(언어구조)
  • 10. Character Sets(Globalization)
  • 11. 데이터형(Data Types)
  • 12. 함수와 연산자
  • 1. 함수와 연산자 참조
    2. 식 평가 형식 변환
    3. 연산자
    4. 제어 흐름 함수
    5. 문자열 함수
    6. 수치 함수와 연산자
    7. 날짜 및 시간 함수
    8. MySQL에서 사용되는 달력
    9. Full-Text 검색 기능
    10. 캐스트 함수와 연산자
    11. XML 함수
    12. 비트 함수
    13. 암호화 함수와 압축 함수
    14. 정보 함수
    15. 공간 분석 함수
    16. 글로벌 트랜잭션 ID와 함께 사용되는 함수
    17. MySQL Enterprise Encryption 기능
    18. 기타 함수
    19. GROUP BY 절에서 사용되는 함수와 수식
    20. 정밀 계산
  • 13. SQL 문법
  • 14. InnoDB 스토리지 엔진
  • 15. 기타 스토리지 엔진
  • 16. 고가용성 및 확장성
  • 17. 리플리케이션
  • 18. MySQL Cluster
  • 19. 파티셔닝
  • 20. Stored Programs and Views
  • 21. INFORMATION_SCHEMA
  • 22. PERFORMANCE SCHEMA
  • 23. 컨넥터 및 API
  • 24. MySQL 확장
  • 25. MySQL Enterprise Edition
  • 26. MySQL Workbench
  • 27. 제약 및 제한
  • 28. MySQL 5.7 새로운 기능

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'
    


서울시 강남구 영동대로 602 6층
TEL: 02-6061-0006  /  E: csr@mysqlkorea.com
주식회사 이노클러스터  등록번호 : 727-86-02261
Copyright © innocluster Co. ltd. all rights reserved