|
## 원본 : mysql 3.21 Reference Manual PostScript 매뉴얼
(현재 최신 매뉴얼은 3.22 레퍼런스 매뉴얼이며 3.22.14b-gamma입니다.)
5, 6, 9, 10, 11, 12, 13, 15, 17, 18장 번역 : 문태준(taejun@hitel.net)
18장 중 C-API 부분 번역 : 권용찬 (golmong@cre.co.kr)
이메일 : taejun@hitel.net, taejun@taejun.pe.kr
웹 : http://taejun.pe.kr (Mysql 관련 자료가 모아져 있습니다)
자료를 공유하기 편하도록 홈페이지를 열었습니다.
많이 애용해주시면 감사~하겠습니다.
개인적인 질문은 각 통신망의 리눅스 동호회나 인터넷을 참고하세요.
**로 묶인 것은 제가 주를 단 것입니다.
설치와 관련된 부분은 kldp.org의 database 항목에서 관련된 정보가 있으므로 참고하시면 됩니다.
0. 목차
1. MySQL 일반 정보
2. MySQL 메일링 리스트 및 질문 요청 방법, 에러(버그) 알리기
3. 라이센싱 / mysql에 지불해야 할 경우
4. mysql 설치
5. mysql의 표준 호환성
6. mysql 접근 권한 시스템
7. mysql 언어 레퍼런스
8. SQL 질의 예제
9. mysql 서버 기능
10. mysql의 최대 성능 향상 방법
11. mysql 벤치마크
12. mysql 유틸리티
13. 테이블 유지보수 및 파손 복구에 isamchk 사용하기
14. mysql에 새로운 기능 추가
15. mysql ODBC 지원
16. 일반적인 문제 및 에러
17. 일반적인 문제 해결 방법
18. mysql 클라이언트 툴과 API
19. 다른 데이터베이스와 비교
부록 A ; MYSQL 사용자
부록 B ; 개발 프로그램
부록 C ;MYSQL 개발자
부록 D ; MYSQL 버전업 역사
부록 E ; MYSQL의 알려진 에러 및 설계에서 부족한 부분
부록 F ; MYSQL에 장래 추가할내용(The TODO)
부록 G ; 다른 시스템에 포팅하기
부록 H ; MYSQL 정규표현식 설명
부록 I ; Unireg 설명
부록 J ; 비MS 운영체제에서 MYSQL 서버 라이센스
부록 K ; MS 운영체제에서 MYSQL 라이센스
SQL 명령, 타입, 함수 인덱스
개념 인덱스
1. MySQL 일반 정보
1.1 MYSQL은 무엇인가?
1.2 매뉴얼에 관하여
1.2.1 매뉴얼에서 쓰인 규정
1.3 MYSQL 역사
1.4 주요특징
1.5 안정성
1.6 2000년 문제
1.7 일반적인 SQL 정보 및 참고자료
1.8 관련 링크
2. MySQL 메일링 리스트 및 질문 요청 방법, 에러(버그) 알리기
2.1 mysql 메일링 리스트
2.2 질문하기, 버그 알리기
2.3 버그나 문제를 알리는 방법
2.3.1 mysql이 손상되었을때
2.4 메일링리스트에서 질문 답변에 대한 안내
3. 라이센싱 / mysql에 지불해야 할 경우
3.1 mysql 비용
3.2 상업적인 지원 방는 방법
3.2.1 기본 이메일 지원
3.2.2 확장 이메일 지원
3.2.3 login 지원
3.2.4 확장 login 지원
3.3 라이센싱이나 지원에 지불하는 방법
3.4 라이센싱/지원 관련 정보 담당자
3.5 사용자 저작권 관련
3.6 mysql에 요금을 내지 않고 상업적으로 판매하는 경우
3.7 mysql을 사용해야 설정할 수 있는 제품을 판매하는 경우
3.8 mysql을 사용하여 상업적인 웹 서버를 운영하는 경우
3.9 상업용 Perl/Tcl/PHP/기타 애플리케이션을 판매하는 경우
3.10 앞으로의 라이센싱 변화
4. mysql 설치
4.1 mysql 구하기
4.2 mysql에서 지원하는 운영체제
4.3 사용할 수 있는 mysql 버전
4.4 업데이트 방법 및 시기
4.5 설치 개괄
4.6 바이너리로 설치하기
4.6.1 클라이언트 프로그램 만들기
4.6.2 시스템 관련 참고사항
4.6.2.1 리눅스
4.6.2.2 HP-UX
4.7 소스로 설치하기
4.7.1 빠른 설치
4.7.2 패치 적용하기
4.7.3 일반 설정 옵션
4.8 컴파일에서 문제점이 생길때
4.9 MIT-pthreads 주의사항
4.10 펄 설치
4.10.1 펄 DBI/DBD 인터페이스 사용시 문제점
4.11 시스템 관련 참고사항
-솔라리스, 솔라리스 x86, 선OS4, 알파-DEC-유닉스, 알파-DEC-OSF1,
SGI-IRIX, FreeBSD, BSD/OS 2, SCO, SCO Unixware 7.0, IBM-AIX, HP-UX
-리눅스 : 리눅스-x86, 레드햇 5.0/5.1, 리눅스-스팍,리눅스-알파,MkLinux
리눅스 RPM
4.12 TcX 바이너리
4.13 Win32 관련사항
4.14 설치후 셋업 및 테스트
4.14.1 mysql_install_db 실행시 문제점
4.14.2 mysql 서버 실행시 문제점
4.14.3 자동 시작/정지 시키기
4.14.5 옵션 파일
4.15 업그레이드/다운그레이드할때의 주의사항
4.15.1 3.21에서 3.22로 업그레이드
4.15.2 3.20에서 3.21로 업그레이드
4.15.3 다른 아키텍쳐로 업그레이드
5. mysql의 표준 호환성
5.1 mysql의 ANSI SQL92 확장 부분
5.2 mysql에서 빠진 기능
5.2.1 sub-selects
5.2.2 SELECT INTO TABLE
5.2.3 트랜잭션
5.2.4 저장 프로시져/트리거
5.2.5 외래키
5.2.5.1 외래키 사용하지 않는 이유
5.2.6 뷰
5.2.7 '--' 로 주석문 시작
5.3 mysql에서 따르고 있는 표준
5.4 BLOB/TEXT 타입의 제한사항
5.5 COMMIT-ROLLBACK 없이 사용하는 방법
6. mysql 접근 권한 시스템
6.1 접근 권한 시스템이란 무엇인가
6.2 mysql 서버에 연결하기
6.2.1 비밀번호를 안전하게 유지하기
6.3 mysql에서 제공하는 권한
6.4 권한 시스템 작동 방식
6.5 접근 제어 1 : 연걸 인증
6.6 접근 제어 2 : 요청 인증
6.7 권한변경시 적용 방법
6.8 초기 mysql 권한 설정
6.9mysql에 새로운 사용자 권한 추가
6.10 비밀번호 설정 방법
6.11 접근 금지 에러가 나는 이유
6.12 크랙커에 대비하여 mysql을 안전하게 만드는 방법
7. mysql 언어 레퍼런스
7.1 문자 : 문자열과 숫자 기록하기
7.1.1 문자열
7.1.2 숫자
7.1.3 NULL 값
7.1.4 데이터베이스, 테이블, 인덱스, 컬럼, 알리아스 이름
7.1.4.1 이름에서 대소문자 구별
7.2 컬럼 타입
7.2.1 컬럼 타입 저장 요구량
7.2.2 숫자 타입
7.2.3 날짜/시간 타입
7.2.3.1 DATETIME, DATE, TIMESTAMP 타입
7.2.3.2 TIME 타입
7.2.3.3 YEAR 타입
7.2.4 문자열 타입
7.2.4.1 CHAR, VARCHAR 타입
7.2.4.2 BLOB, TEXT 타입
7.2.4.3 ENUM 타입
7.2.4.4 SET 타입
7.2.5 컬럼에 적절한 타입 고르기
7.2.6 컬럼 인덱스
7.2.7 다중 컬럼 인덱스
7.2.8 다른 데이터베이스 엔진의 컬럼 타입 사용
7.3 SELECT 와 WHERE 문에서의 함수(functions)
7.3.1 그룹(Group)으로 묶는 기능
7.3.2 산술연산자
7.3.3 비트(Bit) 함수
7.3.4 논리(logical) 연산자
7.3.5 비교 연산자
7.3.6 문자열 비교 함수
7.3.7 흐름 제어(control flow) 함수
7.3.8 산술 함수
7.3.9 문자열 함수
7.3.10 날짜/시간 함수
7.3.11 기타 함수
7.3.12 GROUP BY 문에서 사용하는 함수
7.4 CREATE DATABASE
7.5 DROP DATABASE
7.6 CREATE DATABASE
7.6.1 자동 컬럼 변환
7.7 ALTER TABLE
7.8 OPTIMIZE TABLE
7.9 DROP TABLE
7.10 DELETE
7.11 SELECT
7.12 JOIN
7.13 INSERT
7.14 REPLACE
7.15 LOAD DATA INFILE
7.16 UPDATE
7.17 USE
7.18 FLUSH(캐쉬 삭제)
7.19 KILL
7.20 SHOW(테이블, 컬럼 정보 얻기)
7.21 EXPLAIN(SELECT 관련 정보 얻기)
7.22 DESCRIBE(컬럼 정보 얻기)
7.23 LOCAK TABLES/UNLOCK TABLES
7.24 SET OPTION
7.25 GRANT / REVOKE
7.26 CREATE INDEX(호환성 기능)
7.27 DROP INDEX(호환성 기능)
7.28 주석
7.29 CREATE FUNCTION/DROP FUNCION
7.30 예약된 문자 사용하는 경우
8. SQL 질의 예제
8.1 twin project에서의 질의
8.1.1 Find all non-distributed twins
8.1.2 Show a table on twin pair status
9. mysql 서버 기능
9.1 mysql에서 지원하는 언어
9.1.1 데이터와 정열에 사용하는 문자 셋
9.1.2 새로운 문자셋 추가
9.1.3 멀티바이트 문자 지원
9.2 업데이트 로그
9.3 mysql 테이블 최대 크기
10. mysql의 최대 성능 향상 방법
10.1 버퍼 크기 조정
10.2 메모리 상용 방법
10.3 속도 향상에 영향을 미치는 컴파일/링크 방법
10.4 인덱스 사용방법
10.5 WHERE 문에서 최적화하기
10.6 테이블 열고 닫는 방법
10.6.1 데이터베이스에서 많은 수의 테이블을 만들때의 단점
10.7 많은 테이블을 여는 이유
10.8 데이터베이스와 테이블에서 심볼링 링크 사용
10.9 테이블에 락 거는 방법
10.10 테이블을 빠르고 작게 배열하는 방법
10.11 INSERT 문에서 속도에 영향을 미치는 부분
10.12 DELETE 문에서 속도에 영향을 미치는 부분
10.13 mysql에서 최대 속도를 얻는 방법
10.14 로우 포맷과 다른 점은 무엇인가? 언제 VARCHAR/CHAR을 사용해야 하는가?
11. mysql 벤치마크
12. mysql 유틸리티
12.1 서로 다른 mysql 프로그램 개괄
12.2 텍스트 파일에서 데이터 가져오기
12.3 mysql 압축 읽기 전용 테이블 생성기
13. 테이블 유지보수 및 파손 복구에 isamchk 사용하기
13.1 isamchk 명령어 사용법
13.2 isamchk 메모리 사용법
13.3 테이블 유지보수 설정
13.4 테이블에서 정보 얻기
13.5 파손 복구에 isamchk 사용하기
13.5.1 에러가 났을때 테이블 점검 방법
13.5.2 테이블 복구 방법
13.5.3 테이블 최적화하기
14. mysql에 새로운 기능 추가
14.1 새로운 사용자 정의 기능 추가
14.1.1 UDF calling sequences
14.1.2 Argument processing
14.1.3 Return values and error handling
14.1.4 사용자 정의 기능 컴파일 및 설치하기
14.2 새로운 native 기능 추가
15. mysql ODBC 지원
15.1 MyODBC가 지원하는 운영체제
15.2 MyODBC에 문제가 있을때
15.3 MyODBC와 작동하는 프로그램
15.4 ODBC 관리자 프로그램 설정 방법
15.5 ODBC에서 AUTO_INCREMENT 컬럼의 값 가져오기
16. 일반적인 문제 및 에러
16.1 mysql 사용시 일반적인 에러
16.1.1 mysql 서버가 맛이 간 경우
16.1.2 local mysql 서버에 접속이 안되는 경우
16.1.3 Host '...' is blocked 에러
16.1.4 Out of Memory 에러
16.1.5 Packet too large 에러
16.1.6 The table is full 에러
16.1.7 Commands out of sync 에러(클라이언트)
16.1.8 Ignoring user 에러
16.1.9 Table 'xxx' doesn't exist 에러
16.2 mysql에서 디스크가 꽉 찼을때
16.3 텍스트 파일에서 SQL 문장 실행하기
16.4 mysql에서 임시 파일을 저장하는 곳
16.5 /tmp/mysql.sock을 지워지지 않도록 보호하는 방법
16.6 Access denied 에러
16.7 일반 사용자로 mysql 실행하기
16.8 파일 퍼미션 문제
16.9 File not found
16.10 DATE 컬럼 사용할때 문제
16.11 검색에서 대소문자 구별
16.12 NULL 값에서 문제
16.13 alias에서 문제
16.14 관련된 테이블에서 레코드를 지웠을때
16.15 해당하는 레코드가 없을때 문제 해결
16.16 ALTER TABLE 에서 문제
17. 일반적인 문제 해결 방법
17.1 데이터베이스 복사
17.2 데이터베이스 백업
17.3 같은 머신에서 여러개의 mysql 서버 실행하기
18. mysql 클라이언트 툴과 API
18.1 mysql C API
18.2 C API 테이타타입
18.3 C API 함수 개괄
18.4 C API 함수 설명
**생략**
18.4.47 mysql_query()가 성공했는데도 mysql_store_result()
가 NULL을 반환하는 경우
18.4.48 질의에서 결과 얻는 방법
18.4.49 마지막으로 입력된 unique ID 얻는 방법
18.4.50 C API와 링크할때 문제점
18.4.51 thread-safe 클라이언트 만들기
18.5 mysql perl API
18.5.1 DBI with DBD :: mysql
18.5.1.1 dbi 인터페이스
18.5.1.2 DBI/DBD 추가 정보
18.6MYSQL 자바 연결(JDBC)
18.7 mysql PHP API
18.8 MYSQL C++ API
18.9 mysql Python API
18.10 Mysql TCL API
19. 다른 데이터베이스와 비교
19.1 mSQL과의 비교
19.1.1 mSQL 툴을 mysql로 옮기기
19.1.2 msql과 mysql 클라이언트/서버 통신 프로토콜의 차이점
19.1.3 msql 2.0과 mysql의 SQL 문 차이점
19.2 PostgreSQL과의 비교
부록 A ; MYSQL 사용자
부록 B ; 개발 프로그램
부록 C ;MYSQL 개발자
부록 D ; MYSQL 버전업 역사
부록 E ; MYSQL의 알려진 에러 및 설계에서 부족한 부분
부록 F ; MYSQL에 장래 추가할내용(The TODO)
부록 G ; 다른 시스템에 포팅하기
부록 H ; MYSQL 정규표현식 설명
부록 I ; Unireg 설명
부록 J ; 비MS 운영체제에서 MYSQL 서버 라이센스
부록 K ; MS 운영체제에서 MYSQL 라이센스
SQL 명령, 타입, 함수 인덱스
개념 인덱스
5. mysql의 표준 호환성
5.1 mysql의 ANSI SQL92 확장부분
mysql에는 다른 sql 데이터베이스에서 찾을 수 없는 확장된 부분이 있다. 이런 부분을 사용
하는 경우 주의해야 한다. 왜냐면 mysql에서 사용한 코드가 다른 SQL 서버에 포팅할 수
없을 수도 있기 때문이다. 어떤 경우에는 /*! ... */ 형식의 주석문을 사용한 MYSQL 확장을
이용해 포팅가능한 코드를 만들 수 있다. 예를 들어보자:
SELECT /*! STRAIGHT_JOIN */ col_name from table1,table2 WHERE ...
MYSQL의 확장 부분은 다음과 같다:
- 필드타입 MEDIUMINT, SET, ENUM , 그리고 다른 BLOB 와 TEXT 타입.
- 필드속성 AUTO_INCREMENT, BINARY, UNSIGNED and ZEROFILL.
- 모든 문자열 비교는 기본적으로 대소문자를 구별하지 않으며 현재의 문자셋(기본적으로
ISO-8859-1 Latin1)에 의해 정렬 순서가 결정된다. 이것을 원하지 않으면 컬럼을 BINARY
속성으로 정의해야 하며 이런 경우에는 mysql 서버 호스트가 사용하는 ASCII 순서에 따라
문자열을 비교한다.
- MYSQL은 데이터베이스를 디렉토리로 만들고 테이블은 파일이름으로 만든다. 이것은 두
가지를 함축하고 있다:
ㅇ 파일이름의 대소문자를 구별하는 (대부분의 유닉스 시스템. 리눅스도 마찬가지겠지
용~) 운영 시스템에서는 MYSQL의 데이터베이스 이름과 테이블 이름은 대소문자를
구별한다. 테이블 이름을 기억하는데 문제가 있다면 모든 것을 소문자로 만들자.
ㅇ 테이블의 백업, 이름바꾸기, 옮기기, 삭제, 복사를 위해 표준 시스템 명령을 사용할
수 있다. 예를 들어 테이블의 이름을 바꾸려면 해당하는 테이블의 `.ISD', `.ISM' and
`.frm' 파일의 이름을 바꾸면 된다.
- SQL문에서 db_name.tbl_name 문을 이용하여 다른 데이터베이스의 테이블에 접근할 수
있다. 일부 SQL 서버는 같은 기능을 지원하지만 이것을 User space라고 부른다. MYSQL은
다음과 같은 TABLESPACES를 지원하지 않는다 : create table ralph.my_table...IN
my_tablespace.
- 수치(숫자형) 컬럼에서 LIKE를 사용할 수 있다.
- SELECT문에서 INTO OUTFILE 과 STRAIGHT_JOIN 을 사용할 수 있다. 7.11
[SELECT] 참고.
-EXPLIAN SELECT는 테이블에서 어떻게 조인이 되었는지에 대한 정보를 보여준다.
- Use of index names, indexes on a subpart of a field, and use of INDEX or KEY in a
CREATE TABLE statement. 7.6 [CREATE TABLE] 참고.
- ALTER TABLE에서 CHANGE col_name, DROP col_name 또는 DROP INDEX 를 사용
한다. 7.7 [ALTER TABLE] 참고.
- ALTER TABLE 문에서 IGNORE 사용.
- ALTER TABLE 문에서 다중 ADD, ALTER, DROP or CHANGE 사용
- IF EXISTS 키워드를 이용한 DROP TABLE 사용.
- 한 테이블 이상에서 DROP TABLE 사용.
- LOAD DATA INFILE 사용. 대부분의 경우 이 문장은 오라클의 LOAD DATA INFILE
과 호환된다. 7.15 [LOAD DATA INFILE] 참고.
(** 많은 양의 데이터를 한꺼번에 입력할 때 일일이 INSERT 문을 하는 것보다 속도가 빠
르다. **)
- OPTIMIZE TABLE 문 사용.
- 문자열은 ''' 만이 아니라 '"' 또는 ''' 로 닫을 수 있다.
- escape `\' 문자 사용.
- SET OPTION 문. 7.24 [SET OPTION] 참고.
- GROUP BY 부분에서 모든 컬럼을 사용할 필요가 없다. 이러한 기능은 일반적인 질의가
아닌 특정한 질의에서 성능을 향상시킨다. 7.3.12 [GROUP BY Functions] 참고.
(** ANSI SQL에서는 여러 테입믈을 이용하여 GROUP BY를 사용할 때 사용하고자 하는
모든 컬럼에 GROUP BY를 지정해 주어야 한다. 이렇게 되는 경우 불필요한 연산이 수행될
수 있는데 MYSQL에서는 이러한 것을 없앤 것이다. 7.3.12를 참고한다 **)
- 다른 SQL 환경을 사용했던 사용자를 위해 MYSQL은 많은 기능에서 알리아스를 지원한
다. 예를 들어 모든 문자 펑션은 ANSI SQL 과 ODBC 구문을 지원한다.
- MYSQL은 C 프로그래밍 언어와 같은 논리적인 OR 과 AND를 의미하는 || 와 && 를 인
식한다. MYSQL에서는 || 와 OR 는 같은 말이며 && 와 AND 도 마찬가지이다. 이러한 미
묘한 구문때문에 MYSQL은 string concatenation(문자열 연관, 연결?)을 위한 ANSI SQL
오퍼레이터인 || 을 지원하지 않는다. 대신 CONCAT()를 사용한다. CONCAT() 는 많은 인
자가 있어서 MYSQL 에서 || 오퍼레이터의 사용을 변환하기 쉽다.
MySQL understands the || and && operators to mean logical OR and AND, as in the C
programming language. In MySQL, || and OR are synonyms, as are && and AND.
Because of this nice syntax, MySQL doesn't support the ANSI SQL operator || for
string concatenation; use CONCAT() instead. Since CONCAT() takes any number of
arguments, it's easy to convert use of the || operator to MySQL.
- 포팅이 가능하도록 SQL CODE에서 STRAIGHT_JOIN같은 MYSQL만의 키워드 사용을
지원하기 위해 이런 키워드를 /* */ 주석안에 내장할 수 있다. 주석문안의 내용은 '!' 로 시
작한다. 이런 경우 MYSQL에서는 주석문을 다른 MYSQL 구문과 같이 해석하지만 다른
SQL 서버에서는 이러한 확장기능을 사용하지 않고 건너띌 수 있다. 예를 보자:
SELECT /*! STRAIGHT_JOIN */ * from table1,table2 WHERE ...
- 다음의 기능이나 명령 사용:
ㅇ CREATE DATABASE or DROP DATABASE. 7.4 [CREATE DATABASE] 참고.
ㅇ MOD() 대신에 % 사용. %는 C 프로그래머를 위해 지원하며 또한 PostgresSQL과의
호환성을 위해 지원한다.
ㅇ 컬럼 문에서 =, <>, <= ,<, >=,>, <<, >>, AND, OR, LIKE 사용.
ㅇ LAST_INSERT_ID(). 18.4.49 [mysql_insert_id()] 참고.
ㅇ REGEXP or NOT REGEXP.
ㅇ 하나나 하나 이상의 인자를 사용한 CONCAT() 나 CHAR(). MYSQL에서 이러한 펑
션은 여러개의 인자를 가질 수 있다.
ㅇ BIT_COUNT(), ELT(), FROM_DAYS(), FORMAT(), IF(), PASSWORD(),
ENCRYPT(), PERIOD_ADD(), PERIOD_DIFF(), TO_DAYS(), or WEEKDAY().
ㅇ 서브스트링을 없애는 데 TRIM() 사용.(Use of TRIM() to trim substrings) ANSI
SQL 에서는 단일 문자 제거만 지원한다.
(** 꺼어억~ 트림이 술먹고 하는 트림은 아니랍니다... **)
ㅇ 그룹 펑션에서 STD(), BIT_OR() and BIT_AND()
ㅇ DELET + INSERT 대신 REPLACE 사용. 7.14 [REPLACE] 참고.
ㅇ FLUSH flush_option 명령.
5.2 MYSQL에서 빠진 기능
다음의 기능들은 현재 버전의 MYSQL에 빠져있다. 다음 버전에서의 우선권을 확인하라면
MYSQL TODO 목록을 참고하자(http://www.mysql.com/Manual_split/manual_Todo.html).
이것이 가장 최신 버전의 TODO 목록이다. 부록 F [TODO] 참고.
5.2.1 Sub-selects
다음은 Mysql에서 작동하지 않는다:
SELECT * FROM table1 WHERE id IN (SELECT id FROM table2);
Mysql에서는 오직 INSERT ... SELECT ... and REPLACE ... SELECT ... 만을 지원한다.
독립적인 서브-select 문은 3.23.0에서 아마도 사용할 수 있을 것이다. 그대신 현재 IN() 펑
션을 사용할 수 있다.
5.2.2 SELECT INTO TABLE
Mysql은 아직 SELECT ... INTO TABLE ....을 지원하지 않는다. 현재, Mysql은 오직
SELECT ... INTO OUTFILE ..., 만을 지원하며 기본적으로는 동일하다.
5.2.3 트랜잭션(Transactions)
트랜잭션은 지원되지 않는다. Mysql은 곧 atomic(원자성?) 오퍼레이션을 지원할 것이며
atomic 오퍼레이션은 rollback이 없는 트랜잭션과 비슷하다. atomic 오퍼레이션을 사용하며
insert/select/모든 명령의 그룹을 실행할 수 있으며 어떤 스레드도 충돌하지 않을 수 있도록
보장해준다. 이 문맥에서 일반적으로 롤백(rollback)은 필요없다. 현재 LOCK TABLES 와
UNLOCK TABLES 명령을 이용하여 다른 스레드가 충돌하는 것을 막을 수 있다. 7.23
[Lock Tables] 참고.
5.2.4 저장 프로시저와 트리거
저장 프로시저는 서버에서 컴파일되고 저장될 수 있는 SQL 명령 세트이다. 이런 기능이 수
행되면 클라이언트는 전체 질의를 다시 할 필요가 없고 또한 저장 프로시저를 참조할 수 있
다. 이런 기능이 있으면 질의는 한번만 해석되고 서버와 클라이언트간의 주고받아야 하는
데이터가 줄어들므로 속도가 향상된다. 또한 서버의 펑션 라이브러리를 가짐으로서 개념적
인 단계를 향상시킬 수 있다. (??? You can also raise the conceptual level by having
libraries of functions in the server.)
트리거는 특별한 이벤트가 발생했을 때 생기는 저장 프로시져이다. 예를 들어 트랜잭션 테
이블에서 레코드가 삭제되고 모든 트랜잭션이 지워질 때 상응하는 테이블을 삭제할 수 있는
저장 프로시저를 설치할 수 있다.
앞으로는 저장 프로시저를 지원할 예정이지만 트리거는 아니다. 트리거는 필요하지 않은 경
우에도 사용될 수 있어서 일반적으로 속도가 느려진다.
언제 저장 프로시저를 사용하게 될지는 앞으로 Mysql에 추가할 목록인 부록 F를 참고하
자.(The TODO)
(** 전반적으로 트랜잭션 처리와 트리거 등은 데이터베이스의 속도를 저하시킵니다. Mysql
은 이렇게 속도에 영향을 미칠 수 있는 부분을 제거하여 빠른 속도를 내는 것이지요. 이러
한 부분이 자기가 사용하는 데이터베이스에서 얼마나 중요한가 판단을 해 보아야 할 것입니
다. 보통 소형 DBMS에서는 회복과 병행수행을 지원하지 않는 경우가 많다. 즉 병행수행은
발생하지 않으며, 회복은 사용자의 문제로 생각한다. 그러므로 사용자가 데이터베이스의 예
비 사본을 준비하며, 고장이 발생하면 작업을 다시 해야 한다. 트리거같은 경우는 자료의 무
결성을 보장하기 위해 필요한 것이다. **)
5.2.5 외래키(Foreign Keys)
SQL 문에서 외래키는 테이블을 조인할 때 사용하지 않지만 대부분 참조 무결성을 확인할
때 사용한다. SELECT 문에서 다중 테이블에서 자료를 가져오길 원하면 테이블을 조인해서
처리할 수 있다.
SELECT * from table1,table2 where table1.id = table2.id
7.12 [JOIN] 참고.
Mysql에서 외래키(FOREIGN KEY) 문은 다른 SQL 제품의 CREATE TABLE 명령과의 호
환성 때문에 존재한다: 외래키는 아무것도 하지 않는다. ON DELETE ... 가 없는
FOREIGN KEY 구문은 대부분 문서적인 목적으로 사용한다. 일부 ODBC 애플리케이션은
이것을 자동적인 WHERE 문을 만들 때 사용할 것이다. 그렇지만 이것은 대부분 생략(무시)
하고 넘어가기 쉽다. 외래키는 때로는 제약조건 체크(constraint check)로 사용을 하지만 이
러한 체크는 데이터가 테이블에 정확한 순서로 들어갈때는 불필요하다. Mysql은 일부 애플
리케이션에서 외래키가 존재하는 것을 필요로 하기 때문에(제대로 작동하든 안하든 상관없
이) 지원하는 것일 뿐이다.
Mysql에서 외래키를 가진 테이블의 레코드를 삭제할 때 애플리케이션에 적절한 DELETE
문을 추가하여 ON DELETE ... 가 수행되는 것을 막음으로써 문제를 해결할 수있다. 경험
상 이렇게 하는 것이 외래키를 사용하는 것과 같이 빠르며(어떤 경우에는 더 빠름) 포팅하
기가 더 좋다.
가까운 시일안에 우리는 외래키 기능을 확장할 것이다. 그래서 최소한 mysqldump와 ODBC
에서 정보가 저장되고 검색할 수 있도록 할 것이다.
5.2.5.1 외래키를 사용하지 않는 이유
외래키를 사용할 때 어디에서 출발해야 할지 모르는 많은 문제가 있다:
- Foreign key들은 상황을 매우 복잡하게 만든다. 왜냐하면, foreing key의 정의가 database에
담겨야 하고, foreign key를 구현하는 것은 "자연스런" File 사용법(data file들을 옮기고,
복사하고, 삭제하는 등...)을 제한한다.
(** 문태준님 역주: 번역이 이상한데 외래키가 있으면 참조 무결성 규칙을 위해 여러 가지
보상 연산을 하게 된다. 이것을 뜻하고 있는 듯하다. **)
- INSERT 와 UPDATE 문은 속도에 많은 영향을 끼친다. 그리고 이런 경우 보통 올바른
순서로 올바른 테이블에 레코드를 삽입하기 때문에 대부분 모든 외래키 체크는 사용할 필요
없다.
- 한쪽의 영향이 전체 데이터베이스에 연쇄 작용을 하기 때문에 테이블에서 업데이트를 할
때 매우 많은 테이블에서 락을 사용해야 한다. 한 테이블에서 먼저 레코드를 삭제하고 그후
에 다른 테이블에서 레코드를 삭제하는 것이 훨씬 빠르다.
- Table를 완전히 지우고, (backup이나 새로운 source로부터) 모든 record들을 다시 복구하는
방법으로 Table을 복구할 수 없다.
- Foreign key를 사용한다면, table을 dump(backup)하고 (그 dump한 자료를) restore하는 데
있어 그 일련의 순서를 적절하게 지켜야 한다.
- 각각의 table의 정의가 쓸모있고 적절하더라도, (각 Table들이 상호참조하게 된다면) 단순한
create문으로는 재생성이 불가능한 circular definition(순환정의)가 쉽게 발생한다.
(역자주: A라는 Table이 B의 자료를 참조하는 foreign key를 담고 있고,
B는 C에 대한 foreign key를, C는 A에 대한 foreign key를 담도록 table이 구성된다면
한번에 A,B,C table을 생성할 수 없다. A,B,C를 만든다음 각각의 foreign key를 지정해
주는 방법을 쓰게 된다.)
외래키의 좋은 점은 단지 다음와 같다. ODBC와 특정한 다른 클라이언트 프로그램에서 어
떻게 테이블이 연결되어 있는지를 볼 수 있고 연결 다이어그램을 보는데 사용하며 애플리케
이션을 만드는데 돕는 점이다.
(역자주: 이 글은 foreign key에 대해서 매우 비판적이다. 하지만, 이것은 foreign key의
일부 기능일뿐이다. 무엇보다도 client가 각 Table내 DATA의 연관관계에 대해서
빼먹었는지에 대해서 일일이 신경쓰지 않게 하고, 항상 자료의 무결성(정합성[?])을
보장한다는 것은 매우 중요하다.
특히, Table이 1~20개가 아닌 100단위가 넘어간다면, client에서 일일이 신경쓰며
programing하는 것도 힘들지만, debugging도 예상보다 힘들어진다.
각 table간의 연결관계를 잘 문서화한다면 programmer들이 foreign key로 고통받기
보다는 관련 Table을 check해야 되는 수고를 덜게된다.
foreign key가 기피되는 주된 이유는 table내의 Data를 수정하는 것이 쉽지 않기
때문이다. 현장 실무자의 논리에 어긋나는 요청을 처리하는 데 있어서
foreign key만큼 거추장스런 놈도 없으리라. )
Mysql에서는 곧 외래키 정의를 저장할 수 있도록 해서 클라이언트가 어떻게 원래의 연결이
만들어졌는지에 대해서 질문하고 답을 받을 수 있도록 할 것이다. 현재의 '.frm' 파일 포맷
은 아직 이것을 지원하지 못하고 있다.
5.2.6 뷰
Mysql은 뷰를 지원하지 않는다. 그렇지만 TODO(이후 개선 목록)에 있다.
MySQL doesn't support views, but this is on the TODO.
5.2.7 `--'을 사용한 주석
일부 다른 SQL 데이터베이스는 '--' 로 주석을 시작한다. mysql 명령 라인 도구가 '--'로
시작하는 모든 줄을 제거할 지라도 Mysql은 '#'을 주석 문의 시작으로 사용한다. 사용자는
또한 C 명령 스타일인 /* this is a comment */ 를 mysql에서 사용할 수 있다. 7.28
[Comment] 참고.
Mysql은 '--'를 지원하지 않을 것이다; '--'은 퇴보한 주석문 형태로 자동으로 생성되는
SQL 질의에서 많은 문제를 발생시킨다. 다음의 예제를 보자. 우리는 자동적으로 payment를
!payment! 의 값으로 입력하도록 하고 있다 :
UPDATE tbl_name SET credit=credit-!payment!
payment의 값이 음수일 때 어떤 일이 생길 것이라 생각하는가?
1--1은 합당한 SQL문이기 때문에 '--'가 주석문의 시작을 의미하는 것을 꺼리는 것이다.
'--' 주석을 포함하는 텍스트 파일의 SQL 프로그램을 가졌다면 다음과 같이 사용해야 한다:
shell> replace " --" " #" < text-file-with-funny-comments.sql \
| mysql database
instead of the normal(정상적인 경우 대신???):
shell> mysql database < text-file-with-funny-comments.sql
명령 파일로 '--' 주석을 '#' 주석으로 바꿀 수 있다:
shell> replace " --" " #" -- text-file-with-funny-comments.sql
다음의 명령으로 원래대로 돌려놓자:
shell> replace " #" " --" -- text-file-with-funny-comments.sql
(** 일부 SQL에서 사용하는 -- 주석문에서 문제가 생길 수 있으므로 MYSQL에서는 #을
주석문으로 사용한다는 말이다 **)
5.3 Mysql이 따르고 있는 표준은 무엇인가?
Entry level SQL92. ODBC level 0-2.
5.4 BLOB 와 TEXT 타입의 제한
BLOB 나 TEXT 필드에서 GROUP BY 나 ORDER BY를 사용하길 원하면 그 필드를 고정
길이 객체로 만들어야 한다. 이렇게 하는 표준적인 방법은 SUBSTRING 펑션을 사용하는
것이다. 예를 보자:
mysql> select comment from tbl_name order by SUBSTRING(comment,20);
이렇게 하지 않으면 정렬할 때 오직 첫 번째 max_sort_lengths (기본값=1024)만을 고려된
다.
BLOB 와 TEXT 는 기본값을 가질 수 없으며 또한 언제나 NULL 컬럼일 것이다.
BLOB and TEXT cannot have DEFAULT values and will also always be NULL
columns.
5.5 COMMIT-ROLLBACK 없이 어떻게 대치할 수 있을까?
Mysql은 COMMIT-ROLLBACK 을 지원하지 않는다. 문제는 COMMIT-ROLLBACK을 효
과적으로 다루기 위해서는 Mysql에서 현재 사용하는 것과 완전히 다른 테이블 설계가 필요
하다는 것이다. Mysql은 또한 테이블을 자동 클린업하는 추가적인 스레드와 더 많은 디시
크를 사용할 수 있는 기능이 필요하다. 이러한 기능은 현재보다 mysql을 2-4배 느리게 만
든다. Mysql은 대부분의 다른 SQL 데이터베이스보다 훨씬 더 빠르다. (전형적으로 최소
2-3대 빠름) 이러한 이유는 Mysql에 COMMIT-ROLLBACK이 없기 때문이다.
당분간은 우리는 SQL 서버 언어의 성능을 향상시키는데 더 주력할 것이다. 대부분
COMMIT-ROLLBACK 기능이 정말로 필요한 경우는 드물다. 또한 이렇게 하는 것이 더 좋
은 성능을 낼 수 있다.
일반적으로 트랜잭션이 필요한 루트는 LOCK TABLES를 사용해 코드를 짤 수 있다. 또한
레코드를 업데이트할 때 커서를 사용할 필요가 없다.
우리는 트랜잭션과 커서를 TODO에 넣었지만 우선권이 높은 것은 아니다. 이러한 기능을
수행한다면 CREATE TABLE 의 옵션으로 될 것이다. 이것은 옵션으로 지정한 테이블에서
만 작동하며 그 테이블은 느리게 될 것이라는 것을 의미한다.
우리는 100% 보편적인 데이터보다는 정말로 빠른 데이터베이스가 필요하다.
COMMIT-ROLLBACK 기능을 수행하더라도 속도에 손상이 없다면 우리는 그것을 지원할
것이다. 당분간은 더 중요하게 해야할 일들이 많이 있다. 우리가 어떤 것에 우선권을 두고
있는지는 TODO를 참고하자. 상위 단계의 지원을 받는 고객은 이것을 바꿀 수 있으며 우선
권이 변경될 수도 있다.
현재의 문제는 실제로 ROLLBACK 이다. 롤백없이 LOCK TABLES을 이용하여 여러 종류
의 COMMIT를 사용할 수 있다. 롤백을 지원하기 위해 Mysql은 업데이트가 된 모든 예전
레코드를 저장하고 롤백이 일이났을 때 시작 시점으로 돌아갈 수 있도록 바꾸어야 한다. 예
를 들어 이러한 것은 전혀 어렵지 않다.(현재의 isamlog 는 이런 경우를 위해 사용할 수 있
다) 그러나 ALTER/DROP/CREATE TABLE에서 롤백을 수행하는 것은 무척 어렵다.
롤백 사용을 피하기 위해 다음의 전략을 사용할 수 있다:
1. 접근하기 원하는 모든 테이블에 락을 사용. LOCK TABLES ...
2. 조건 테스트(Test conditions)
3. 모든 것이 제대로 된다면 업데이트를 한다.
4. UNLOCK TABLES
일반적으로 가능한 롤백을 이용해 트랜잭션을 사용하는 것보다는 이러한 방법이 훨씬 더 빠
르다. 그렇지만 항상 사용가능한 것은 아니다. 이러한 방법으로 해결할 수 없는 유일한 상황
은 업데이트중 누군가가 스레드를 죽였을 때이다. 이런 경우 모든 락은 해제가 된다. 그렇지
만 업데이트의 일부는 실행되지 않을 것이다.
물론 단일 오퍼레이션에서 레코드를 업데이트하는 펑션을 사용할 수 있다. 다음의 테크닉을
사용하며 매우 효율적인 애플리케이션을 만들 수 있다:
- 현재 값과 관련되어 있는 필드를 수정
- 실제로 변화가 생겼을때만 필드를 업데이트
예를 들어, 어떤 고객 정보를 업데이트 할 때 오직 바뀐 데이터만 업데이트를 한다. 그리고
For example, when we are doing updates on some customer information, we update only
the customer data that have changed and test only that none of the changed data, or
data that depend on the changed data, have changed compared to the original row.
변화된 데이터의 테스트는 UPDATE 문에서 WHRE 절을 사용하여 할 수 있다. 레코드가
업데이트되지 않았다면 클라이언트에 다음과 같은 메시지를 준다: "당신이 바꾼 데이터 일
부가 다른 사용자에 의해 바뀌었습니다". 그러고나서 우리는 윈도우에서 예전의 레코드와
현재의 레코드를 비교하여 보여준다. 그러면 사용자는 어떤 고객 정보 레코드를 사용할지
결정할 수 있다.
이렇게 하면 "컬럼 라킹"과 비슷하다. 그렇지만 실제로는 더 빠르다. 왜냐하면 현재의 값과
관련되어 있는 값의 컬럼만 업데이트하기 때문이다. 이렇나 전형적인 업데이트문은 다음과
비슷할 것이다:
UPDATE tablename SET pay_back=pay_back+'relative change';
UPDATE customer
SET
customer_date='current_date',
address='new address',
phone='new phone',
money_he_owes_us=money_he_owes_us+'new_money'
WHERE
customer_id=id AND address='old address' AND phone='old phone';
지금 보듯이 이렇게 하면 매우 효율적이며 설사 다른 클라이언트가 pay_back 이나
money_he_owes_us 컬럼의 값을 바꾸었을 때라도 제대로 작동한다.
대부분의 경우, 사용자는 테이블에서 유일한 값(identifiers)을 관리하기 위해 롤백과 테이블
락을 사용하고 싶어한다. 이것은 AUTO_INCREMENT 컬럼과 SQL LAST_INSERT_ID()
펑션, 또는 mysql_insert_id() 의 C API 펑션을 사용하여 더욱 효율적으로 사용할 수 있다.
18.4.49 [mysql_insert_id()] 참고.
TcX에서는 언제나 이런 문제를 해결할 수 있기 때문에 결고 low-level 락을 필요로 하지
않는다. 어떤 경우에는 정말로 로우-락이 필요하다. 그렇지만 이런 경우는 극소수이다. 로우
-레벨 락을 원하면 테이블에서 플래그 컬럼을 사용할 수 있다. 다음과 같다:
UPDATE tbl_name SET row_flag=1 WHERE id=ID;
만약 row가 발견되고 row_flag가 원래의 row에서 이미 1이 아니라면 영향을 받은 row의
숫자로서 1일 반환한다.
MySQL returns 1 fro the number of affected rows if the row was found and row_flag
wasn't already 1 in the original row.
6. Mysql 접근 권한 시스템
mysql 은 진보적이지만 비표준적인 보안/권한 시스템을 가지고 있다. 이번 장에서는 이것이
어떻게 작동하는지를 설명하고 있다.
6.1 권한 시스템이란 무엇인가?
Mysql 권한 시스템의 주요 기능은 데이터베이스에서 select, insert, update, delete 권한
을 호스트의 사용자 이름과 관련짓는 것이다.
추가적인 기능에는 익명 사용자 기능과 LOAD DATA INFILE 과 관리자 오퍼레이션과 같은 my
sql만의 특수한 권한을 허용하는 부분이 포함되어 있다.
Mysql에서 인증을 목적으로 사용하는 사용자 이름은 유닉스 사용자 이름(로그인 이름)이나
위도우 사용자 이름고는 전혀 관계가 없다는 것!을 기억하자. 대부분 mysql 클라이언트는 m
ysql 사용자 이름으로 현재의 유닉스 사용자 이름을 사용하여 접속하려 할 것이다. 그렇지
만 이건 오직 편의를 위해서이다. 클라이언트 프로그램은 -u 나 --user 옵션으로 지정한 다
른 이름을 허용한다. 이것은 mysql 사용자 이름에 비밀번호를 설정하지 않으면 데이터베이
스의 보안에 문제가 생길 수 있다는 것을 의미한다. 어떤 이름을 사용하여 서버에 접속하려
고 하는 사람은 각 이름에 비밀번호가 설정되어 있지 않다면 접속에 성공할 것이다.
유닉스 사용자 이름이 일반적으로 8글자로 제한되어 있는 것과 다르게 mysql 사용자 이름은
16글자까지 사용할 수 있다.
mysql 비밀번호는 유닉스의 비밀번호와 아무 관련이 없다. 유닉스 머신에 로그인할 때 사용
하는 비밀번호와 데이터베이스에 접속할 때 사용하는 비밀번호는 전혀 관련이 없다. 또한 m
ysql은 유닉스 로그인 프로세스에서 사용하는 것과 다른 알고리즘으로 비밀번호를 암호화한
다.
6.2 mysql 서버에 접속하기
mysql 클라이언트 프로그램은 일반적으로 연결 패러미터(매개 변수)가 필요하다.: 연결할
호스트, 사용자 이름, 비밀번호. 예를 들어 mysql 클라이언트는 다음과 같이 시작할 수 있
다. (선택 인자는 [ ] 로 닫는다)
shell>; mysql [-h host_name] [-u user_name] [-pyour_pass]
-p와 뒤에 붙은 비밀번호 사이에는 공간이 없다는 것을 기억하자.
-h, -u, -p를 대체할 수 있는 형식으로는 --host=host_name, --user=user_name and --passw
ord=your_pass 이 있다.
mysql은 커맨드 라인에서 연결 매개변수가 빠져있을 때는 기본 값을 사용한다. 기본 호스트
이름은 localhost 이고 기본 사용자 이름은 유닉스 로그인 이름이다.(-p 가 빠져있으면 비
밀번호는 사용하지 않는다) 그래서 만약 유닉스 사용자 이름이 joe 라면 다음의 명령은 동
일하다.:
shell> mysql -h localhost -u joe
shell> mysql -h localhost
shell> mysql -u joe
shell> mysql
다른 mysql 클라이언트도 비슷하게 작동한다.
유닉스 시스템에서 연결을 할 때 사용할 수 있는 기본 값이 있어서 클라이언트 프로그램을
사용할 때마다 명령행에서 옵션을 사용하지 않아도 된다:
ㅇ 홈 디렉토리의 '.my.cnf' 설정 파일의 [client] 섹션에서 연결 변수를 설정할 수 있다.
파일에서 이와 연관된 섹션은 다음과 같다:
[client]
host=host_name
user=user_name
password=your_pass
4.14.4 [option files] 참고.
ㅇ 환경 변수를 사용하여 연결 변수를 지정할 수 있다. 호스트는 MYSQL_HOST 로 지정할 수
있다. Mysql 사용자 이름은 USER, LOGNAME, 또는 LOGIN을 사용할 수 있다. (이러한 값들은
이미 유닉스 로그인 이름으로 설정되어 있을 것이다. 그러므로 바꾸지 않는게 좋다) 비밀번
호는 MYSQL_PWD로 지정할 수 있다.(그렇지만 이것은 안전하지 않다; 다음 섹션을 참고하자)
연결 변수가 여러 가지 방법을 지정되었다면 명령행에서 지정한 값이 설정 파일과 환경 변
수로 설정한 것보다 우선권을 가진다. 또한 설정 파일의 값이 환경 변수보다 우선권을 가진
다.
6. 2. 1 비밀번호의 보안 유지
다른 사용자가 발견할 수 있게 비밀번호를 지정하는 방법은 권하지 않는다. 클라이언트 프
로그램을 실행할 때 비밀번호를 지정하는 방법은 아래와 같으며 각 방법마다 위험도를 같이
설명하였다:
ㅇ 명령행에서 -pyour_pass 또는 --password=your_pass 옵션 사용. 이 방법은 편리하지만
위험한 방법이다. 비밀번호를 시스템 상황 프로그램(ps 등)을 통해 볼 수 있기 때문에 다른
사용자가 명랭행으로 볼 수 있다.(mysql 클라이언트는 일반적으로 초기화되는 동안 명령행
인자를 0으로 덮어씌운다. 그렇지만 값을 볼 수 있는 짧은 틈이 여전히 있다)
ㅇ -p 또는 --password 옵션 사용(비밀번호 값을 지정하지는 않음). 이런 경우 클라이언트
프로그램은 터미널에서 비밀번호를 물어본다:
shell> mysql -u user_name -p
Enter password: ********
클라이언트는 비밀번호를 칠 때 터미널에서 '*' 문자를 보여준다. 그러므로 다른 사용자가
비밀번호를 볼 수 없다. 다른 사용자가 볼 수 없으므로 명령행에서 비밀번호를 입력하는 것
보다 훨씬 더 안전하다. 그렇지만 이 방법은 비대화식의 스크립트로 클라이언트 프로그램을
사용하면 적절하지 않다.
ㅇ 설정 파일에 비밀번호 저장. 예를 들어 홈 디렉토리의 '.my.cnf' 파일에서 [client] 섹
션에 비밀번호를 지정할 수 있다.
[client]
password=your_pass
비밀번호를 '.my.cnf' 파일에 저장한다면 그 파일은 그룹이나 다른 사용자가 읽기/쓰기를
할 수 없도록 해야 한다. 파일의 퍼미션이 400 이나 600 인지 확인하자.
4.14.4 [옵션 파일] 참고.
ㅇ 비밀번호를 MYSQL_PWD 환경 변수에 저장할 수 있다. 그렇지만 이 방법은 정말로 위험하
며 사용해서는 안된다. 일부 ps 프로그램은 실행 프로세스의 환경변수를 보여주는 옵션이
있다; MYSQL_PWD에 설정을 하면 다른 사람들이 쉽게 비밀번호를 볼 수 있다. 이런 기능의 p
s가 없는 시스템일지라도 프로세스 환경변수를 검색할 수 있는 방법이 없다고 생각하는 것
은 현명하지 못하다.
이중에서 가장 안전한 방법은 클라이언트 프로그램이 비밀번호를 요구하거나 적절하게 보안
이 된 '.my.cnf' 파일에 비밀번호를 지정하는 것이다.
6.3 mysql에서 제공하는 권한
권한과 관련된 정보는 mysql 데이터베이스의(데이터베이스 이름이 mysql 임) user, db, hos
t, table_priv, columns_priv 테이블에 저장된다. mysql 서버는 시작할 때, 그리고 환경을
지정할 때(6.7 [권한 변경] 참고) 이 테이블의 내용을 읽어들인다.
mysql에서 제공하는 권한을 설정할 때 사용하는 이름은 아래와 같다.테이블의 컬럼 이름은
grant tables의 각 권한 및 권한이 적용되는 context와 연관되어 있다.
Privilege Column Context
(권한) (컬럼) (환경)
select Select_priv tables
insert Insert_priv tables
update Update_priv tables
delete Delete_priv tables
index Index_priv tables
alter Alter_priv tables
create Create_priv databases, tables or indexes
drop Drop_priv databases or tables
grant Grant_priv databases or tables
reload Reload_priv server administration
shutdown Shutdown_priv server administration
process Process_priv server administration
file File_priv file access on server
select, insert, update, delete 권한은 데이터베이스의 테이블에서 레코드에 대한 오퍼레
이션을 할 수 있도록 허용한다.
SELECT 문은 오직 실제로 테이블에서 줄(레코드)를 가져올 때만 select 권한이 필요하다.
서버의 데이터베이스에 접근 권한이 없는 경우라고 하더라도 특정한 SELECT 문은 사용할
수 있다. 예를 들면 간단한 계산을 위해 mysql 클라이언트를 사용할 수 있다:
mysql> SELECT 1+1;
mysql> SELECT PI()*2;
index(인덱스) 권한은 인덱스를 생성하거나 제거할 수 있다.
alter 권한은 ALTER TABLE 을 사용할 수 있도록 한다.
create 와 drop 권한은 새로운 데이터베이스와 테이블을 생성하거나 존재하는 데이터베이
스와 테이블을 제거할 수 있도록 허용한다.
사용자에게 mysql 데이터베이스의 drop 권한을 허용하면, 그 사용자는 mysql 접근권한 정보
가 저장된 데이터베이스를 없앨 수 있다는것!을 명심하자.
grant 권한은 사용자가 가지고 있는 권한을 다른 사용자가 가질 수 있도록 허용한다.
file 권한은 LOAD DATA INFILE and SELECT ... INTO OUTFILE 문을 이용하여 서버에 파일을
저장하고 읽을 수 있는 권한을 허용한다. 이러한 권한을 가진 사용자는 mysql 서버가 읽고
쓸 수 있는 파일을 읽고 쓸 수 있는 권한이 허용된다.
나머지 권한들은 관리자 오퍼레이션에 사용되며 mysqladmin 프로그램의 기능을 수행한다.
아래의 테이블은 각 관리자 권한에 따라 사용할 수 있는 mysqladmin 명령을 보여준다:
Privilege Commands permitted to privilege holders
(권한) (권한에 따라 허용되는 명령)
reload reload, refresh, flush-privileges, flush-hosts, flush-logs, flush-tab
les
shutdown shutdown
process processlist, kill
reload 명령은 서버가 grant 테이블을 다시 읽어 들인다. refresh 명령은 모든 열린 테이블
을 닫으며 로그 파일을 열고 닫는다. flush-privileges 는 reload 명령과 동의어이다. 다른
flush-* 명령은 refresh 와 비슷한 기능을 수행한다. 그러나 범위에 제한이 있으며 어떤 경
우에는 더 선택할 만하다. 예를 들어 로그 파일만 닫고 다시 열고자 한다면 flush-logs 가
refresh보다 더 나은 선택이다.
(** flush의 옵션으로는 호스트, 로그 파일, 권한 설정, 테이블, status variables 설정 변
수가 있다. SQL 문에서 또는 mysqladmin 유틸리티를 사용하면 된다. **)
shutdown 명령은 서버를 셧다운한다. (** 이거 번역 맞아~~?? **)
processlist 명령은 서버에서 실행되고 있는 스레드에 대한 정보를 보여준다. kill 명령은
서버 스레드를 죽인다. 언제나 자신의 스레드는 보거나 죽일 수 있지만 다른 사용자에 의해
시작된 스레드는 프로세스 권한이 있어야 보거나 죽일 수 있다.
몇가지 권한은 조심스럽게 허용해야 한다:y:
ㅇ grant(허용) 권한은 사용자가 다른 사용자의 권한을 설정할 수 있도록 허용한다. 다른
권한과 grant 권한을 가진 두 사용자는 권한을 결합할 수 있다.
ㅇ file 권한은 서버에서 모든 사람이 읽기 가능한 파일을 읽는데 남용 될 수 있.... SELEC
T 문을 이용해 접근할 수 있는 내용...
The file privilege can be abused to read any world-readable file on the server into a
database table, the contents of which can then be accessed using SELECT.
(** 굳이 권한을 주지 않아도 이용할 수 있는 것은 권한을 주지 않는게 낫다는 말이겠지요
**)
ㅇ shutdown 권한은 다른 사용자에가 완전히 서비스를 사용하지 못하도록 남용될 수 있다.
ㅇ process 권한은 비밀번호를 설정하고 바꾸는 질의를 포함해 현재 수행하고 있는 질의를
보는데 사용될 수 있다.
ㅇ mysql 데이터베이스에 대한 권한은 비밀번호와 다른 접근 권한 정보를 바꾸는 데 사용될
수 있다. (비밀번호가 암호화되어 저장되었다고 하더라도, 충분한 권한을 가진 악의있는 사
용자는 다른 비밀번호롤 바꿀 수 있다)
mysql 권한 시스템으로 다룰 수 없는 몇가지가 있다:
ㅇ 접근을 거부할 사용자를 명백하게 지정할 수 없다. 왜냐하면 사용자와 연결을 거부하는
것을 완전하게 연관시킬 수 없기 때문이다.
ㅇ 사용자가 테이터베이스에서 테이블을 만들고 지울 수 있는 권한을 가질 수 있지만 데이
터베이스 자체를 만들고 삭제할 수는 없도록 지정할 수 없다.
(** 그러니까 create 와 drop 권한을 주면 데이터베이스 자체에 대해 제어할 수 있지요. 그
안의 테이블만 만들고 지울 수 있도록 하지는 못한다는 말 **)
{{}}
6.4 권한 시스템 작동 방법
mysql 권한 시스템은 모든 사용자가 허용된 것만큼만 할 수 있도록 보증한다. mysql 서버에
연결할 때, 사용자 확인은 연결한 호스트와 사용자가 지정한 사용자 이름에 의해 결정된다.
시스템은 사용자 확인과 지정한 권한에 따라 권한을 허용한다.
mysql은 사용자를 확인하는데 호스트이름과 사용자 이름 둘다 사용한다. 왜냐면 인터넷에서
이름이 같다고 같은 사용자라고 생각할 수는 없기 때문이다. 예를 들어 whitehouse.gov에서
접속하는 사용자 bill 은 microsoft.com에서 접속하는 사용자 bill 과 같은 사람일 필요는
없다. mysql은 때론 같은 이름을 가지고 있더라도 호스트를 이용해 사용자를 구별한다 : wh
itehouse.gov에서 접속하는 bill에게 특정한 권한을 허용할 수 있고 microsoft.com에서 접
속하는 bill에게 다른 권한을 허용할 수 있다.
mysql의 접근 제어는 두가지 단계가 있다:
단계 1: 서버에서 사용자가 연결할 수 있는지 없는지 판단
단계 2 (서버에 사용자가 연결이 허용되었을 경우) : 사용자가 수행하려는 명령에 대해 충
분한 권한이 있는지 각 요청마다 서버에서 판단.예를 들면, 데이터베이스의 테이블에서 sel
ect rows를 할때, 또는 데이터베이스에서 테이블을 제거할 때 서버에서 테이블에 대한 sele
ct 권한이 있는지 데이터베이스에 대한 제거 권한이 있는지 확인을 한다.
서버는 접근 제어의 각 두 단계에서 mysql 데이터베이스의 user, db, host 테이블을 이용한
다.grant 테이블의 필드는 아래와 같다:
Table name user db host
Scope fields Host Host Host
(필드 범위) User Db Db
Password User
Privilege fields Select_priv Select_priv Select_priv
(권한 필드) Insert_priv Insert_priv Insert_priv
Update_priv Update_priv Update_priv
Delete_priv Delete_priv Delete_priv
Index_priv Index_priv Index_priv
Alter_priv Alter_priv Alter_priv
Create_priv Create_priv Create_priv
Drop_priv Drop_priv Drop_priv
Grant_priv Grant_priv Grant_priv
Reload_priv
Shutdown_priv
Process_priv
File_priv
접권 제어의 두번째 단계를 위해(요청 인증), 요청이 테이블에 관계된 것이라면 추가적으로
tables_priv 와 columns_priv 테이블을 참고한다. 이 테이블의 필드는 다음과 같다:
Table name tables_priv columns_priv
Scope fields Host Host
Db Db
User User
Table_name Table_name
Column_name
Privilege fields Table_priv Type
Column_priv
Other fields Timestamp Timestamp
Grantor
각 승인(grant) 테이블은 필드 범위와 권한 필드로 구성되어 있다.
필드 범위는 테이블에서 각 엔트리의 범위를 결정한다. 다시 말하면 엔트리가 적용되는 con
text(환경, 배경)이다. 예를 들면, Host 와 User 값이 'thomas.loc.gov' 와 'bob' 인 user
테이블 엔트리는 thomas.loc.gov 호스트에서 bob이 연결을 할때 서버에서 인증을 하는데 사
용된다.비슷하게 Host, User, db 필드값이 'thomas.loc.gov', 'bob', 'reports' 인 db 테
이블 엔트리는 thomas.loc.gov 호스트에서 bob 이 reports 데이터베이스에 접근할 때 사용
된다. tables_priv 와 columns_priv 테이블은 테이블이나 각 엔트리가 적용될 수 있는 테이
블/컬럼 조합을 가리키는 범위 필드를 포함하고 있다.
접권 체크를 하기 위해, HOst 값 비교는 대소문자를 구별하지 않는다. User, Password, Db,
Table_name 값은 대소문자를 구별한다. mysql 3.22.12 와 이후 버전에서 Column_name 값은
대소문자를 구별하지 않는다. (3.22.11에서는 대소문자 구별함)
권한 필드는 테이블 엔트리에 승인되는 권한을 가리키며 이는 수행할 수 있는 오페레이션이
다. 서버는 사용자의 권한을 완벽하게 설정하기 위해 다양한 승인(grant) 테이블의 정보를
조합한다. 여기에 사용하는 규칙은 6.6 [Request access]를 참고하자.
범위 필드는 문자열이며 다음과 같이 정의되었다; 기본 값은 빈 문자열이다:
Field name Type
Host CHAR(60)
User CHAR(16)
Password CHAR(16)
Db CHAR(64) (CHAR(60) for the tables_priv and columns_priv tables)
user, db, host 테이블에서 모든 권한 필드는 ENUM('N','Y')로 정의되어 있다. -- 각각은
'N' 나 'Y'의 값을 가지며 기본값은 'N' 이다.
(** ENUM 타입은 목록 값중 오직 하나의 값만 가진다.필드 타입 참조 **)
tables_priv 와 columns_priv 테이블에서 권한 필드는 SET 필드로 정의된다:
(** SET 타입은 목록 값중에 0이나 1개 이상의 값을 가진다 **)
Table name Field name Possible set elements
tables_priv Table_priv 'Select', 'Insert', 'Update',
'Delete', 'Create', 'Drop', 'Grant',
'References', 'Index', 'Alter'
tables_priv Column_priv 'Select', 'Insert', 'Update',
'References'
columns_priv Type 'Select', 'Insert', 'Update',
'References'
간단하게 말해서 서버는 승인(grant) 테이블을 다음과 같이 사용한다:
ㅇ user 테이블의 scope(범위) 필드는 들어오는 연결에 대해 허용할 것인지 거부할 것인지
를 결정한다. 허용된 연결에 대하여, 권한 필드는 사용자의 전체적인 (superuser) 권한을
가리킨다.
ㅇ db 와 host 테이블은 함께 사용된다:
- db 테이블의 범위 필드는 어떤 호스트에서 어떤 데이터베이스에 대해 어떤 사용
자가 접근할 수 있는지 결정한다. 권한 필드는 어떤 오퍼레이션이 허용되었는지를 결정한
다.
- host 테이블은 db 테이블의 엔트리를 여러개의 호스트에 적용하려고 할 때 db 테
이블의 확장을 위해 사용한다.예를 들어, 사용자가 현재 네트웍의 여러 호스트에서 데이터
베이스를 사용할 수 있도록 하려면,사용자의 "db" 테이블 엔트리에 Host 값을 비워두고, "h
ost" 테이블에 각 호스트의 엔트리를 넣으면 된다.이러한 절차는 6,6 [Request access]에
자세하게 나와 있다.
ㅇ tables_priv 와 columns_priv 테이블은 db 테이블과 비슷하다. 그렇지만 더 세부적으로
지정할 수 있다: 이 테이블들은 데이터베이스 단계에서 더 나아가 테이블과 컬럼 단계에 적
용할 수 있다.
관리 권한(reload, shutdown,기타..)은 오직 user 테이블에서만 지정을 할 수 있다는 것을
기억하자! 왜냐면 관리자 오퍼레이션은 서버 자체에 대한 오퍼레이션이며 특정한 데이터베
이스를 지정하는 것이 아니다. 그러므로 이러한 권한은 다른 승인(grant) 테이블에 있을 필
요가 없다.실제로, 오직 user 테이블만이 관리자 오퍼레이션을 수행할 수 있는지 없는지를
결정할 때 참고가 된다.
파일(file) 권한도 마찬가지로 user 테이블에서만 지정한다.위와 같은 관리 권한은 아니다.
그렇지만 서버 호스트에서 파일을 읽거나 쓸 수 있는 권한은 접근하고 있는 데이터베이스와
무관한 것이다.
mysqld 서버는 시작할 때 승인(grant) 테이블을 한번 읽는다. 승인 테이블을 변경하고 효과
를 발휘하려면 6.7 [Privilege changes]를 참고하자.
승인 테이블의 내용을 수정했을 때 원하는대로 권한이 설정되었는지 확인하는 것은 좋은 생
각이다. 유용한 진단 프로그램은 mysqlaccess 스크립트로서 Yves CArlier 가 mysql distrib
ution 으로 제공하고 있다. 어떻게 작동하고 있는지 확인하기 위해 mysqlaccess 에 --help
옵션을 주어 실행해보자. 물론 6.11 [Access denied] 와 6.12 [Security]를 참고하자.
mysqlaccess는 오직 user, db, host 테이블만 점검한다. 테이블이나 컬럼 단계의 권한까지
는 점검하지 않는다는 것을 기억하자.
6.5 접근 제어, 단계 1 : 연결 확인(인증)
mysql 서버에 접속하려고 할 때 서버는 사용자 확인과 비밀번호를 통해 접속을 허용하거나
거부한다. 사용자 확인이 안되면 서버는 접속을 완전히 거부한다. 사용자 확인이 되면 서버
는 연결을 받아들이고 2번째 단계로 들어가며 요청을 기다린다.
사용자 확인은 두가지 정보에 기반하고 있다:
ㅇ 접속하는 호스트
ㅇ mysql 사용자 이름
사용자 확인은 user 테이블의 세가지 범위 필드(Host, User, Password)를 사용하여 수행된
다. 서버는 user 테이블 엔트리의 호스트이름과 사용자 이름이 맞으며, 비밀번호가 정확할
때만 접속을 받아들인다.
아래와 같이 user 테이블의 범위 필드값을 지정할 수 있다:
ㅇ Host 값은 호스트 이름이나 IP 숫자 또는 로컬 호스트를 가리키는 'localhost' 가 될 것
이다.
ㅇ Host 필드에서 '%' 와 '_' 의 와일드카드 문자를 사용할 수 있다.
ㅇ '%'의 Host 값은 모든 호스트 이름을 나타낸다. 공백의 호스트 값은 '%'와 같다. 특정한
호스트에 대한 이러한 값은 당신의 서버에 연결할 수 있다는 것을 참고하자.
ㅇ 와일드카드 문자는 User 필드에는 허용되지 않는다. 그렇지만 모든 유저에 해당하는 공
백으로 둘 수 있다. 연결을 하려는 목록에 공백 사용자 이름이 있다면 클라이언트에서 실제
로 지정한 이름 대신에 그 사용자는 익명 사용자, 이름이 없는 사용자로서 간주된다.
ㅇ Password 필드는 공백으로 될 수 있다.이것은 아무런 비밀번호나 사용할 수 있다는 것을
의미하는 것은 아니며 사용자는 비밀번호를 지정하지 않고 연결을 해야 한다는 의미이다.
아래의 테이블은 연결 요청에 적용하는 "user" 테이블 목록의 Host, User 값이 어떻게 조합
되는지를 보여주는 예제이다:
호스트값/사용자 값 : 목록에 해당하는 연결
'thomas.loc.gov'/'fred' : thomas.loc.gov 에서 연결하는 fred
'thomas.loc.gov'/'' : thomas.loc.gov 에서 연결하는 모든 사용자
'%'/'fred' : 모든 호스트에서 연결하는 fred
'%'/'' : 모든 호스트에서 연결하는 모든 사용자
'%.loc.gov'/'fred' : loc.gov 도메인의 모든 호스트에서 연결하는 fred
'x.y.%'/'fred' : x.y.net, x.y.com, x.y.edu 등에서 접속하는 fred (이것은 아마도 유용하
지 않을 것이다)
'144.155.166.177'/'fred' : 144.155.166.177의 IP 주소에서 접속하는 fred
'144.155.166.%'/'fred' : 144.155.166 클래스 C 서브넷의 모든 호스트에서 접속하는 fred
Host 필드에서 IP에 와일드 카드를 사용할 수 있기 때문에(예를 들어 '144.155.166.%' 는
서브넷의 모든 호스트에 적용된다) 144.155.166.somewhere 와 같은 호스트 이름을 이용하여
부당하게 이용할 가능성이 생길 수 있다. 이러한 것을 막기 위해 mysql은 숫자와 도트(.)으
로 시작하는 호스트이름은 허용하지 않는다. 1.2.foo.com 과 같은 호스트라면 이러한 호스
트이름은 승인(grant) 테이블의 Host 컬럼과 매치되지 않는다. IP 숫자만이 IP 와일드 카드
값과 매치시킬 수 있다.
만약 한개 이상의 user table 목록이 있다면 서버는 어떻게 user table을 선택할까? 이런
경우에는 user table의 정렬 순서에 따라 해결을 하며 , 정열은 서버가 시작할때 수행이 된
다. user table이 다음과 같다고 가정해보자:
+-----------+----------+-
| Host | User | ...
+-----------+----------+-
| % | root | ...
| % | jeffrey | ...
| localhost | root | ...
| localhost | | ...
+-----------+----------+-
서버가 테이블을 읽을 때, 먼저 특정하게 지정된 값이 있는 호스트부터 목록을 정열한다.
(Host 컬럼에서 '%'는 "모든 호스트"를 의미하여 최소한도로 지정하는 것이다) 목록에서 호
스트값이 같으면 먼저 특정하게 지정된 사용자가 있는 것부터 정열한다.(공백으로 되어 있
는 User 값은 "모든 사용자"를 의미하여 최소한도로 지정하는 것이다.) 이렇게 하면 정열된
user 테이블은 다음과 같다:
+-----------+----------+-
| Host | User | ...
+-----------+----------+-
| localhost | root | ...
| localhost | | ...
| % | jeffrey | ...
| % | root | ...
+-----------+----------+-
정열된 순서에 따라 매칭 알고리즘이 적용되며 먼저 매칭되는 것을 사용한다. localhost에
서 jeffrey가 연결을 하려할때, Host 컬럼에서 'localhost' 목록이 먼저 매칭된다. 물론 사
용자 이름이 공백인 목록은 연결하는 호스트네임과 사용자 이름에 매칭된다. ('%'/'jeffrey
' 목록 또한 매칭이 된다. 그러나 테이블에서 처음으로 매칭되는 것은 아니다.)
다른 예제가 있다. user 테이블이 다음과 같다고 가정해보자:
+----------------+----------+-
| Host | User | ...
+----------------+----------+-
| % | jeffrey | ...
| thomas.loc.gov | | ...
+----------------+----------+-
정열된 테이블은 다음과 같다:
+----------------+----------+-
| Host | User | ...
+----------------+----------+-
| thomas.loc.gov | | ...
| % | jeffrey | ...
+----------------+----------+-
첫번째로 thomas.loc.gov에서 jeffrey가 연결하는 것이 매칭되며, whitehouse.gov 에서 jef
frey가 연결하는 거은 두번째로 매칭이 된다.
서버에 연결할 때 문제가 생기면, user 테이블을 출력하여 어떤 것이 먼저 매칭되는지 직접
정열을 하면 된다.
6.6 접근 제어, 2단계 : 요청 인증
{{}}연결되었다면 서버는 2단계로 들어간다. 연결이 성사되었을 때 각 요구에 대해 사용자가 수
행하려는 연산의 유형에 기반하여 서버는 사용자가 충분한 권한을 가지고 있는지 점검한다.
여기서 승인 테이블의 권한 필드가 작동한다. 권한은 user, db, host, table_priv, columns
_priv 테이블의 정보를 사용한다. GRANT 와 REVOKE 명령을 이용하여 권한 테이블을 다룰 수
있다. 7.25 [GRANT] 참고. (이전에 보았던 각 권한 테이블의 필드 목록을 참고하는 것이 도
움이 될 것이다; 6.4[Privilege] 참고.)
user 테이블의 승인 권한은 사용자에게 전체적인 기반을 제공하며 현재의 데이터가 어떤 것
인지와는 상관이 없다. 예를 들어, user 테이블에서 사용자에게 delete 권한을 승인했다면
서버 호스트에서 어떤 데이터베이스의 레코드라도 삭제할 수 있다! 다르게 말해서 user 테
이블 권한은 슈퍼유저 권한이며, 슈퍼유저(서버나 데이터베이스 관리자 등)에게만 user 테
이블에 대한 권한을 승인하는 것이 좋다. 다른 사용자에게는 user 테이블에서 권한을 'N'로
설정하고, db와 host 테이블을 사용하여 특정 데이터베이스에 기반한 권한승인을 하는게 좋
다.
db 와 host 테이블은 특정 데이터베이스의 권한을 승인한다. 각 테이블의 Host 와 Db 필드
에서 와일드카드 문자 '%' 와 '_' 를 사용할 수 있으며 값이 공백이면 필드 범위(scope fie
lds)에서 모든 값을 허용한다. '%' Host 값은 "모든 호스트"를 의미한다. db 테이블에서 Ho
st 값이 공백이면 "host 테이블에서 더 자세한 정보를 문의하라"는 의미이다. A '%' or bla
nk Db value in the host table means or "any database." (** or의 뜻이 무엇인지 모르겠
네요. host 테이블에서 Db 의 값이 '%' 또는 공백이면 "모든 데이터베이스"를 의미한다는
말 같은데요 **) User 값이 공백이면 익명 사용자로 간주된다.
서버가 시작할 때 db 와 host 테이블을 읽고 정열을 한다.(동시에 user 테이블을 읽는다.)
db 테이블은 Host, Db, User 순으로 필드 범위를 정열하며 host 테이블은 Host, Db 순으로
필드 범위를 정열한다. user 테이블과 같이 특정하게 지정되어 있는 값이 먼저 정열되고 최
소한도로 지정된 값이 나중에 정열된다. 서버에서 매칭되는 목록을 찾을때, 가장 먼저 발견
한 것을 사용한다.
tables_priv 와 columns_priv 테이블은 특정한 테이블과 컬럼에 관련된 권한을 승인한다.d
b와 host 테이블의 Host 필드와 같이 와일드카드를 Host 필드에서 사용할 수 있다. 그렇지
만 Db, Table_name, Column_name 필드에서는 와일드카드나 공백값을 사용할 수 없다.
Host 테이블에서만 와일드카드를 사용할 수 있지만 tables_priv 와 columns_priv 테이블은
db 테이블과 비슷하게 정열이 되며 정열은 간단하다.
요청 인증 과정은 아래에서 설명한다. 접근-점검 소스 코드에 친숙하다면, 여기서 설명하는
것은 코드에서 사용된 알고리즘과는 약간 다르다는 것을 알 수 있다.여기서의 설명은 코드
가 실제로 작동하는 방식과 동일하다. 단지 설명을 간단하게 하는데서 차이가 있는 것이다.
관리자 요청에 대해서(shutdown, reload 등) 서버는 단지 user 테이블만 체크를 한다. 왜냐
면 user 테이블에서만 관리자 권한을 지정하기 때문이다. 목록에서 요청된 연산을 허용하면
접근이 허용되며 아닌 경우에는 접근이 거부된다.예를 들어, mysqladmin shutdown을 실행하
고자 하는데 user 테이블 목록에서는 사용자에게 shutdown 권한을 승인하지 않으면, db나 h
ost 테이블을 체크하지 않더라도 접근이 거부된다. (이러한 테이블에는 Shutdown_priv 컬럼
이 없기 때문에 이렇게 할 필요도 없다)
데이터베이스와 관련된 요청에 대해(insert, update 등) 서버는 먼저 user 테이블 목록에서
사용자의 전체(슈퍼유저) 권한을 점검한다. 목록에서 요청한 연산을 허용하면 접근이 승인
된다.
user 테이블에서 전체적인 권한이 불충분하면, 서버는 db 와 host 테이블을 점검하여 데이
터베이스에 관련된 권한을 결정한다:
1. 서버는 db 테이블에서 매칭되는 Host, Db, User 필드를 찾는다. 연결하려는 사용자의 호
스트 이름과 Mysql 사용자 이름이 Host 와 User에 매칭되다. 사용자가 접근하기 원하는 데
이터베이스는 Db 필드에 매칭된다. 적합한 Host 와 User 목록이 없으면 접근은 거부된다.
2. 매칭되는 db 테이블 목록이 있고 Host 필드가 공백이 아니면, 목록은 사용자의 데이터베
이스 관련 권한을 정의한다.
3. 매칭되는 db 테이블 목록의 Host 필드가 공백이면, host 테이블에서 어떤 호스트가 데이
터베이스에 접근할 수 있는지 판단한다는 것을 의미한다. 이런 경우, 더 자세한 정보를 위
해 host 테이블에서 매칭되는 Host 와 Db 필드를 찾는다. host 테이블에 매칭되는 목록이
없으면 접근은 거부된다. 매칭되는 목록이 있으면 사용자의 데이터베이스 관련 권한은 db
와 host 테이블 목록에서 권한을 intersection 하여 결정된다.(** insertection은 교집합을
생각하면 되지요. and 조건 **) 다시 말해서, db와 host 테이블 둘 다 'Y'로 되어있을 때
권한이 설정된다.이러한 방법으로 db 테이블에서 일반적인 권한을 승인할 수 있으며, 그러
고나서 host 테이블 목록을 사용해 host를 기반으로 하여 선택적으로 권한을 제한할 수 있
다.)
db 와 host 테이블 목록을 이용해 데이터베이스와 관련된 권한 승인을 결정한 후, 서버는
이러한 정보를 user 테이블에서 승인한 전체적인 권한에 추가한다. 그 결과가 요청한 연산
을 허용하면 접근이 허용된다. 다른 방법으로, 서버는 tables_priv 와 columns_priv 테이블
에서 사용자의 테이블과 컬럼 권한을 점검하고 사용자의 권한에 추가한다. 그 결과에 따라
접근이 허용되거나 거부된다.
왜 서버에서 전체적인 사용자 엔트리 권한에 데이터베이스, 테이블, 컬럼에 관련된 권한을
추가하는지가 명확하지 않다.... 이런 경우 사용자 권한은 초기에 요청된 연산에 대하여 불
충분하다... (It may not be apparent why the server adds the database-, table- and col
umn-specific privileges to the global user entry privileges for those cases in which
the user privileges are initially found to be insufficient for the requested operatio
n.) 요청은 한가지 유형 이상의 권한이 필요하기 때문이다. 예를 들어, INSERT ... SELECT
문을 수행할 때 insert 와 select 권한 둘 다 필요하다. 사용자의 권한은 user 테이블에서
한가지 권한을 승인하고 db 테이블 엔트리에서 다른 권한을 승인할 것이다. 이런 경우, 사
용자는 이러한 요청을 수행하기 위해 필요한 권한을 가지고 있다. 그렇지만 서버는 자체적
으로 다른 테이블에 대해서는 .....(In this case, you have the necessary privileges to
perform the request, but the server cannot tell that from either table by itself;) ;
두 엔트리에 의해 승인된 권한이 조합되어야 한다.
host 테이블은 "안전한" 서버 목록을 유지하는데 사용할 수 있다. TcX에서는, host 테이블
에는 지역 네트웍의 모든 시스템이 포함되어 있다. 여기서는 모든 권한이 허용된다.
안전하지 않는 호스트를 가리키기 위해 host 테이블을 사용할 수 있다. 안전하다고 생각되
지 않는 공개 지역에 위치한 public.your.domain 시스템이 있다고 가정해보자. 사용자는 사
용자 네트웍의 모든 호스트에 접근할 수 있으며, host 테이블 엔트리가 다음과 같은 시스템
만 제외한다 :
+--------------------+----+-
| Host | Db | ...
+--------------------+----+-
| public.your.domain | % | ... (all privileges set to 'N')
| %.your.domain | % | ... (all privileges set to 'Y')
+--------------------+----+-
당연히 접근 권한이 원하는대로 되어 있는지 언제나 승인 테이블에서 목록을 테스팅해야 한
다. (예를 들어 mysqlaccess 를 사용)
6.7 권한 변경시 적용 방법
mysqld 가 시작할 때, 모든 승인 테이블 내용이 메모리로 올라가고 이때부터 유효하게 된
다.
GRANT, REVOKE, SET PASSWORD 를 이용해 승인 테이블에 변경을 하면 바로 서버에서 인식을
한다.
권한 테이블을 직접 변경했다면(INSERT, UPDATE 등을 사용하여), 서버에서 승인 테이블을
재가동하도록 하기 위해 FLUSH PRIVIEGES 문이나 mysqladmin flush-privileges 를 실행해야
한다.그렇게 하지 않으면 서버를 다시 시작하기 전까지 변경된 권한이 적용되지 않는다.
서버에서 권한 테이블이 변경되었다는 것을 감지했을 때, 이미 존재하던 클라이언트 연결은
다음과 같이 영향을 받는다:
1. 테이블과 컬럼 권한 변경은 클라이언트의 다음 요청부터 적용된다.
2. 데이터베이스 권한 변경은 다음의 USE db_name 명령부터 적용된다.
3. 전체적인 권한과 비밀번호 변경은 클라이언트가 다음에 연결할 때부터 적용된다.
{{}}
6.8 초기 mysql 권한설정
mysql을 설치하고 나서, mysql_install_db 스크립트를 실행해서 초기 접근 권한을 설정해야
한다. 4.7.1 [Quick install] 참고. mysql_install_db 스크립트는 mysqld 서버를 시작하고,
다음과 같이 승인 테이블의 권한을 초기화한다:
- mysql root 사용자는 슈퍼유저이며 모든 것을 할 수 있다. 로컬 호스트에서만 연결할 수
있다.
주의 : 처음에 root 비밀번호는 비어있다. 그래서 누구나 비밀번호없이 root로 연결할 수있
고 모든 권한을 승인받는다.
- 익명 사용자는 'test' 나 'test_' 로 시작하는 데이터베이스에 대한 모든 권한을 승인받
는다. 모든 사용자가 로컬 호스트에서 연결할 수 있으며 익명 사용자로 간주된다.
- 다른 권한은 거부된다. 예를 들어 일반 사용자는 mysqladmin shutdown 이나 mysqladmin p
rocesslist 를 사용할 수 없다.
설치했을 때 초기 권한이 폭넓게 설정되어 있기 때문에 가장 먼저 mysql root 사용자의 비
밀번호를 설정해야 한다. 다음과 같이 설정하면 된다. (PASSWORD() 함수를 이용해 비밀번호
를 설정해야 한다!):
shell> mysql -u root mysql
mysql> UPDATE user SET Password=PASSWORD('new_password')
WHERE user='root';
mysql> FLUSH PRIVILEGES;
or
shell> mysqladmin -u root password new_password
(** PASSWORD() 라는 함수를 사용하지 않아도 되므로 편리함. 또한 SQL문에서 grant 명령을
이용해 설정할 수도 있지요 **)
첫번째 방법을 사용하면 직접 user 테이블의 비밀번호를 업데이트한다. 이경우 서버가 다시
승인 테이블을 읽도록 해야 한다.(FLUSH PRIVILEGES 사용). 왜냐하면 다른 방법으로는 변경
사항을 알릴 수 없기 때문이다.
(** 승인 테이블을 다시 읽지 않아서 이전에 설정했던 비밀번호가 제대로 안되는 경우가 있
을 것입니다. 꼭 기억하고 있어야해요 **)
root 비밀번호가 설정되었으면 서버에 root로 접속할때마다 비밀번호를 명시해야 한다.
추가로 셋업을 하거나 테스트할 때는 비밀번호를 설정할 필요가 없기 때문에 root 비밀번호
를 빈값으로 남겨두고 싶을 것이다. 그렇지만 실제 작업을 하기 전에는 반드시 비밀번호를
설정했는지 확인해야 한다.
기본권한을 어떻게 설정하는지 mysql_install_db 스크립트를 살펴보자. 다른 사용자에게 권
한을 어떻게 설정할지 이것을 기본으로 사용할 수 있다.
위에서 설명한 것과 다르게 초기 권한을 설정하기 원하면, mysql_install_db 스크립트를 실
행하기 전에 수정하면 된다.
완전하게 승인 테이블을 다시 만들기 위해 mysql 데이터베이스를 포함하는 디렉토리의 '*IS
M' 과 '*.ISD' 파일을 제거해야 한다. (이 디렉토리는 database 디렉토리에서 'mysq''이라
는 이름이 붙어있다. mysqld --help 해서 database 디렉토리의 목록을 볼 수 있다.) 원하는
대로 권한을 수정한 후 mysql_install_db 스크립트를 실행하자.
6.9 mysql에 새로운 사용자 권한 추가하기
두가지 방법으로 사용자를 추가할 수 있다 : GRANT 문 사용 또는 mysql 승인 테이블 직접
조작. GRANT 문을 사용하는 것이 더 선호되는 방법이다.
아래의 예제는 새로운 사용자를 설정하기 위해 어떻게 mysql 클라이언트를 사용하는지 보여
준다. 이 예제는 이전에 설명했던것과 같이 기본값에 따라 권한을 설정하는 것으로 가정한
다. 이것은 설정을 바꾸기 위해 mysqld가 실행되고 있는 같은 시스템에 있어야 한다는 것을
말한다. (**초기값은 localhost에서만 접속 가능하므로**) 또한 mysql root 사용자로 접속
해야 하고 root 사용자는 mysql 데이터베이스에 대한 insert 권한과 reload 관리자 권한이
있어야 한다. root 사용자의 비밀번호를 바꾸었으면, 아래와 같이 mysql 명령행 상태에서
비밀번호를 명시해야 한다.
GRANT 문을 이용해 새로운 사용자를 추가할 수 있다:
shell> mysql --user=root mysql
mysql> GRANT ALL PRIVILEGES ON *.* TO monty@localhost
IDENTIFIED BY 'something' WITH GRANT OPTION;
mysql> GRANT ALL PRIVILEGES ON *.* TO monty@"%"
IDENTIFIED BY 'something' WITH GRANT OPTION;
mysql> GRANT RELOAD,PROCESS ON *.* TO admin@localhost;
mysql> GRANT USAGE ON *.* TO dummy@localhost;
위 GRANT 문에서는 세 명의 사용자를 설정한다:
monty : 어느 곳에서든 서버에 연결할 수 있는 완전한 슈퍼유저이지만 비밀번호를 사용해야
한다. 우리는 monty@localhost 와 monty@"%"를 사용한 GRANT 문에 대해서 반드시 논의를 해
야 한다. localhost 목록을 추가하지 않으면, mysql_install_db 에 의해 생성된 localhost
의 익명 사용자 목록(등록?)이 로컬 호스트에서 접속할때 우선권을 갖는다. 왜냐하면 지정
된 Host 필드 값이 있으며 정열 순서에서 먼저 오기 때문이다. (** 승인 테이블의 정열 순
서가 특정한 Host를 지정한 것부터 시작하는 것을 기억하자.
admin : 비밀번호 없이 localhost에서 접속할 수 있으며 reload와 process 관리자 권한을
승인받은 사용자. 이경우 사용자가 mysqladmin processlist 뿐만 아니라 mysqladmin reloa
d, mysqladmin refresh, mysqladmin flush-* 명령을 실행할 수 있다.데이터베이스와 관련된
권한은 승인되지 않았다. 이것은 추가적인 GRANT 문을 사용해 나중에 승인할 수 있다.
dummy : 비밀번호없이 연결할 수 있지만 오직 localhost에서만 연결 가능한 사용자. 권한
유형(privilege type)이 USAGE 이기 때문에 전체적인 권한이 'N'로 설정되어 있다. USAGE
는 아무런 권한도 설정하지 않는다. 나중에 데이터베이스와 관련된 권한을 승인할 수 있다.
또한 동일한 사용자 접근 정보를 INSERT 문을 통해 직접 추가할 수 있으며 이경우에는 서버
가 승인 테이블을 다시 읽도록 알려주어야 한다.(**FLUSH PRIVILEGES 사용**)
shell> mysql --user=root mysql
mysql> INSERT INTO user VALUES('localhost','monty',PASSWORD('something'),
'Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y')
mysql> INSERT INTO user VALUES('%','monty',PASSWORD('something'),
'Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y')
mysql> INSERT INTO user SET Host='localhost',User='admin',
Reload_priv='Y', Process_priv='Y';
mysql> INSERT INTO user (Host,User,Password)
VALUES('localhost','dummy',");
mysql> FLUSH PRIVILEGES;
mysql 버전에 따라 위에서 'Y' 값이 다를 수 있다는 것을 기억하자. 3.22.11 버전 이후에서
사용할 수 있는 확장된 INSERT 문은 여기서 admin 사용자에게 사용되었다.
슈퍼유저를 설정하기 위해 권한필드를 'Y'로 한 user 테이블 목록만 만들면 된다는 것을 기
억하자. db 나 host 테이블 목록은 필요없다. (** 관리자 권한은 db나 host 테이블과는 전
혀 관련이 없다. db는 접속할 수 있는 데이터베이스에 대해 상세하게 설정하고 host 테이블
은 db테이블을 좀 더 정교하게 설정하기 위해 필요한 것이다. 관리자 권한은 오직 user 테
이블만 관련되어있다 **)
마지막 INSERT 문(dummy 사용자)에서는 user 테이블의 권한 컬럼이 명확하게 설정되지 않았
다. 왜냐면 이 컬럼의 기본값은 'N'로 되어 있기 때문이다.
다음의 예제에서는 custom 이라는 사용자를 추가한다. custom은 localhost, server.domain,
whitehouse.gov에서 접속할 수 있다. localhost에서는 bankaccount 데이터베이스에만 접속
할 수 있으며 whitehouse.gov에서는 expenses 데이터베이스에, 모든 세 호스트상에서는 cus
tomer 데이터베이스에 접속하길 원한다. 모든 세 호스트상에서 stupid라는 비밀번호를 사용
하길 원한다.
GRANT 문을 이용 이러한 사용자 권한을 설정하기 위해 다음의 명령을 실행하자:
shell> mysql --user=root mysql
mysql> GRANT SELECT,INSERT,UPDATE,DELETE,CREATE,DROP
ON bankaccount.*
TO custom@localhost
IDENTIFIED BY 'stupid';
mysql> GRANT SELECT,INSERT,UPDATE,DELETE,CREATE,DROP
ON expenses.*
TO custom@whitehouse.gov
IDENTIFIED BY 'stupid';
mysql> GRANT SELECT,INSERT,UPDATE,DELETE,CREATE,DROP
ON customer.*
TO custom@'%'
IDENTIFIED BY 'stupid';
승인 테이블을 직접 수정해 사용자 권한을 설정하려면 다음의 명령을 사용하자. (마지막에
FLUSH PRIVILEGES 를 사용해야 한다는 것을 기억하자):
shell> mysql --user=root mysql
mysql> INSERT INTO user (Host,User,Password)
VALUES('localhost','custom',PASSWORD('stupid'));
mysql> INSERT INTO user (Host,User,Password)
VALUES('server.domain','custom',PASSWORD('stupid'));
mysql> INSERT INTO user (Host,User,Password)
VALUES('whitehouse.gov','custom',PASSWORD('stupid'));
mysql> INSERT INTO db
(Host,Db,User,Select_priv,Insert_priv,Update_priv,Delete_priv,
Create_priv,Drop_priv)
VALUES
('localhost','bankaccount','custom','Y','Y','Y','Y','Y','Y');
mysql> INSERT INTO db
(Host,Db,User,Select_priv,Insert_priv,Update_priv,Delete_priv,
Create_priv,Drop_priv)
VALUES
('whitehouse.gov','expenses','custom','Y','Y','Y','Y','Y','Y');
mysql> INSERT INTO db
(Host,Db,User,Select_priv,Insert_priv,Update_priv,Delete_priv,
Create_priv,Drop_priv)
VALUES('%','customer','custom','Y','Y','Y','Y','Y','Y');
mysql> FLUSH PRIVILEGES;
~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~~~~~
처음의 세가지 INSERT 문은 custom 사용자가 비밀번호를 사용하여 다양한 호스트에서 접속
할 수 있도록 user 테이블 목록을 추가한다. 그렇지만 그에게 어떠한 퍼미션도 승인하지 않
는다. (모든 권한은 기본값으로 'N' 이다) 다음의 세가지 INSERT 문은 적절한 호스트에서
접속을 할 때, custom 에게 bankaccount, expenses, customer 데이터베이스에 대한 권한을
승인하는 db 테이블 목록을 추가한다. 일반적으로 승인 테이블을 직접 수정하였으면, 변경
된 권한을 적용하기 위해 서버가 승인 테이블을 다시 읽도록 해 주어야 한다.
특정한 사용자가 특정한 도메인의 시스템에서 접속할 수 있도록 설정하고자 한다면, 다음과
같이 GRANT 문을 설정할 수 있다:
mysql> GRANT ...
ON *.*
TO myusername@"%.mydomainname.com"
IDENTIFIED BY 'mypassword';
승인 테이블을 직접 수정하려면 다음과 같이 한다:
mysql> INSERT INTO user VALUES ('%.mydomainname.com', 'myusername',
PASSWORD('mypassword'),...);
mysql> FLUSH PRIVILEGES;
~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~~~~
승인 테이블을 다루기 위해 xmysqladmin, mysql_webadmin, xmysql 프로그램을 사용할 수 있
다. http://www.mysql.com/Contrib 에서 이러한 유틸리티를 찾을 수 있다.
6.10 비밀번호 설정 방법
앞의 예제는 중요한 원칙을 보여준다 : INSERT 나 UPDATE 문에서 공백이 아닌 비밀번호를
저장할 때 반드시 암호화하기 위해 PASSWORD() 함수를 사용해야 한다!! user 테이블은 비밀
번호를 플레인텍스트(**일반 텍스트 파일**)가 아니라 암호화된 형태로 저장하기 때문이다.
이러한 사실을 잊어버리면 다음과 같이 비밀번호를 설정하려고 할 것이다:
shell> mysql -u root mysql
mysql> INSERT INTO user (Host,User,Password)
VALUES('%','jeffrey','bLa81m0');
mysql> FLUSH PRIVILEGES;
플레인텍스트 값 'bLa81m0' 은 user 테이블에 비밀번호로 저장이 된다.jeffrey라는 사용자
가 이 비밀번호를 사용해 서버에 연결하려고 할 때 mysql 클라이언트를 이 비밀번호를 암호
화해서 그 결과를 서버로 보낸다. 서버는 암호화된 비밀번호('bLa81m0'이 아니다)를 user
테이블의 비밀번호(플레인텍스트 'bLa81m0' 값이다)와 비교한다. 비교는 실패하고 서버는
연결을 거부한다:
shell> mysql -u jeffrey -pbLa81m0 test
Access denied
비밀번호는 user 테이블에 입력될 때 반드시 암호화되어야 하기 때문에, INSERT 문은 다음
과 같이 사용해야 한다:
mysql> INSERT INTO user (Host,User,Password)
VALUES('%','jeffrey',PASSWORD('bLa81m0'));
또한 SET PASSWORD 문을 사용할 때도 PASSWORD() 함수를 사용해야 한다:
mysql> SET PASSWORD FOR jeffrey@"%" = PASSWORD('bLa81m0');
참고 : PASSWORD() 함수는 비밀번호 암호화를 수행한다. 그렇지만 유닉스에서 비밀번호를
암호화하는 방법과는 다르다. 유닉스 비밀번호와 mysql 비밀번호가 동일할 때 PASSWORD()
가 유닉스 비밀번호 파일(** /etc/passwd 파일 **)에 암호화되어 저장된 값과 같다고 생각
하면 안 된다.
GRANT ... IDENTIFIED BY 문이나 mysqladmin password 명령을 사용해 비밀번호를 설정하면
PASSWORD() 함수는 필요없다. 둘다 비밀번호를 암호화해서 저장한다:
mysql> GRANT USAGE ON *.* TO jeffrey@"%" IDENTIFIED BY 'bLa81m0';
shell> mysqladmin -u jeffrey password bLa81m0
(** 당근, GRANT 문이나 mysqladmin password 명령을 사용하는게 편하겠지요? mysql의 암호
화 알고리즘이 유닉스와 다르듯 유닉스 계정과 mysql의 사용자는 전혀 다르다는 것도 다시
한번 기억하고 있어야 합니다.**)
6.11 접근 거부 에러가 나는 이유
mysql 서버에 연결하려 할 때 접근 거부 에러가 나면, 아래에서 설명하는 것에 따라 해결
방법을 찾을 수 있다:
- 초기 승인 테이블 내용을 설정하기 위해 mysql을 설치한 후 mysql_install_db 스크립트를
실행하였는가? 실행하지 않았다면 스크립트를 실행하자. 6.8 [Default privileges] 참고.
다음 명령을 이용해 초기 권한을 시험해 볼 수 있다:
shell> mysql -u root test
에러없이 서버에 접속할 수 있을 것이다. mysql 데이터베이스 디렉토리에 'user.ISD' 파일
이 있는지 확인해보아야 한다. (일반적으로 'mysql 설치 디렉토리/var/mysql/user.IDS' 이
다)
- 설치를 새로하고 난후 , 서버에 연결하고 사용자와 접근 권한을 설정해야 한다:
shell> mysql -u root mysql
초기에 mysql root 사용자만 비밀번호가 없기 때문에 서버에 연결할 수 있다. 보안문제가
있기 때문에, 다른 mysql 사용자를 설정하기 전에 먼저 root의 비밀번호를 설정해야 한다.
root로 접속하려하는데 다음의 에러가 났다고 가정하자:
Access denied for user: '@unknown' to database mysql
이것은 user 테이블에 User 컬럼 = root 라는 목록이 없고, mysqld가 사용자 클라이언트의
호스트이름을 해석할 수 없다는 것을 의미한다. 이런 경우 --skip-grant-tables 옵션을 이
용해 서버를 다시 시작해야 하고 '/etc/hosts' 를 편집하거나 '\windows\hosts' 파일에 사
용자 호스트 목록을 추가해야 한다.
- 3.22.11 이전 버전에서 3.22.11이나 이후 버전으로 업데이트했다면, mysql_fix_privilege
_tables 스크립트를 실행했는가? 하지 않았다면 실행하자. mysql 3.22.11에서 GRANT 문 기
능이 가능해지면서 승인 테이블 구조가 바뀌었다.
- (INSERT 나 UPDATE 문을 사용해) 승인 테이블을 직접 고쳤고 변화가 아직 반영되지 않은
것으로 보이면, FLUSH PRIVILEGES 문을 사용하거나 mysqladmin flush-privileges 명령을 사
용해 서버가 승인 테이블을 다시 읽도록 해야 한다는 것을 기억하자.그렇지 않으면 서버가
재시작하기 전까지는 변화된 것이 반영되지 않는다. root 비밀번호를 설정하고 나서 권한을
flush 하기까지는 비밀번호를 명시할 필요가 없다. 왜냐면 서버는 아직 비밀번호를 바꾸었
는지 모르기 때문이다.
- 세션 중간에 권한이 변경된 것으로 보이면 슈퍼유저가 바꾸었을 것이다. 승인 테이블을
재시작하는 것은 새로운 클라이언트 접속에 영향을 미치지만 이미 존재하고 있던 연결은 6.
7 [Privileges changes]에서 설명한대로 영향을 미친다.
- 시험하기 위해, mysqld 대몬에 --skip-grant-tables 옵션을 주어 시작하자. 그러고나서
mysql 승인 테이블을 변경할 수 있고 변경된것이 원하는대로 작동하는지를 체크하는 mysqla
ccess 스크립트를 사용할 수 있다. 원하는대로 수정이 되었으면 mysqld 서버가 새로운 승인
테이블로 시작할 있도록 mysq1admin flush-priveleges 를 실행한다.
주의 : 승인테이블을 재로딩하는 것은 --skip-grant-tables 옵션을 무효화한다. 이를 통해
서버를 다운시키고 다시 재시작하지 않고도 승인 테이블을 시작할 수 있다.
- 펄, Python, ODBC 프로그램에서 접근하는데 문제가 있다면, mysql -u user_name db_name
또는 mysql -u user_name -pyour_pass db_name 으로 서버에 접속을 시도해보자. (-p 와 비
밀번호사이에는 공백이 없다는 것을 기억하자. 또한 --password=your_pass 형태로도 사용할
수 있다) mysql 클라이언트로 접속이 되면 프로그램에 문제가 있는 것이며 접근 권한에는
문제가 없다.
- 비밀번호가 제대로 작동하지 않으면, INSERT, UPDATE, SET PASSWORD 문에서 비밀번호를
설정하면서 PASSWORD() 함수를 반드시 사용해야 한다는 것을 기억하자. PASSWORD() 함수는
GRANT ... INDENTIFIED BY 문이나 mysqladmin password 명령을 사용했다면 불필요하다. 6.1
0 [Passwords] 참고.
- localhost 는 지역 호스트 이름과 같은 말이다. 또한 호스트를 명백하게 설정하지 않은
경우 클라이언트에서 연결하려는 호스트의 기본값이다. 그러나 MIT-pthreads를 사용하는 시
스템에서는 localhost로의 연결이 제대로 작동하지 않는다. (localhost 연결은 유닉스 소켓
을 통해 만들어진다. 그렇지만 MIT-pthreads에서는 유닉스 소켓을 지원하지 않는다.) 이와
같은 시스템에서 문제를 피하려면, 서버에 호스트 이름을 명확하게 말해주기 위해 --host
옵션을 사용해야 한다. 그러면 mysqld 서버에 TCP/IP 연결을 만든다. 이경우, 서버 호스트
의 user 테이블 목록에 실제 호스트이름이 있어야 한다. (서버와 동일한 호스트에서 클라이
언트 프로그램을 실행한다고 하더라도 마찬가지이다.)
- mysql -u user_name db_name 으로 데이터베이스에 접속하려 할 때 접근 거부 에러가 나
면, user 테이블에 문제가 있을 것이다. mysql -u root mysql 를 실행하여 점검하고 다음의
SQL 문을 사용하자:
mysql> SELECT * FROM user;
여기서 사용자의 호스트이름과 mysql 사용자 이름과 맞는 Host 와 User 컬럼의 목록이 포함
되어 있어야 한다.
- Access denied 에러 메시지는 접속하려는 사용자와 호스트 이름, 그리고 비밀번호를 사용
했는지 여부를 보여줄 것이다. 일반적으로 user 테이블에 에러 메시지에서 보여준 호스트
이름과 사용자 이름과 정확하게 맞는 목록을 가지고 있어야 한다.
- 다른 시스템에서 mysql 서버에 접속할 때 다음의 에러 메시지가 나오면, user 테이블에
연결을 하려고 하는 호스트 이름이 없다는 것을 말한다:
Host ... is not allowed to connect to this MySQL server
(서버 호스트에서!) 명령행 유틸리티인 mysql을 사용하여 user 테이블에 연결하고자 하는
사용자/호스트 이름을 추가하여 해결할 수 있다. mysql 3.22 를 사용하고 있지 않고 연결하
고자 하는 시스템의 IP 숫자나 호스트 이름을 모른다면, user 테이블에 Host 컬럼 값으로
'%' 목록을 입력하고 서버 시스템에서 --log 옵션을 사용해 mysqld 를 재시작하자. 클라이
언트 시스템에서 연결을 시도한 후 mysql 로그에는 어떻게 실제로 연결을 했는지에 대한 정
보가 들어있다. (그러고나서 '%'를 로그에 나온 실제 호스트 이름으로 바꾼다. 그렇지 앟으
면 보안에 문제가 생길 수 있다.)
- mysql -u root test 는 작동을 하는데 mysql -h your_hostname -u root test 에서 접근에
에러가 나면, user 테이블에 정확한 호스트 이름이 없을 것이다. 일반적인 문제는 user 테
이블의 Host 값에는 완전하지 않은 호스트 이름(** 도메인은 빼고 호스트 이름만 넣은 경우
**) 이 들어가 있는데 시스템의 네임 해석 루틴은 FQDN(fully-qualified domain name - **
완전한 도메인 이름과 호스트 이름을 사용**)으로 처리하는 경우이다(또는 거꾸로 해석).예
를 들어, user 테이블에 호스트 이름이 'taejun' 으로 되어있는데, DNS는 mysql에 호스트
이름이 'taejun.subnet.se'라고 알려줄 수 있으며 이경우는 제대로 작동하지 않을 것이다.
user 테이블에 Host 컬럼 값으로서 해당하는 IP 숫자나 호스트 이름을 추가하자. (대신, us
er 테이블에 Host 값으로 와일드카드 문자를 포함할 수 있다. 예를 들어, 'taejun.%'. 그러
나 호스트이름 끝에 '%'를 사용하는 것은 안전하지 않으며 권하지도 않는다!)
- mysql -u user_name test 는 작동하는데 mysql -u user_name other_db_name 은 작동하지
않는다면 db 테이블에 other_db_name 목록이 없는 경우이다.
- 서버 시스템에서 mysql -u user_name db_name 은 작동을 하는데, 다른 클라이언트 시스템
에서 mysql -u user_name db_name 은 작동을 하지 않는다면, user 테이블이나 db 테이블에
클라이언트 시스템의 목록이 없는 것이다.
- 왜 Access denied 가 나는지 해결하지 못하면, user 테이블에서 와일드카드('%' 또는 '
_')를 포함하고 있는 Host 값을 가진 목록을 모두 제거하자. 매우 일반적인 에러는 Host='%
' 그리고 User='some user'로 입력을 하고나서 , 이렇게 하면 같은 시스템에서 연결할 때 l
ocalhost를 지정할 수 있도록 허용한다고 생각하는 것이다. 이것이 제대로 작동하지 않는
이유는 기본 권한에 Host='localhost' 와 User='' 목록이 포함되어 있기 때문이다. Host 값
에 '%' 보다 더 분명한 'localhost' 목록이 있기 때문에, localhost에서 접속할 때 새로운
목록보다 먼저 선택이 된다. 정확한 절차는 두번째 항목으로 Host='localhost' 와 User='so
me_user' 를 입력하거나 Host='localhost' 와 User='' 를 제거하는 것이다.
- 다음의 에러가 나는 경우:
Access to database denied
db 나 host 테이블에 문제가 있을 것이다. 선택한 db 테이블의 목록에 Host 컬럼이 비어있
다면, host 테이블에 db 테이블 목록에 적용되는 호스트 이름이 있는지를 확인해야 한다.
(** 일반적으로 db 테이블에 host 값을 비워두는 경우, host 테이블에서 접근하는 호스트를
제어할 수 있다 **)
- 다음의 에러가 나는 경우:
Access to database denied
SELECT ... INTO OUTFILE 또는 LOAD DATA INFILE 의 SQL 문을 사용하는 경우, user 테이블
목록에서 file 권한이 설정되어 있지 않았을 것이다.
- 다른 모든 것이 실패하였을 경우, mysqld 대몬을 디버깅 옵션으로 시작하자. (예를 들어,
--debug=d,general,query) 그러면 각 명령에서 생기는 정보와 함께, 접속을 시도하는 호스
트와 사용자에 대한 정보를 출력할 것이다. G.1 [Debugging] 참고.
- mysql 승인 테이블에서 다른 문제에 부딪쳤고 이 문제를 메일링리스트에 알려야겠다고 느
끼면, mysql 승인 테이블을 덤프하여 제공해야 한다. mysqldump mysql 명령을 사용해 테이
블을 덤프할 수 있다. 언제나 mysqlbug 스트립트를 사용하여 문제를 올리자.
- 다음의 에러가 나는 경우, mysqld 대몬이 실행되지 않거나 잘못된 소켓이나 포트로 연결
하려고 시도하는 경우:
Can't connect to local MySQL server
Can't connect to MySQL server on some_hostname
먼저 mysqld 대몬이 실제로 작동하는지 ps를 이용해 확인한다. 소켓 파일이 있느지 확인하
고 점검을 해 보아야 한다.(일반적으로 `/tmp/mysql.sock' 임) 또는 telnet host_name 3306
으로 접속을 시도해보자. 더 자세한 정보를 위해 mysqladmin version 과 mysqladmin -h hos
t_name version 을 사용해 볼 수 있다. 물론 참고할 것이 있는지 mysql 데이타 디렉토리의
에러 로그 파일을 점검해보자.
{{}}{{}}{{}}- 클라이언트 프로그램은 설정 파일이나 환경 변수에서 지정한 연결 패러미터를 사용할 수
있다는 것을 기억하자. 명령행에서 지정하지 않았는데 클라이언트가 잘못된 기본 연결 패러
미터를 보내는 것으로 생각되면, 홈 디렉토리에서 환경변수나 '.my.cnf' 파일을 점검해보
자. 비록 여기서 지정한 연결 패러미터와는 관계가 멀지만 시스템의 전반적인 mysql 설정
파일을 점검해 볼 수 있다. 4.14.4 [Option files] 참고. 클라이언트에서 아무런 옵션도 주
지 않았는데 Access denied 에러 메시지가 나오는 경우, 옵션 파일 중에서 예전의 비밀번호
를 지정하지 않았는지 확인해 보자. 4.14.4 [Option files] 참고.
6.12 크랙커에 대비하여 mysql을 안전하게 하는 방법
mysql 서버에 연결할 때 일반적으로 비밀번호를 사용해야 한다. 비밀번호는 연결할 때 단순
한 텍스트로 전송되지 않는다.
서버/클라이언트 연결은 암호화되지 않는다; 모든 정보는 연결을 볼 수 있는 누구라도 읽을
수 있는 텍스트로 전송된다. 이 문제에 대해 걱정이 되면 문제를 어렵게 하기 위해 압축 프
로토콜(mysql 3.22 이상 버전)을 사용할 수 있다. 보안을 더 확실하게 하기 위해 ssh를 설
치할 수 있다. (http://www.cs.hut.fi/ssh 참고) 이것을 이용해 mysql 서버와 클라이언트
사이에 암호화된 TCP/IP 연결을 사용할 수 있다.
mysql 시스템의 보안을 유지하게 위해 다음의 제안을 신중하게 고려하자:
- 모든 mysql 사용자가 비밀번호를 사용. 어떤 사용자가 비밀번호가 없으면 'mysql - u 사
용자이름' 을 이용해 간단하게 그 사용자로 로그인할 수 있다는 것을 기억하자. 이것은 클
라이언트/서버 애플리케이션의 일반적인 작동방법이다. mysql_install_db 스크립트를 실행
하기 전에 이 스크립트를 수정하여 모든 사용자의 비밀번호를 바꿀 수 있다. 또는 mysql ro
ot 사용자의 비밀번호를 바꿀 때는 다음과 같이 하면 된다:
shell> mysql -u root mysql
mysql> UPDATE user SET Password=PASSWORD('new_password')
WHERE user='root';
mysql> FLUSH PRIVILEGES;
- mysql 데몬을 유닉스의 root 사용자로 시작하지 말자. mysqld 는 다른 사용자가 실행할
수 있다.또한 보안을 더 엄격하게 하기 위해 mysql이라는 유닉스 사용자를 만들 수 있다.
다른 유닉스 사용자로 mysqld를 실행하면 user 테이블에서 root 사용자 이름을 바꿀 필요가
없다. mysqld를 다른 유닉스 사용자가 시작하기 위해 mysql.server 스크립트를 수정하면 된
다. 일반적으로 su 명령을 사용한다. 더 자세한 내용은 16.7 [Changing mysql user] 참고.
- mysqld를 실행할 수 있는 사용자만이 데이터베이스 디렉토리에 읽기/쓰기 권한을 가지고
있는지 확인.
- 모든 사용자에게 process 권한을 주지 말자. mysqladmin processlist 을 출력하면 현재
실행하는 쿼리의 내용을 볼 수 있다. 그러므로 이러한 명령을 실행할 권한이 있는 사용자는
다른 사용자의 UPDATE user SET password=PASSWORD(_'no_secure') 질의를 볼 수 있다.mysql
은 process 권한을 가진 사용자를 위해 추가적인(extra) 연결을 저장한다.그래서 mysql roo
t 사용자는 모든 일반적인 연결이 사용되었어도 로그인하고 점검을 할 수 있다.
- 모든 사용자에게 file 권한을 주지 말자. 이러한 권한이 있는 사용자는 mysqld 대몬의 권
한이 있는 파일 시스템의 어느 곳에라도 파일을 저장할 수 있다.좀 더 안전하게 하기 위해
SELECT ... INTO OUTFILE 로 생성되는 모든 파일은 모든 사용자가 읽기만 할 수 있으며 이
미 존재하는 파일을 덮어씌울 수 없다.
(** file 권한은 LOAD DATA INFILE , SELECT .. INTO OUTFILE 문을 이용하여 서버에 파일을
저장하고 읽을 수 있는 권한을 허용한다. 이러한 권한을 가진 사용자는 mysql 서버가 읽고
쓸 수 있는 파일을 읽고 쓸 수 있는 권한이 허용된다. 일반 사용자에게 이런 권한을 줄 필
요는 없다. 필요한 부분만 권한을 주는 것이 좋다. 권한을 남용말자. **)
- DNS 를 신뢰하지 못한다면 승인 테입르에서 호스트이름 대신 IP를 사용하자. 기본적으로
mysqld 의 --secure 옵션은 호스트이름을 안전하게 한다. 어떤 경우 와일드카드 문자가 포
함된 호스트이름 값을 사용할때는 매우 조심해야 한다.
- mysql.server 스크립트에서 유닉스 root 사용자의 비밀번호를 넣는다면, 이 스크립트는
오직 root만이 읽을 수 있도록 해야 한다.
다음의 mysqld 옵션은 보안과 관련되어 있다:
--secure : gethostbyname() 시스템 콜에 의해 리턴된 IP 숫자가 원래의 호스트이름을 reso
lve 한 것과 같은지를 점검한다. 이것은 어떤 사람이 다른 호스트 이름을 에뮬레이터해서
접근하는 것을 어렵게 만든다. 이 옵션은 또한 호스트이름이 온전한지에 대한 점검을 추가
한다. 해석하는데 때로는 시간이 많이 걸려서 mysql 3.21에서는 기본적으로 설정이 되어 있
지 않다. mysql 3.22에서는 호스트이름을 캐쉬하고 이 옵션이 기본적으로 설정되어 있다.
(** 함수 gethostbyname()은 호스트 이름을 인자로 받아 그에 해당하는 IP 주소 및 기타 정
보를 해당하는 구조체에 담아 그 구조체의 포인터를 리턴하는 함수입니다. 쉽게 말해서 호
스트 이름을 넣으면 해당 IP 주소를 찾아주지요.**)
--skip-grant-tables : 이 옵션을 사용하면 서버가 권한 시스템을 전혀 사용하지 않는다.
그러면 모든 사용자가 모든 데이터베이스에 접속할 수 있다! (mysqladmin reload 를 실행하
여 실행중인 서버가 승인 테이블을 사용하도록 할 수 있다.)
--skip-name-resolve : 호스트이름이 해석되지 않는다. 승인 테이블의 모든 Host 컬럼값은
반드시 IP 숫자이거나 로컬호스트이어야 한다.
--skip-networking : 네트웍을 통한 TCP/IP 연결을 허용안함. mysqld와 모든 연결은 유닉스
도메인 소켓을 통해 만들어진다. 이 옵션은 MIT-pthreads를 사용하는 시스템에서는 제대로
작동을 하지 않는다. 왜냐면 MIT-pthreads 패키지는 유닉스 소켓을 지원하지 않기 때문이
다. (** 리눅스를 사용하는 사람들에게는 상관없겠죠? 유닉스 도메인 소켓을 지원하니깐.
이와 비슷하게 postgres도 6.3버전 이후부터인가요? 기본적으로 유닉스 도메인 소켓으로 바
뀌었지요. **)
9. mysql 서버 기능(functions)
9.1 mysql에서 지원하는 언어
mysqld의 에러 메시지는 다음의 언어로 나타날 수 있습니다. : Czech, Dutch, English(기본
값), 기타 등등 (** 기타 언어는 매뉴얼 참고. 한글, 일본어 등 동양권은 여기서 빠져있습니
다. 9.1.1 절을 참고하세요. **)
mysqld를 특정한 언어로 시작하려면 --language=lang 또는 -L lang 옵션을 사용하면 됩니
다.
예> # mysqld--language=swedish
또는
# mysqld --language=/usr/local/share/swedish
모든 언어는 소문자로 표기합니다.
언어 파일은 (기본값으로) 'mysql_base_dir/share/LANGUAGE/'에 있습니다.
에러 메시지 파일을 업데이트하려면 'errmsg.txt' 파일을 편집하고 'errmsg.sys' 파일을 만
들기 위해 다음의 명령을 사용합니다.
# comp_err errmsg.txt errmsg.sys
만약 mysql의 새로운 버전으로 업그레이드하면 새로운 'errmsg.txt' 파일로 위와 같은 과정
을 거쳐야 합니다.
9.1.1 데이터와 정열에 사용하는 문자 셋
기본적으로 mysql은 ISO-8859-1 (Latin 1) 문자 셋을 사용합니다. 이 문자셋은 미국과 서유
럽에서 사용하는 문자 셋입니다.
문자셋은 이름에 어떤 문자셋을 사용할 수 있는지 그리고 SELECT 문에서 ORDER BY 와
GROUP BY 문을 사용할 때 어떻게 정렬되는지를 결정합니다.
컴파일할때 configure에서 --with-charset=charset 옵션을 사용하여 문자셋을 바꿀 수 있습
니다. 자세한 것은 4.7.1 을 참고하세요.
(** 한글을 사용하기 위해서 이 부분은 중요합니다. 우리는 컴파일할때 문자셋을 sjis로 바
꾸어 주면 됩니다. sjis는 일본어 2바이트 문자 셋입니다. 이렇게 해야 정렬이 제대로 되고
정규표현식을 사용할 수 있습니다. **)
9.1.2 새로운 문자셋 추가
** 생략 **
9.1.3 멀티바이트 문자 지원
멀티 바이스 문자셋을 만들면 _MB 매크로를 사용할 수 있습니다.
** 생략 **
9.2 업데이트 로그
mysqld를 시작할 때 --log-update=file_name 옵션을 사용하면 mysqld는 데이타를 업데이
트한 모든 sql 문을 포함하는 로그 파일을 기록합니다. 파일은 data 디렉토리(** 보통
mysql 설치 디렉토리 밑의 data 디렉토리 **)에 기록되며 file_name.# 형태로 됩니다. #은
mysqladmin refresh 나 mysqladmin flush -logs, FLUSH LOGS 문, 또는 서버를 재시작할
때마다 증가됩니다.
--log 나 -l 옵션을 사용하면 파일 이름은 'hostname.log'가 되며, restart나 refreshes를 해
도 새로운 로그 파일이 만들어지지 않습니다. 기본적으로 mysql.server 스크립트는 -l 옵션
으로 mysql 서버를 시작합니다. production enviroment(?)를 사용하여 시작할때 더 나은 성
능이 필요하면 mysql.server에서 -l 옵션을 제거할 수 있습니다.
업데이트 로그는 지능적이서 실제로 데이타가 업데이트될 때만 로그 기록을 남깁니다. 그래
서 WHERE를 사용한 UPDATE나 DELETE에서 해당하는 레코드를 찾지 못하면 로그 파일
에 기록하지 않습니다. 또한 이미 존재하는 값을 사용할때도 Update 문은 무시됩니다.
업데이트 로그 파일에서 데이터베이스를 업데이트하려면 다음과 같이 하면 됩니다. (로그
파일이 'file_name.#'의 형태라고 가정)
# ls -1 -t -r file_name.[0-9]* | xargs cat | mysql
ls는 정확한 순서로 모든 로그 파일을 가져올 때 사용합니다.
이것은 데이터베이스에 손상이 생긴 뒤 백업 파일로 복구할 때 유용하며, 백업과 손상이 생
긴 시간 사이에 일어난 업데이트를 다시 할때(redo) 사용할 수 있습니다.
또한 다른 호스트에 미러링된 데이터베이스를 가지고 있으며 마스터 데이터베이스에 생긴
변화를 복사할때 업데이트 로그를 사용할 수 있습니다.
9.3 mysql 테이블 최대 크기
mysql 자체는 테이블 최대 크기가 4G이며 운영 시스템은 각자의 고유한 파일 크기 제한이
있습니다. 리눅스에서는 현재 2G 입니다. 솔라리스 2.5.1에서는 4G이며, 솔라리스 2.6에서는
1000G가 될 것입니다. 현재 테이블 크기 제한은 4G이거나, (MYSQL 제한) 운영 시스템 제
한입니다. 4G 이상으로 확대하기 위해 앞으로 mysql을 바꿀 것입니다. 부록 F를 참고하세
요.
거대 테이블을 읽기 전용으로 하면 많은 테이블을 하나로 모으고 압축하는 pack_isam 을
사용할 수 있습니다. pack_isam은 일반적으로 테이블을 최소 50% 압축하여 효과적으로 더
큰 테이블을 사용할 수 있습니다. 12.3 [pack_isam]을 참고하세요.
다른 솔루션은 MERGE 라이브러리에 포함되어 있으며 identical 테이블을 모아 하나로 관
리할 수 있습니다. (여기서 Identical은 모든 테이블이 identical 컬럼 정보로 만들어진다는
것을 의미합니다.) 현재 MERGE는 인덱스를 지원하지 않기 때문에 테이블의 모음
(collection)만을 검색하는데만 사용할 수 있습니다. 가까운 시일내에 여기에 인덱스를 추가
할 것입니다.
(** 참고로 읽기 전용 테이블은 mysql에 라이센스를 지불하고 구입했을 때만 만들 수 있습
니다. 단지 읽기만 하는 것은 가능하지만 압축이 된 읽기 전용 테이블은 만들 수 없습니다.
**)
10. mysql의 최대 성능 향상 방법
10.1 버퍼 크기 조정
mysqld 서버가 사용하는 기본 버퍼 크기는 다음의 명령으로 알 수 있다.
shell> mysqld --help
이 명령은 모든 mysqld 옵션의 목록과 설정 변수를 보여준다. 출력되는 내용은 기본값을
포함하고 있으며 다음과 비슷하다.
Possible variables for option --set-variable (-O) are:
back_log current value: 5
connect_timeout current value: 5
join_buffer current value: 131072
key_buffer current value: 1048540
long_query_time current value: 10
max_allowed_packet current value: 1048576
max_connections current value: 90
max_connect_errors current value: 10
max_join_size current value: 4294967295
max_sort_length current value: 1024
net_buffer_length current value: 16384
record_buffer current value: 131072
sort_buffer current value: 2097116
table_cache current value: 64
tmp_table_size current value: 1048576
thread_stack current value: 131072
wait_timeout current value: 28800
mysqld 서버가 현재 가동중이면 다음의 명령을 통해 실제 변수값을 볼 수 있다.
shell> mysqladmin variables
각 옵션은 밑에서 설명한다. 버퍼 크기, 길이, 스택 크기는 바이트이다. 'K'(킬로바이트)
나 'M'(메가바이트)를 앞에 붙여 값을 지정할 수 있다. 예를 들면 16M는 16 메가바이트를
가리킨다. 대소문자는 구별하지 않는다. 16M 와 16m은 같다.
-back_log
mysql이 가질 수 있는 최대 연결 요청의 수. 이것은 main mysql 스레드가 매우 짧은 시간
동안 매우 많은 연결 요청을 받을 때 기능을 한다. 이때 메인 스레드가 연결을 체크하고 새
로운 스레드를 시작하는데는 약간의 시간이 걸린다.(그러나 아주 짧은 시간임) back_log 값
은 mysql이 순간적으로 새로운 요청에 답하는 것을 멈추기전에 이 짧은 시간동안 얼마나
많은 요청을 쌓아두고 있는지를 지정한다. 매우 짧은 시간동안 매우 많은 연결이 예상될때
만 이 값을 증가시켜야 한다.
다른 말로 이 값은 tcp/ip 연결을 받는 listen queue의 크기이다. 각 운영체제마다 이러한 큐
의 크기에 한계가 있다. Unix system call listen(2) 매뉴얼페이지에 자세한 정보가 있다. ba
ck_log값의 한계는 운영체제 문서를 확인해봐라. back_log를 최대값보다 더 높여도 효과가
없다.
-connect_timeout
Bad handshake에 반응하기 전에 연결 패킷을 mysql 서버에서 기다리는 시간.(초)
-join_buffer
(인덱스를 사용하지 않는 조인의) full-join에서 사용하는 버퍼의 크기. 버퍼는 두 테이블 사
이에서 각 full-join마다 한번 할당이 된다. 인덱싱을 추가하지 못할 때 조인 버퍼를 증가시
키면 full join의 속도를 향상시킬 수 있다. (일반적으로 빠르게 조인을 하는 가장 좋은 방법
은인덱스를 추가하는 것이다)
-key_buffer
인덱스 블락은 버퍼링되고 모든 스레드에서 공유한다. 키 버퍼는 인덱스 블락에서 사용하는
버퍼의 크기이다. 인덱스가 많은 테이블에서 delete나 insert 작업을 많이 하면 키 버퍼값을
증가시키는 것이 좋다. 더 빠른 속도를 내려면 LOCK TABLES를 사용하자. [Lock Tables]
참고.
-max_allowed_packet
한 패킷의 최대 크기. 메시지 버퍼는 net_buffer_length 바이트로 초기화되지만 필요하면 최
대 허용 패킷 바이트를 증가시킬 수 있다.기본값은 큰 패킷을 잡기에는 작다. 거대 BLOB
컬럼을 사용한다면 값을 증가시켜야 한다. 사용자가 원하는 최대 blob만큼 크게 해야 한다.
-max_connections
동시 클라이언트 숫자. mysqld가 필요로하는 파일 지시자(descriptor)의 숫자만큼 값을 늘려
야 한다. 밑에서 파일 디스크립터 제한에 대한 내용을 참고하자.
-max_connect_errors
호스트에서 최대 연결 에러이상의 interrupted 연결이 있으면 더 많은 연결을 위해 호스트는
block화된다. FLUSH HOSTS 명령으로 호스트의 block을 해제할 수 있다.
-max_join_size
최대 조인 크기이상으로 레크도를 읽는 조인을 하면 에러가 난다. 만약 사용자가 where 문
을 사용하지 않고 시간이 많이 걸리면서 몇백만개의 레코드를 읽는 조인을 수행하려 하면
이 값을 설정한다.
-max_sort_length
BLOB나 TEXT 값으로 정열할때 사용하는 바이트의 숫자. (각 값중 오직 첫번째 max_sort
_length 바이트만 사용된다. 나머지는 무시된다)
-net_buffer_length
질의에서 통신 버퍼가 초기화되는 크기. 일반적으로 바뀌지 않지만 매우 적은 메모리를 가
지고 있을 때 예상되는 질의에 맞게 세팅할 수 있다. (이것은 클라이언트에 가는 예상된 sql
문의 길이이다. 질의문이 이 크기를 넘으면 버퍼는 자동으로 max_allowed_packet 바이트까
지 증가한다)
-record_buffer
순차적인 검색을 하는 각 스레드에서 각 검색 테이블에 할당하는 버퍼 크기. 순차적인 검색
을 많이 하면 이 값을 증가시켜야 한다.
-sort_buffer
정렬이 필요한 각 스레드에서 할당하는 버퍼 크기. order by 나 group by 오퍼레이션을 빠
르게 하려면 이 값을 증가시킨다. 16.4 [임시 파일] 참고.
-table_cache
모든 스레드에서 열 수 있는 테이블의 숫자. mysqld가 필요로 하는 파일 디스크립터의 숫
자만큼 이 값을 증가시켜라. mysql은 각 유일한 오픈 테이블에서 두개의 파일 디스크립터가
필요하다. 파일 디스크립터 제한을 참고한다. 테이블 캐쉬가 어떻게 작동하는지는 10.6 [테
이블 캐쉬]를 참고한다.
-tmp_table_size
임시 테이블이 이 값을 넘으면 mysql은 "The Table tbl_name is full"이라는 에러 메시지를
낸다. 매우 많은 group by 질의를 사용하면 이 값을 증가시켜야 한다.
-thread_stack
각 스레드의 스택 사이즈. creash-me test(**역자주 : 데이터베이스의 벤치마킹을 하는 테스
트입니다. 말그대로 데이터베이스를 죽여주지요) 에서 잡히는 많은 제한은 이 값에 달려있
다. 기본값은 일반적으로 충분히 크다. 11장의 [벤치마크] 참조
-wait_timeout
연결을 끊기전에 연결 활동(activity)을 서버에서 기다리는 시간(초).
table_cache 와 max_connections는 서버가 열 수 있는 최대 파일 갯수에 영향을 미친다. 이
값을 증가시키면 운영시스템에서 오픈 파일 디스크립터의 per-process 숫자의 한계까지 올
릴 수 있다. (** ... imposed by your operating system on the per-process number of
open file descriptors. 번역이 이상하므로 영문 참고)
그러나 많은 시스템에서 이 한계를 증가시킬수 있다. 이렇게 하려면 각 시스템에서 이 한계
를 변화시키는 방법이 매우 다양하므로 운영체제 문서를 참고해야 한다.
table_cache 는 max_connections 와 관계가 있다. 예를 들면 200개의 연결이 있으면 최소 2
00 * n 의 테이블 캐쉬를 가져야 한다. 여기서 n은 조인에서 테이블의 최대 숫자이다.
mysql은 매우 유용한 알고리즘을 사용하기 때문에 일반적으로는 매우 적은 메모리로 사용
할 수 있으며 메모리가 많을 수록 성능이 더 많이 향상된다.
많은 메모리와 많은 테이블을 가졌고 중간정도 숫자의클라이언트에서 최대의 성능을 원한다
면 다음과 같이 사용한다.
shell> safe_mysqld -O key_buffer=16M -O table_cache=128 \
-O sort_buffer=4M -O record_buffer=1M &
메모리가 적고 연결이 많으면 다음과 같이 사용한다.
shell> safe_mysqld -O key_buffer=512k -O sort_buffer=100k \
-O record_buffer=100k &
또는:
shell> safe_mysqld -O key_buffer=512k -O sort_buffer=16k \
-O table_cache=32 -O record_buffer=8k -O net_buffer=1K &
매우 많은 연결이 있을 때 mysqld가 각 연결마다 최소한의 메모리를 사용하도록 설정하지
않았다면 "swapping problems" 문제가 생길 것이다.
mysqld에서 옵션을 바꾸었으면 그것은 서버의 해당하는 인스턴스에만 영향을 미친다는 것
을 기억하자.
옵션을 바꾸었을때의 효과를 보기 위해 다음과 같이 해보자.
shell> mysqld -O key_buffer=32m --help
마지막에 --help 옵션이 들어간 것을 기억하자. 그렇지 않으면 커맨드 라인에서 사용한 옵
션의 효력은 출력에는 반영되지 않을 것이다.
10.2 메모리 사용 방법 <메모리 최적화>
아래에서 설명하는 목록은 mysqld 서버가 메모리를 사용하는 방법에 대해서 나타내고 있
다. 메모리 사용과 관련된 서버의 변수 이름이 주어진다.
- 키 버퍼(변수 key_buffer)는 모든 스레드에서 공유한다. 서버에서 사용하는 다른 버퍼는
필요한대로 할당이 된다.
- 각 연결은 각 스레드마다의 특정한 공간을 사용한다. 스택(64k, 변수 thread_stack) , 연결
버퍼(변수 net_buffer_length), result 버퍼 (변수 net_buffer_length) 등. 연결 버퍼와 result
버퍼는 필요할때 max_allowed_packet 까지 동적으로 증가된다. 질의가 수행될 때 현재의
질의문의 복사문이 또한 할당이 된다.
(** When a query is running a copy of the current query string is also alloced.)
- 모든 스레드는 같은 기본 메모리를 공유한다.
- 메모리 맵은 아직 지원이 안된다. (압축 테이블을 제외하고. 그러나 이것은 다른 이야기이
다) 왜냐하면 4GB의 32비트 메모리 공간은 대부분의 대형 테이블에서 충분히 크기가 않기
때문이다. 우리가 64비트 주소 공간을 가진 시스템을 가지게 될 때 우리는 메모리 맵핑을
위한 일반적인 지원을 추가할 것이다.
- 테이블에서 순차적인 검색을 하는 각 요청은 read 버퍼에 할당이 된다. (변수 record_buff
er)
- 모든 조인은 한번에 수행이 되며 대부분의 조인은 임시 테이블을 생성하지 않고 수행이
된다. 대부분의 테이블은 메모리 기반(HEAP) 테이블이다. 거대 길이의 레코드를 가졌거나
BLOB 컬럼을 포함한 임시 테이블은 디스크에 저장이 된다. 현재의 문제는 메모리 기반 테
이블이 tmp_table_size를 초과했을때 "The table tbl_name is full"이라는 에러가 생기는 것
이다. 가까운 시일안에 필요할때 자동적으로 메모리 기반(HEAP) 테이블을 디스크 기반(NI
SAM) 테이블로 바꾸도록 고칠 것이다.
이 문제를 해결하기 위해서 mysqld의 tmp_table_size 옵션을 설정하여 임시 테이블 크기를
늘이거나 클라이언트 프로그램에서 SQL_BIG_TABLES라는 sql 옵션을 설정하여야 한다. 7.
24 SET OPTION 을 참고하자.
mysql 3.20에서 임시 테이블의 최대 크기는 record_buffer*16이다. 3.20 버전을 사용하고 있
다면 record_buffer의 값을 증가시켜야 한다. 또한 mysqld를 시작할 때 --big-tables 옵션을
사용하여 항상 임시 테이블을 디스크에 저장할 수 있지만 질의 속도에 영향을 미친다.
- 정열을 하는 대부분의 요청은 정렬 버퍼와 하나나 두개의 임시 파일을 할당한다. 16.4의
[임시 파일]을 참고한다.
- 대부분의 파징(parsing)과 계산은 지역 메모리에서 이루어진다. 작은 아이템에는 메모리 o
verhead가 필요없고 일반적인 느린 메모리 할당(slow memory allocation)과 freeing(메모리
해제)는 무시된다. 메모리는 오직 예상지 못한 거대 문자열에서 할당이 된다.( mallloc() 과
free() 사용)
- 각 인덱스 파일은 한번에 열리며 각 병행수행되는 스레드에서 데이터 파일은 한번에 열
린다. 각 병행수행 스레드마다 테이블 구조, 각 컬럼의 컬럼 구조, 3 * n 의 버퍼 크기가 할
당된다. ( n은 최대 레코드 길이이며 BLOB 컬럼은 해당하지 않는다) BLOB는 BLOB 데이
터의 길이에 5에서 8 바이트를 더한 값을 사용한다.
- BLOB 컬럼을 가진 각 테이블에서 버퍼는 거대 BLOB 값을 읽을 수 있도록 동적으로 커
진다. 테이블을 검색하면 버퍼는 최대 BLOB의 값만큼 버퍼가 할당이 된다.
- 모든 사용중인 테이블의 테이블 핸들러는 캐쉬에 저장되며 FIFO로 관리가 된다. 일반적
으로 캐쉬는 64 엔트리를 갖는다. 동시에 두개의 실행 스레드에서 테이블을 사용하면 캐쉬
는 테이블의 두 엔트리를 포함한다. 10.6 [테이블 캐쉬]를 참고한다.
- mysqladmin flush-tables 명령은 사용하지 않는 모든 테이블을 닫고 현재 실행되는 스레
드가 끝날 때 모든 사용중인 테이블을 닫는다고 표시한다. 이것은 효과적으로 사용중인 메
모리를 해제한다.
ps 와 다른 시스템 상황 프로그램은 mysqld가 많은 메모리를 사용하고 있다고 보고할 것이
다. 이것은 다른 메모리 주소의 스레드-스택때문에 생긴다. 예를 들면 솔라리스의 ps 는 스
택사이의 사용하지 않는 메모리를 사용하는 메모리로 간주한다. 이것은 swap -s를 이용 사
용가능한 스왑을 체크하여 확인할수 있다. 우리는 mysqld를 상용 메모리 유출 측정 프로그
램으로 테스팅해서 mysqld에는 메모리 유출이 없다.
10.3 속도 향상에 영향을 미치는 컴파일/링크 방법 <컴파일시 최적화하기>
다음 테스트의 대부분은 리눅스와 mysql 벤치마크를 가지고 수행되었지만 다른 운영 시스
템에도 암시해주는 것이 있다.
static으로 링크를 할때 가장 빠른 실행 속도를 얻을 수 있다. 데이터베이스에 연결하기 위
해 TCP/IP보다는 유닉스 소켓을 사용하면 더 좋은 성능을 낼 수 있다.
리눅스에서 pgcc와 -O6을 사용하면 가장 빠르다. 'sql_yacc.cc'를 이 옵션으로 컴파일하려면
gcc/pgcc는 모든 성능을 내기 위해 많은 메모리가 필요하기 때문에 180M의 메모리가 필요
하다. 또한 mysql을 설정할때 libstdc++ 라이브러리를 포함하지 않기 위해 CXX=gcc라고 설
정해야 한다.
- pgcc를 사용하고 모두다 -O6 옵션으로 컴파일하면 mysqld 서버는 gcc로 컴파일한 것보
다 11% 빨라진다.
- 동적으로 링크하면 (-static을 사용하지 않고) 13% 느려진다.
If you connect using TCP/IP rather than Unix sockets, the result is 7.5% slower.
- 유닉스 소켓을 사용하는 것보다 tcp/ip로 연결하는 것이 7.5% 느려진다.
- On a Sun sparcstation 10, gcc 2.7.3 is 13% faster than Sun Pro C++ 4.2.
- On Solaris 2.5.1, MIT-pthreads is 8-12% slower than Solaris native threads.
(** 번역을 안한 이후. 리눅스랑 상관없으니깐... **)
TcX에서 제공한 mysql 리눅스 배포판은 pgcc로 컴파일되었고 정적으로 링크되었다.
10.4 How MySQL uses indexes
prefix- and end-space compressed. See section 7.26 CREATE INDEX syntax (Compatibil
ity function).
모든 인덱스(PRIMARY, UNIQUE and INDEX()) 는 B-trees 에 저장된다. 문자열은 자동적
으로 앞 뒤의 공간(?)이 압축된다. 7.26 [인덱스 생성] 참고.
인덱스의 사용 :
- WHERE 문에서 해당하는 레코드 빨리 찾기
- 조인을 수행할때 다른 테이블에서 레코드 가져오기
- 특정 키에서 MAX() 나 MIN() 값 찾기
- 소팅이나 그룹화할때 인덱스 키를 사용하면 테이블을 정열하거나 그룹화한다. 키에 DES
C가 붙으면 역순으로 인덱스를 읽는다.
- 어떤 경우에는 데이터 파일에 묻지 않고 값을 가져온다. 어떤 테이블에서 사용하는 모든
컬럼이 숫자이고 특정 키로 형성되어있으면 빠른 속도로 인덱스 트리에서 값을 가져올 수
있다.
다음 예제를 보자.
mysql> SELECT * FROM tbl_name WHERE col1=val1 AND col2=val2;
다중 컬럼 인덱스가 col1 과 col2에 있으면 해당하는 레코드를 직접 가져올 수 있다. 분리
된 단일 컬럼 인덱스가 col1 과 col2 에 있으면 최적화기는 어떤 인덱스가 더 적은 레코드
를 가졌는지 확인하고 레코드를 가져오기 위해 그 인덱스를 사용하도록 결정한다.
테이블이 다중 컬럼 인덱스를 가졌다면 최적화기가 레코드를 찾는데 어떤 인덱스키를 사용
할 수 있다. 예를 들면 세가지 컬럼 인덱스(col1, col2, col3)를 가졌다면 (col1), (col1,col2)
(col1,col2,col3) 인덱스를 사용하여 검색을 할 수 있다.
MySQL can't use a partial index if the columns don't form a leftmost prefix of the inde
x.
Suppose you have the SELECT statements shown below:
(** 해석이 잘 안되는데 예제를 보시면 무슨 말인지 알 수 있을 것임**)
mysql> SELECT * FROM tbl_name WHERE col1=val1;
mysql> SELECT * FROM tbl_name WHERE col2=val2;
mysql> SELECT * FROM tbl_name WHERE col2=val2 AND col3=val3;
If an index exists on (col1,col2,col3), only the first query shown above uses the index.
The second and third queries do involve indexed columns, but (col2) and (col2,col3) are
not leftmost prefixes of (col1,col2,col3).
인덱스가 (col1,col2,col3)로 있다면 위의 질의중 오직 첫번째 질의만 인덱스를 사용한다. 두
번째 및 세번째 질의은 인덱스된 컬럼이 포함되어 있지만 (col2) 와 (col2,col3)는 (col1,col2,c
ol3) 인덱스에 해당하지 않는다.
MySQL also uses indexes for LIKE comparisons if the argument to LIKE is a constant
string that doesn't start with a wildcard character. For example, the following SELECT
stat ements use indexes:
mysql은 또한 LIKE의 인수가 와일드카드 문자로 시작하지 않는 상수 문자열일이라면 LIK
E 비교문에서 인덱스를 사용한다. 예를 들어 다음의 SELECT 문은 인덱스를 사용한다.
mysql> select * from tbl_name where key_col LIKE "Patrick%";
mysql> select * from tbl_name where key_col LIKE "Pat%_ck%";
첫번째 문장에서는 "Patrick" <= key_col < "Patricl" 을 가진 레코드만 고려된다. 두번째 문
장에서는 "Pat" <= key_col < "Pau" 을 가진 레코드만 고려된다.
다음의 SELECT 문은 인덱스를 사용하지 않는다:
mysql> select * from tbl_name where key_col LIKE "%Patrick%";
mysql> select * from tbl_name where key_col LIKE other_col;
첫번째 문장에서 LIKE 값은 와일드카드 문자로 시작하고 있다. 두번째 문장에서는 LIKE
값이 상수가 아니다.
10.5 WHERE 문에서 최적화하기
(이번 절은 완전한 내용을 포함하고 있지는 않다. mysql은 많은 최적화방법이 있다.)
In general, when you want to make a slow SELECT ... WHERE faster, the first thing t
o check is whether or not you can add an index. All references between different tables
should usually be done with indexes. You can use the EXPLAIN command to determine
which indexes are used for a SELECT. See section 7.21 EXPLAIN syntax (Get informat
ion about a SELECT).
일반적으로 느린 SELECT ... WHERE 문을 빠르게 하려면 가장 먼저 확인해야 할 것이 인
덱스 추가 문제이다. 다른 테이블사이에서 모든 레퍼런스(references 참조)는 일반적으로 인
덱스에 의해 수행된다. SELECT 문에서 어떤 인덱스를 사용하는지 결정하기 위해 EXPLAI
N 명령을 사용할 수 있다. 7.21 [Explain]을 참고.
mysql에서 수행하는 최적화는 다음과 같다.
- 불필요한 삽입어 제거
((a AND b) AND c OR (((a AND b) AND (c AND d))))
-> (a AND b ANDc) OR (a AND b AND c AND d)
-상수 폴딩(folding)
(a<b AND b=c) AND a=5
-> b>5 AND b=c AND a=5
- 상수 조건 제거(상수 폴딩때문에 필요)
(B>=5 AND B=5) OR (B=6 AND 5=5) OR (B=7 AND 5=6)
-> B=5 OR B=6
- 인덱스에서 사용되는 상수 표현은 한번에 계산된다.
(Constant expressions used by indexes are evaluated only once.)
- WHERE 절이 없는 단일 테이블의 COUNT(*)는 테이블 정보에서 직접 값을 가져온다.
단일 테이블에서 사용된 NOT NULL 표현도 이와 같이 수행된다.
- 유효하지 않은 상수 표현은 미리 제거된다. mysql은 불가능하고 해당하는 레코드가 없는
SELECT 문을 빠르게 감지한다.
- GROUP BY 나 그룹 펑션(COUNT(), MIN() ...)을 사용하지 않으면 HAVING은 WHERE
에 합쳐진다.
(** HAVING 절에서는 인덱스를 사용하지 못함. 그러므로 가능한 HAVING절을 사용하지
않는게 속도면에서 좋다 **)
- 각 서브 조인에서 빠르게 WHERE 문을 계산하고 가능한한 레코드를 제외하도록 간소하
게 WHERE 문이 만들어진다.
- mysql은 일반적으로 최소한의 레코드를 찾기 위해 인덱스를 사용한다. =, >, >=, <, <=,
BETWEEN 그리고 'something%' 처럼 앞이 와일드카드로 시작하지 않는 LIKE 문등을
사용하여 비교를 할 때 인덱스를 사용한다. (** 10.4 절에서 설명하였듯이 like 를 사용할때
와일드카드로 시작하는 like 문을 사용하면 인덱스를 사용하지 않는다. 일정한 단어로만 시
작하는 컬럼에서 자료를 찾을 때 유용할 것이다. **)
- Any index that doesn't span all AND levels in the WHERE clause is not used to opti
mize the query.
다음의 WHERE 문은 인덱스를 사용한다.:
... WHERE index_part1=1 AND index_part2=2
... WHERE index=1 OR A=10 AND index=2 /* index = 1 OR index = 2 */
... WHERE index_part1='hello' AND index_part_3=5
/* optimized like "index_part1='hello'" */
다음의 WHERE 문은 인덱스를 사용하지 않는다.:
... WHERE index_part2=1 AND index_part3=2 /* index_part_1 is not used */
... WHERE index=1 OR A=10 /* No index */
... WHERE index_part1=1 OR index_part2=10 /* No index spans all rows */
- 질의에서 다른 테이블보다 모든 상수 테이블을 먼저 읽는다. 상수 테이블은 다음과 같다.
ㅇ빈 테이블이나 1개의 레코드만 있는 테이블
ㅇWHERE 문에서 UNIQUE 인덱스나 PRIMARY KEY 를 사용하고 모든 인덱스
는 상수 표현으로된 테이블
다음의 테이블은 상수 테이블로 사용된다.
mysql> SELECT * FROM t WHERE primary_key=1;
mysql> SELECT * FROM t1,t2
WHERE t1.primary_key=1 AND t2.primary_key=t1.id;
- 모든 가능성을 시도하여 테이블을 조인하는데 가장 좋은 조인 조합을 찾는다. (ORDER B
Y나 GROUP BY의 모든 컬럼이 동일한 테이블에서 나오면 조인을 할때 이 테이블이 먼저
선택된다)
- ORDER BY 문과 다른 GROUP BY 문이 있을 때, 또는 ORDER BY 나 GROUP BY가
조인 큐의 첫번째 테이블이 아닌 다른 테이블의 컬럼을 포함하고 있으면 임사 테이블을 만
든다.
- 각 테이블 인덱스를 찾고 레코드의 30%미만을 사용하는 (best) 인덱스가 사용된다. 그런
인덱스가 없으면 빠른 테이블 검색이 사용된다.
- 어떤 경우에는 mysql은 데이터 파일을 조회하지 않고 인덱스에서 레코드를 읽을 수 있
다. 인덱스에서 사용한 모든 컬럼이 숫자라면 질의를 처리하는데 단지 인덱스 트리만을 사
용한다.
- 각 레코드가 출력되기 전에 HAVING 절에 맞지 않는 레코드는 건너뛴다.
다음은 매우 빠른 질의의 예이다:
mysql> SELECT COUNT(*) FROM tbl_name;
mysql> SELECT MIN(key_part1),MAX(key_part1) FROM tbl_name;
mysql> SELECT MAX(key_part2) FROM tbl_name
WHERE key_part_1=constant;
mysql> SELECT ... FROM tbl_name
ORDER BY key_part1,key_part2,... LIMIT 10;
mysql> SELECT ... FROM tbl_name
ORDER BY key_part1 DESC,key_part2 DESC,... LIMIT 10;
다음의 커리는 인덱스 트리만을 사용하여 값을 구한다.(인덱스 컬럼은 숫자라고 가정):
mysql> SELECT key_part1,key_part2 FROM tbl_name WHERE key_part1=val;
mysql> SELECT COUNT(*) FROM tbl_name
WHERE key_part1=val1 and key_part2=val2;
mysql> SELECT key_part2 FROM tbl_name GROUP BY key_part1;
다음의 질의는 개별적인 정열을 하지 않고 정열된 순서대로 열을 가져오는 데 인덱스를 사
용한다:
mysql> SELECT ... FROM tbl_name ORDER BY key_part1,key_part2,...
mysql> SELECT ... FROM tbl_name ORDER BY key_part1 DESC,key_part2 DESC,...
10.6 테이블 열고 닫는 방법
open 테이블의 캐쉬는 table_cache의 최대값까지 커질 수 있다. (기본값 64 ; 이 값은 mysql
d에서 -0 table_cache=# 으로 바꿀 수 있다) 캐쉬가 꽉 찼을때, 그리고 다른 스레드가 테이
블을 열려고 할 때, 또는 mysqladmin refresh 나 mysqladmin flush-tables를 사용할때를 제
외하고는 테이블은 결코 닫히지 않는다.
테이블 캐쉬가 꽉 차면 서버는 캐쉬 엔트리를 사용하도록 조절하기 위해 다음의 절차를 사
용한다.
- 가장 먼저 사용했던 순서대로 현재 사용하지 않는 테이블을 닫는다.
- 캐쉬가 꽉 찼고 어떤 테이블도 닫히지 않지만 새로운 테이블을 열어야 한다면 캐쉬가 필
요한 만큼 임시적으로 확장된다.
- 캐쉬가 임시적으로 확장된 상태이고 테이블을 사용할 수 없는 상황으로 가면 테이블을
닫고 캐쉬를 해제한다.
테이블은 각 동시병행적인 접근때마다 열린다. 동일한 테이블에 접근하는 두개의 스레드가
있거나 같은 질의에서 테이블에 두번 접근하면(with AS) 테이블을 두번 열여야 한다는 의
미이다. 테이블의 첫번째 개방은 두개의 파일 디스크립터를 가진다. ; 추가적인 테이블의 개
방은 하나의 파일 디스크립터를 가질 뿐이다. 처음에 개방에 사용하는 추가적은 파일 디스
크립터는 인덱스 파일에 사용된다. ; 이 디스크립터는 모든 스레드에서 공유된다.
10.6.1 데이터베이스에서 많은 수의 테이블을 만들때의 단점
디렉토리에 많은 파일이 있다면 open, close 그리고 create 오퍼레이션은 느려질 것이다. 서
로 다른 많은 테이블에서 SELECT 문을 수행하면 테이블 캐쉬가 꽉 찰 때 약간의 overhea
d가 있을 것이다. 왜냐면 개방된 테이블이 있다면 다른 테이블은 닫혀야 하기 때문이다. 테
이블 캐쉬를 크게 해서 이러한 오우버헤드를 줄일 수 있다.
10.7 많은 테이블을 여는 이유
mysqladmin status 를 실행할 때 다음과 같이 나올 것이다:
Uptime: 426 Running threads: 1 Questions: 11082 Reloads: 1 Open tables: 12
단지 6테이블을 사용했는데 이러한 결과는 당황스러울 것이다.
mysql은 멀티스레드를 사용한다. 그래서 동시에 같은 테이블에서 많은 질의를 할 수 있다.
같은 파일에 대하여 다른 상황을 가지는 두개의 스레드에 대한 문제를 줄이기 위해 테이블
은 각 동시병행적인 스레드마다 독립적으로 개방된다. 이것은 테이타 파일에서 약간의 메모
리와 하나의 추가적인 파일 디스크립터를 사용한다. 모든 스레드에서 인덱스 파일은 공유된
다.
10.8 데이터베이스와 테이블에서 심볼릭 링크 사용
데이터베이스 디렉토리에서 테이블과 데이터베이스를 다른 위치로 옮기고 새로운 위치로 심
볼릭 링크를 사용할 수 있다. 이렇게 하는 것을 원할 경우가 있다. 예를 들면 데이터베이스
를 더 여유공간이 많은 파일시스템으로 옮기는 경우 등.
mysql에서 테이블이 심볼링 링크되었다는 것을 감지하면 심볼링 링크가 가리키는 테이블을
대신 사용할 수 있다. realpath() call 을 지원하는 모든 시스템에서 작동한다. (최소한 리눅
스와 솔라리스는 realpath()를 지원한다) realpath()를 지원하지 않는 시스템에서 동시에 실
제 경로와 심볼릭 링크된 경로에 접근하면 안된다. 이런 경우에는 업데이트 된후에 테이블
이 모순될 수 있다.
mysql은 기본값으로 데이터베이스 링크를 지원하지 않는다. 데이터베이스간에 심볼릭 링크
를 사용하지 않는 작동을 잘 할 것이다. mysql 데이터 디렉토리에 db1 데이터베이스가 있
고 db1을 가리키는 db2 심볼릭 링크를 만들었다고 해보자:
shell> cd /path/to/datadir
shell> ln -s db1 db2
이제 db1에 tbl_a라는 테이블이 있다면 db2에도 tbl_a가 나타날 것이다. 한 스레드가 db1.tbl
_a를 업데이트하고 다른 스레드가 db2.tbl_a를 업데이트하면 문제가 생길 것이다.
정말로 이 기능이 필요하면 , `mysys/mf_format.c'에서 다음의 코드를 수정해야 한다.:
if (!lstat(to,&stat_buff)) /* Check if it's a symbolic link */
if (S_ISLNK(stat_buff.st_mode) && realpath(to,buff))
위 코드를 다음과 같이 수정한다 :
if (realpath(to,buff))
10.9 테이블에 락 거는 방법
mysql의 모든 락은 deadlock-free 이다. 언제나 질의를 시작할때 한번에 모든 필요한 락을
요청하고 언제나 같은 순서대로 테이블에 락을 걸어 관리한다.
WRITE 락을 사용하는 방법은 다음과 같다:
- 테이블에 락이 없으면 그 테이블에 write 락을 건다.
- 이런 경우가 아니라면 write 락 큐에 락을 요청한다.
READ 락을 사용하는 방법은 다음과 같다:
- 테이블에 write 락이 없으면 그 테이블에 read 락을 건다.
- 이런 경우가 아니라면 read 락 큐에 락을 요청한다.
락이 해제되었을 때 락은 write 락 큐의 스레드에서 사용할 수 있으며 그러고 나서 read 락
큐의 스레드에서 사용한다.
테이블에서 업데이트를 많이 하면 SELECT 문은 더 이상 업데이트가 없을 때까지 기다린
다는 것을 의미한다.
이러한 문제를 해결하기 위해 테이블에서 INSERT 와 SELECT 오퍼레이션을 많이 사용하
는 경우에 다음과 같이 하면 된다. 임시 테이블에 레코드를 입력하고 한번에 임시 테이블에
서 실제 테이블로 레코드를 업데이트한다.
다음의 예를 보자:
mysql> LOCK TABLES real_table WRITE, insert_table WRITE;
mysql> insert into real_table select * from insert_table;
mysql> delete from insert_table;
mysql> UNLOCK TABLES;
만약 어떤 경우에 SELECT문에 우선권을 주고 싶다면 INSERT 옵션에서 LOW_PRIORITY
or HIGH_PRIORITY 옵션을 사용할 수 있다. 7.13 [Insert] 참고. (** LOW_PRIORITY를 지
정하면 클라이언트에서 테이블을 읽지 않을 때까지 INSERT 문 수행이 미루어진다. **)
단일 큐를 사용하기 위해 `mysys/thr_lock.c' 의 락킹 코드를 바꿀 수 있다. 이런 경우 writ
e 락과 read 락은 같은 우선권을 가지며 어떤 애플리케이션에서는 유용할 수 있다.
10.10 테이블을 빠르고 작게 배열하는 방법 <** 테이블 최적화 **>
다음은 테이블에서 최대의성능을 내는 방법과 저장 공간을 절약할 수 있는 테크닉이다:
- 가능한한 NOT NULL로 컬럼을 선언한다. 속도가 빨라지며 각 컬럼마다 1 비트를 절약할
수 있다.
- default 값을 가질 때 유리하다. 입력되는 값이 기본값과 다를 때만 확실하게 값이 입력된
다. INSERT 문에서 첫번째 TIMESTAMP 컬럼이나 AUTO-INCREAMENT 컬럼의 값을
입력할 필요가 없다. 18.4.49 [mysql_insert_id()] 참고.
- 가능한한 테이블을 작게 만드려면 더 작은 integer 타입을 사용하자. 예를 들면 MEDIUM
INT 가 보통 INT 보다 좋다.
- 가변 길이 컬럼이 없다면(VARCHAR, TEXT or BLOB columns), 고정 길이 레코드 포
맷이 사용된다. 이 경우 속도는 더 빠르지만 불행히도(흑흑~) 낭비되는 공간이 더 많다. 10.1
4 [Row format] 참고.
- mysql이 질의를 효과적으로 최적화하기 위해 많은 양의 데이터를 입력한후 isamchk --a
nalyze를 실행하자. 이렇게 하면 동일한 값을 가진 줄의 평균 숫자를 가리키는 각 인덱스의
값을 업데이트한다. (물론 unique 인덱스에서는 항상 1이다)
- 인덱스와 인덱스에 따른 데이타를 정열하려면
isamchk --sort-index --sort-records=1 을 사용하자.(if you want to sort on index 1).
인덱스에 따라 정렬된 모든 레코드를 읽기 위해 unique 인덱스를 가졌다면 이렇게 하는 것
이 속도를 빠르게 하는 가장 좋은 방법이다.
- INSERT 문에서 가능한 다중 값 목록을 사용하자. 개별적인 SELECT 문보다 훨씬 빠르
다. 데이타를 테이블에 입력할 때 LOAD DATA INFILE을 사용하자. 많은 INSERT 문을
사용하는 것보다 보통 20배 빠르다. 7.15 [Load] 참고.
많은 인덱스를 가진 테이블에 데이타를 입력할때 다음의 과정을 사용하면 속도를 향상시킬
수 있다.
1. mysql이나 Perl 에서 CREATE TABLE로 테이블을 만든다.
2. mysqladmin flush-tables 실행. (** 열린 테이블을 모두 닫음 **)
3. isamchk --keys-used=0 /path/to/db/tbl_name 사용. 테이블에서 모든 인덱스 사용을 제
거한다.
4. LOAD DATA INFILE 를 이용 테이블에 데이타를 입력.
5. pack_isam을 가지고 있고 테이블을 압축하기 원하면 pack_isam을 실행.
6. isamchk -r -q /path/to/db/tbl_name 를 이용 인덱스를 다시 생성.
7. mysqladmin flush-tables 실행.
- LODA DATA INFILE 과 INSERT 문에서 더 빠른 속도를 내려면 키 버퍼를 증가시킨
다. mysqld나 safe_mysqld에서 -O key_buffer=# 옵션을 사용하면 된다. 예를 들어 16M는
풍부한 램을 가졌다면 훌륭한 값이다.
- 다른 프로그램을 사용하여 데이타를 텍스트 파일로 덤프할때 SELECT ... INTO OUTFIL
E 을 사용하자. 7.15 [LOAD DATA INFILE] 참고.
- 연속으로 다량의 insert와 update를 할 때 LOCK TABLE을 사용하여 테이블에 락을 걸
면 속도를 향상시킬 수 있다. LOAD DATA INFILE 그리고 SELECT ...INTO OUTFILE
는 원자적이기 때문에 LOCK TABLE을 사용하면 안된다. 7.23 [LOCK TABLES/UNLOCK
TABLES] 참고.
테이블이 얼마나 단편화되었는지 점검하려면 '.ISM' 파일에서 isamchk -evi 를 실행한다. 1
3장 [Maintenance] 참고.
10.11 INSERT 문에서 속도에 영향을 미치는 부분 <** insert 최적화 **>
insert 하는 시간은 다음와 같이 구성된다:
Connect: (3)
Sending query to server: (2)
Parsing query: (2)
Inserting record: (1 x size of record)
Inserting indexes: (1 x indexes)
Close: (1)
(숫자)는 비례적인 시간이다. 이것은 테이블을 개방할때 초기의 overhead를 고려하고 있지
는 않다. (매 동시병행적으로 수행되는 질의마다 발생)
The size of the table slows down the insertion of indexes by N log N (B-trees).
테이블의 크기는 N log N(B-trees)에 따라 인덱스의 입력이 느려진다. (**말이 좀 이상. 테
이블이 커짐에 따라 인덱스 생성도 느려진다는 뜻이겠죵 **)
테이블에 락을 걸거나 insert 문에서 다중 값 목록을 사용하여 입력 속도를 빠르게 할 수
있다. 다중 값 목록을 사용하면 단일 insert 보다 5배 정도 속도가 빨라진다.
mysql> LOCK TABLES a WRITE;
mysql> INSERT INTO a VALUES (1,23),(2,34),(4,33);
mysql> INSERT INTO a VALUES (8,26),(6,29);
mysql> UNLOCK TABLES;
주요한 속도 차이는 모든 INSERT 문이 완료되고 난 후에 한번에 인덱스 버퍼가 쓰여기지
때문에 생긴다. 보통 서로 다른 여러 INSERT 문이 있으면 많은 인덱스 버퍼 플러쉬가 있
을 것이다. 모든 줄을 단일 문으로 입력하면 락은 필요없다.
락킹은 또한 다중 연결 테스트의 총 시간을 줄일 수는 있다. 그러나 어떤 스레드에서는 총
대기시간은 증가할 수 있다.(왜냐면 락을 기다리기 때문이다)
예를 들어보자:
thread 1 does 1000 inserts
thread 2, 3, and 4 does 1 insert
thread 5 does 1000 inserts
락을 사용하지 않으면 2, ,3 4는 1과 5 전에 끝마칠 것이다. 락을 사용하면 2,3,4는 아마도 1
이나 5 전에 끝나지 않을 것이다. 그러나 총 시간은 40% 빨라진다.
INSERT, UPDATE, DELETE 오퍼레이션은 mysql에서 매우 빠르다. 그렇기 때문에 줄에서
5개 이상의 insert나 update를 할 때 락을 추가하면 더 좋은 성능을 얻을 수 있다. 줄에 매
우 많은 자료를 입력한다면 다른 스레드에서 테이블에 접근하도록 하기 위해 때때로(각 100
0줄마다) UNLOCK TABLES를 사용하는 LOCK TABLES 실행하면 된다. 이렇게 하면 좋
은 성능을 낼 수 있다. (** 열심히 입력을 하고 중간에 락을 풀었다가 다시 락을 거는 것
반복함**)
물론 LOAD DATA INFILE 이 더 빠르다.
10.12 DELETE 문에서 속도에 영향을 미치는 부분 <** DELETE 문 최적화 **>
레코드를 삭제하는 시간은 정확히 인덱스 숫자에 비례한다. 레코드를 빠르게 지우기 위해
인덱스 캐쉬의 크기를 증가시킬 수 있다. 기본 인덱스 캐쉬는 1M 이다; 빠르게 삭제하기 위
해 증가되어야 한다.(충분한 메모리를 가지고 있다면 16M로 하자)
10.13 mysql에서 최대 속도를 얻는 방법
벤치마킹을 시작하자! mysql 벤치마크 스위트에서 어떤 프로그램을 사용할 수 있다. (일반
적으로 'sql-bench' 디렉토리에 있음) 그리고 입맞에 맞게 수정하자. 이렇게 하면 당신의 문
제를 해결할 수 있는 다른 해결책을 찾을 수 있으며 당신에게 가장 빠른 해결책을 테스트할
수 있다.
- mysqld를 적절한 옵션으로 시작하자. 메모리가 많을수록 속도가 빠르다.
10.1 [MySQL parameters] 참고.
- SELECT 문의 속도를 빠르게 하기 위해 인덱스를 만들자.
10.4 [MySQL indexes] 참고.
- 가능한 효율적으로 컬럼 타입을 최적화하자. 예를 들면 가능한 NOT NULL로 컬럼을 정
의하자. 10.10 [Table efficiency] 참고.
- --skip-locking 옵션은SQL 요청에서 파일 락킹을 없앤다. 속도가 빨라지지만 다음의 과
정을 따라야 한다:
ㅇ isamchk로 테이블을 체크하거나 수리하기 전에 mysqladmin flush-tables 로 모
든 테이블을 플러시해야 한다. (isamchk -d tbl_name은 언제나 허용된다. 왜냐하면 이건 단
순히 테이블의 정보를 보여주기 때문이다)
ㅇ 동시에 뜬 두개의 mysql 서버가 동일한 테이블을 업데이트하려 한다면 동일한
데이터 파일에 두개의 mysql 서버를 띄우면 안된다.
--skip-locking 옵션은 MIT-pthreads로 컴파일할때 기본값이다. 왜냐면 모든 플랫
폼의 MIT-pthreads에서 flock()가 완전하게 지원이 되지 않기 때문이다.
- 업데이트에 문제가 있다면 업데이트를 미루고 나중에 하자. 많은 업데이트를 하는 것이
한번에 하나를 업데이트하는 것보다 더 빠르다.
- FreeBSD 시스템에서 MIT-pthreads에 문제가 있으면 FreeBSD 3.0 이후 버전으로 업데
이트 하는것이 좋다. 이렇게 하면 유닉스 소켓을 사용하는 것이 가능하며(FreBSD에서 유닉
스 소켓이 MIT-pthreads에서 TCP/IP 연결을 사용하는 것보다 빠르다) 그리고 스레드 패키
지가 조정(intergrated?)되어야 한다.
- 테이블이나 컬럼 단계를 체크하는 GRANT는 성능을 떨어뜨린다.
10.14 로우 포맷과 다른 점은 무엇인가? 언제 VARCHAR/CHAR을 사용해야 하는가?
mysql은 실제의 SQL VARCHAR 타입이 없다. 그대신 mysql은 레코드를 저장하고 이것을
VARCHAR로 에뮬레이트하는데 세가지 방법이 있다.
테이블에 VARCHAR, BLOB, TEXT 컬럼이 없으면 고정 row size를 사용한다. 그외에는
동적 row size를 사용한다. CHAR 과 VARCHAR 컬럼은 애플리케이션의 관점에서 동일하
게 취급된다; 둘다 trailing space는 컬럼을 가져올때 제거된다.
isamchk -d 를 이용 테이블에서 사용하는 포맷을 체크할 수 있다.
(-d 는 "테이블 묘사"를 의미)
mysql은 세가지 다른 테이블 포맷을 가지고 있다; 고정길이, 다이나믹, 압축.
고정 길이 테이블
- 기본 포맷. 테이블에 VARCHAR, BLOB, TEXT 컬럼이 없을 때 사용.
- 모든 CHAR, NUMERIC, DECIMAL 컬럼은 컬럼 길이에 space-padded 이다. (** space-
padded를 무엇이라고 번역해야 할지 애매모호해서 **)
- 매우 빠름
- 캐쉬하기 쉽다
- 손상 후 복구가 쉽다. 왜냐면 고정된 위이에 레코드가 위치하기 때문이다.
- 많은 양의 레코드가 지워졌거나 운영 시스템에서 자유 공간을 늘리길 원치 않는다면 (isa
mchk를 이용) 재조직화할 필요없다.
- 보통 다이나믹 테이블보다 많은 디스크 공간을 필요로 한다.
다이나믹 테이블
- 테이블이 VARCHAR, BLOB, TEXT 컬럼을 포함하고 있을 때 사용.
- 모든 문자열 컬럼은 다이나믹하다.(4보다 작은 길이를 가진 문자열 제외)
- 컬럼이 문자열 컬럼에서 비었거나 ('') 숫자형 컬럼에서 0(NULL 값을 가진 컬럼과 동일
한 것이 아니다) 을 나타내는 비트맵이 모든 레코드 앞에 선행된다. 문자열 컬럼에서 trailin
g space를 제거한 후 zero의 길이를 가지거나 숫자형 컬럼이 zero의 값을 가지면 비트 맵으
로 표시되고 디스크에 저장되지 않는다. 비지 않은 문자는 문자내용에 길이 바이트만큼 추
가되어 저장된다.
- 보통 고정 길이 테이블보다 디스크 공간 절약.
- 줄의 길이를 확장하는 정보를 가지고 줄을 업데이트하면 줄은 단편화될 것이다. 이런 경
우 더 좋은 성능을 위해 때때로 isamchk -r 을 실행해야 한다. 통계적으로(?) isamchk -ei
tbl_name을 사용하자.
- 손상후 복구가 어렵다. 왜냐면 레코드가 많은 조각드로 단편화되고 링크(단편)가 없어지
기 때문이다.
- 다이나믹 사이즈 테이블의 예상되는 열 길이 :
3
+ (number of columns + 7) / 8
+ (number of char columns)
+ packed size of numeric columns
+ length of strings
+ (number of NULL columns + 7) / 8
각 링크마다 6 바이트가 더 있다. 다이나믹 레코드는 업데이트로 레코드가 늘어날때마다 링
크된다. 각 새로운 링크는 최소 20바이트일 것이며, 그래서 다음의 확장은 아마도 동일한 링
크로 될 것이다. 그게 아니라면 다른 링크가 있을 것이다. isamchk -ed 로 얼마나 많은 링
크가 있는지 체크할 수 있다. 모든 링크는 isamchk -r 로 제거할 수 있다.(** ?? **)
There is a penalty of 6 bytes for each link. A dynamic record is linked whenever an up
date causes an enlargement of the record. Each new link will be at least 20 bytes, so th
e next enlargement will probably go in the same link. If not, there will be another link.
You may check how many links there are with isamchk -ed. All links may be removed
with isamchk -r.
압축 테이블
- 읽기 전용 테이블은 pack_isam 유틸리티로 만들 수 있다. 확장 mysql 이메일 지원을 구
입한 모든 고객은 내부적인 용도로 pack_isam을 사용할 권리가 주어진다.
- 압축해제 코드는 모든 mysql 배포판에 있으므로 pack_isam이 없는 고객도 pack_isam으
로 압축된 테이블을 읽을 수 있다. (테이블이 같은 플랫폼에서 압축되어 있는한)
- 매우 적은 디스크 용량을 사용.
- 각 레코드는 개별적으로 압축이 된다.( 매우 적은 액세스 overhead) 레코드의 헤더는 테
이블의 가장 큰 레코드에 따라 (1-3 바이트) 고정된다. 각 컬럼은 다르게 압축이 된다. 압축
타입은 다음과 같다:
ㅇ 일반적으로 각 컬럼마다 다른 Huffman 테이블이다.
ㅇ Suffic 공간 압축
ㅇ Prefix 공간 압축
ㅇ 0 값을 가진 숫자는 1비트로 저장.
ㅇ integer 컬럼의 값이 작은 범위를 가졌다면, 컬럼은 최대한 작은 타입으로 저장
된다. 예를 들면 BIGINT 컬럼은 모든 값이 0부터 255라면 TINIINT 컬럼(1바이트)로 저장
된다.
ㅇ 컬럼이 몇가지 가능한 값으로만 구성되어 있다면, 컬럼 타입은 ENUM으로 변환
된다.
ㅇ 컬럼은 위 압축 방법을 조합하여 사용한다.
- 고정 길이나 다이나믹 길이의 테이블을 다룰 수 있다. 그러나 BLOB나 TEXT 컬럼은 다
룰 수 없다.
- isamchk로 압축을 해재할 수 있다.
mysql은 다른 인덱스 타입을 지원한다. 그러나 일반적인 타입은 NISAM이다. 이것은 B-tre
e 인덱스이며 모든 키의 갑을 합하여 (키 길이+4)*0.67로 인덱스 파일의 크기를 대강 계산
할 수 있다. (이것은 모든 키가 정렬된 순서로 입력된 가장 나쁜 경우이다)
String indexes are space compressed. If the first index part is a string, it will also be p
refix compressed. Space compression makes the index file smaller if the string column h
as a lot of trailing space or is a VARCHAR column that is not always used to the full
length. Prefix compression helps if there are many strings with an identical prefix.
문자열 인덱스는 공간이 압축된다. 첫번째 인덱스 부분이 문자열이라면, prefix가 압축된다.
문자열 컬럼이 다량의 trailing space를 가졌거나 언제나 완전한 길이를 사용하지 않는 VA
RCHAR 컬럼일 때 space 압축은 인덱스 파일을 더 작게 만든다. prefix 압축은 많은 문자
열에 동일한 prefix가 있을 때 유용하다.
{{<!-- This HTML file has been created by texi2html 1.52 (hacked by david@detron.se)
from /dr1/my/masters/mysql/Docs/manual.texi on 2 Febuary 1999 -->
}}11. mysql 벤치마크 스위트
여기에는 mysql 벤치마크 스위트(그리고 crash-me)에 대한 기술적인 설명이 들어가야 한다. 그렇
지만 아직 작성이 되지 않았다. 현재로서는 배포판의 'bench' 디렉토리에서 코드와 결과를 살펴보
아야 한다.(또한 다음의 웹페이지에서 살펴볼 수 있다.
{{{{http://www.mysql.com/crash-me-choose.htmy)
}}
}}
이것은 사용자에게 주어진 SQL 수행이 제대로 수행되는지 아닌지를 알려주는 벤치마크이다.
crash-me 는 실제로 질의를 수행하여 데이터베이스에서 지원하는 기능과 능력, 제한사항 등을 측
정하는 프로그램이다. 예를 들어 다음의 사항을 측정한다:
ㅇ 지원하는 컬럼 타입
ㅇ 지원하는 인덱스 숫자
ㅇ 지원하는 펑션
ㅇ 질의의 최대 크기
ㅇ VARCHAR 컬럼의 최대 크기
번역자 : 문태준(taejun@hitel.net)
12. mysql 유틸리티
12.1 다양한 mysql 프로그램 개요
mysql client 라이브러리를 사용하여 서버와 통신을 하는 모든 mysql 클라이언트는 다음의
환경 변수를 사용한다:
Name Description
MYSQL_UNIX_PORT 기본 소켓; 로컬호스트에서 접속할때 사용
MYSQL_TCP_PORT 기본 TCP/ip port
MYSQL_PWD 기본 패스워드
MYSQL_DEBUG 디버깅할때 Debug-trace 옵션
TMPDIR 임시 테이블/파일이 생성되는 디렉토리
MYSQL_PWD 를 사용하는 것은 보안에 취약하다. 6.2 [Connecting] 참고.
'mysql' 클라이언트는 명령행 라인 히스토리에 환경 변수를 저장하기 위해 MYSQL_HISTF
ILE 이라는 파일을 사용한다.
모든 MYSQL 프로그램은 매우 다양한 옵션이 있다. 그러나 모든 MYSQL 프로그램에서 --
help 옵션을 제공한다. --help 옵션을 이용해 프로그램의 다양한 옵션에 대한 모든 정보를
볼 수 있다. 예를 들어, mysql --help 를 해보자.
아래의 목록은 mysql 프로그램에 대해서 설명하고 있다:
isamchk : mysql 테이블 정보 보기, 점검, 최적화, 복구 유틸리티. 많은 기능이 있기 때문에
별도의 장에서 자세히 설명하고 있다. 13장 참고.
make_binary_release : 컴파일된 mysql 바이너리 버전을 만든다. 다른 myql 사용자의 편의
를 위해 ftp.tcx.e의 '/pub/mysql/Incoming' 에 올리자.
msql2mysql : msql 프로그램을 mysql로 변환하는 쉘 스크립트. 모든 경우를 다룰 수는 없
지만 변환할때 유용할 것이다.
mysql : 간단한 SQL 쉘. (GNU readline 호환성있음) 상호대화식 및 비대화식으로 사용할
수 있다. 대화식으로 사용하는 경우, 질의 결과는 아스키-테이블 포맷으로 출력된다. 비대화
식으로 사용할 경우, 결과는 텝으로 분리된 포맷으로 출력된다. (출력 포맷은 명령행 라인
옵션을 이용해 바꿀 수 있다) 다음과 같이 스크립트를 사용할 수 있다:
shell> mysql database < script.sql > output.tab
클라이언트에서 메모리가 부족해서 문제가 생기면 --quick 옵션을 사용하자. 그러면 질의
결과를 가져오기 위해 mysql_store_result() 대신 mysql_use_result()를 사용한다.
mysqlaccess : host, user, database 조합의 접근 권한 점검 스크립트.
mysqladmin : 데이터베이스 생성 및 삭제, 승인 테이블 재로딩, 디스크에 테이블 플러싱, 로
그 파일 재오픈 등을 수행하는 관리자용 유틸리티. mysqladmin은 또한 서버에서 버전, 프로
세스, 상태(status) 정보를 확인할 수 있다.
mysqlbug : mysql 버그 레포트 스크립트. mysql의 버그를 알릴 때 사용하는 스크립트.
mysqld : SQL 대몬. 항상 실행되고 있어야 한다.
mysqldump : mysql 데이터베이스를 SQL문 형태의 파일이나 탭으로 구분된 텍스빚 파일로
덤프하는 유틸리티.
mysqlimport : LOAD DATA INFILE을 사용해 텍스트 파일의 자료를 테이블에 입력하는
유틸리티. 12.2 참고.
mysqlshow : 데이터베이스, 테이블, 컬럼과 인덱스에 대한 정보 출력
mysql_install_db : 기본 권한으로 MYSQL 승인 테이블 생성. 처음 설치했을때만 수행된다.
replace : msql2mysql에서 사용되는 유틸리티이다. 그렇지만 다양하게 적용할 수 있다. 파일
이나 표준 입력의 문자열을 교체할 수 있다. 먼저 긴 문자열을 매칭하기 위해 제한된 상황
의 시스템에서 사용하자(** ??) 문자열을 교체하는데 사용할 수 있다. 예를 들어 다음의 명
령어는 파일에서 a와 b를 교체한다:
shell> replace a b b a -- file1 file2 ...
safe_mysqld : mysqld 대몬을 시작하는 스크립트. 에러가 났을때 서버를 재시작하고 로그
파일에 실행 정보를 기록하는 등 몇가지 안정 대책이 있다.
12. 2 텍스트 파일에서 데이터 입력(수입?)하기
mysqlimport 는 명령행 인터페이스에서 LOAD DATA INFILE sql 문을 제공한다. 대부분
의 옵션은 LOAD DATA INFILE 과 동일하다. 7.15 [Load] 참고.
다음과 같이 사용한다:
shell> mysqlimport [options] filename ...
명령행에서 지정한 텍스트 파일에 대하여, mysqlimport는 파일이름에서 확장자를 제거한다.
그리고 파일의 내용을 어떤 테이블에 넣을 것인지 결정하는데 사용한다. 예를 들어 vkdlfdlf
madl 'patient.txt', 'patient.text', 'patient'는 모두 patient라는 테이블 이름으로 입력될 것이
다.
mysqlimport 는 다음의 옵션을 지원한다:
-C, --compress : 서버, 클라이언트에서 압축을 지원하면 서버/클라이언트 사이에서 모든
정보를 압축한다
-#, --debug[=option_string] : 프로그램 사용 추적(디버깅용)
-d, --delete : 텍스트 파일에서 입력하기 전에 테이블을 비움
--fields-terminated-by=...
--fields-enclosed-by=...
--fields-optionally-enclosed-by=...
--fields-escaped-by=...
--fields-terminated-by=...
: LODA DATA INFILE 에서의 옵션과 동일한 기능을 갖는 옵션
-f, --force : 에러 생략.텍스트 파일을 위한 테이블이 없으면, 다른 남아있는 파일을 계속
처리(if a table for a text file doesn't exist, continue processing any remaining files) 이
옵션이 없는 경우, 테이블이 없으면 빠져나온다
--help : 도움말 출력
-h host_name, --host=host_name : 지정한 호스트의 mysql 서버에 데이타 입력. 기본값은
localhost
-i, --ignore : --replace 옵션의 정보 참고.
-l, --lock-tables : 텍스트 파일로 처리하기 전에 모든 테이블에 쓰기 락을 건다. 그러면 서
버에서 모든 테이블이 동기화될 수 있다.
-L, --local : 클라이언트에서 입력 파일 읽음. 기본적으로, localhost에서 접속하면 텍스트
파일은 서버에 있다고 가정된다.
-pyour_pass, --password[=your_pass] : 서버에 연결할 때 사용하는 비밀번호. '=your_pass
'를 지정하지 않으면 터미널에서 비밀번호를 물어봄
-P port_num, --port=port_num : 호스트에 연결할 때 사용하는 TCP/IP 숫자. (localhost가
아닌 호스트에서 접속할 때 사용. 예를 들어 유닉스 소켓을 사용하는 경우)
-r, --replace : --replace 와 --ignore 옵션은 unique key 값의 레코드가 중복되어 있을 경
우에 사용된다. --replcae 를 명시할 경우, 동일한 unique key 값을 가지고 있는 레코드를
대체한다. --ignore 를 명시할 경우, unique key 값이 동일한 레코드는 생략된다. 두 옵션
모두 명시하지 않는다면, 중복되는 키 갑이 발견되면 에러를 출력하고 텍스트 파일의 나머
지 부분은 생략이 된다.
-s, --silent : 침묵 모드. 에러가 발생했을 때만 출력.
-S /path/to/socket, --socket=/path/to/socket : 로컬호스트(기본 호스트값)에서 접속할 때
사용하는 소켓 파일.
-u user_name, --user=user_name : 서버에 연결할 때 사용하는 mysql 사용자 이름. 기본값
은 유닉스 로그인 이름.
-v, --verbose : Verbose 모드. 프로그램의 수행에 대한 상세한 정보 출력.
-V, --version : 버전 정보 출력.
12.3 mysql 압축 읽기 전용 테이블 생성기
** 이 부분은 번역 생략. 간단하게 소개만 합니다 **
pack_isam 은 10 라이센스 이상을 구입하거나 extended support 를 받을 때 사용할 수 있
는 추가 유틸리티. 바이너리로만 배포하므로 특정한 플랫폼에서만 사용 가능. 압축률은 40%
-70% 정도이다. 메모리맵을 사용하므로(mmap()) mmap()가 작동되지 않으면 문제가 생긴
다. 압축하고나서는 읽기 전용 테이블이 되며 BLOB 칼럼은 압축하지 못한다.
공개적으로 구할 수 있는 mysql에서 압축 읽기 전용 테이블을 생성하지는 못하지만 읽는
것은 가능하다. 기타 자세한 내용은 매뉴얼을 참고하자.
13. 테이블 유지보수 및 파손 복구에 isamchk 사용하기
데이터베이스 테이블의 정보를 얻을 때, 테이블 점검, 복구 및 최적화 할때 isamchk 유틸리티를 사
용할 수 있다. 다음의 섹션은 어떻게 isamchk를 사용하는지(옵션에 대한 상세한 설명 포함), 테이블
유지 계획을 어떻게 설정할 것인지, 어떻게 isamchk의 다양한 기능을 수행하기 위해 isamchk를 사
용하는지에 대해 설명하고 있다.
{{}}13.1 isamchk 명령어 사용법
isamchk 는 다음과 같이 사용한다:
shell> isamchk [options] tbl_name
옵션은 isamchk로 무엇을 할 것인지 지정한다. 아래에서 설명한다. (isamchk --help 명령으로 옵션
의 목록을 볼 수 있다) 옵션이 없을 때, isamchk는 단지 테이블을 점검한다. 더 많은 정보를 얻으려
하거나 특정한 작업이 필요하면 아래에서 설명하는데로 옵션을 지정한다.
tbl_name은 점검하기 원하는 데이터베이스 테이블이다. 데이터베이스 디렉토리가 아닌 다른 곳에
서 isamchk를 실행하면, 파일의 경로를 지정해야 한다. 왜냐하면 isamchk는 데이터베이스의 위치
에 대해서 알지 못하기 때문이다. 실제로, isamchk는 작업하려는 파일이 데이터베이스 디렉토리에
있는지 아닌지 신경을 쓰지 않는다; 데이터베이스 테이블에 해당하는 파일을 다른 곳으로 복사하
고 그곳에서 복구 작업을 할 수 있다.
원한다명 isamchk의 명령행에서 여러개의 테이블을 사용할 수 있다. 또한 이름을 인덱스 파일 이
름('.ISM' 가 붙음)으로 지정할 수 있으며 이런 경우 '*.ISM' 패턴을 사용하여 디렉토리의 모든 테이
블을 지정할 수 있다. 예를 들어 데이터베이스 디렉토리에 있다면 다음과 같이 디렉토리의 모든
테이블을 점검할 수 있다:
shell> isamchk *.ISM
If you are not in the database directory, you can check all the tables there by specifying the path to the dir
ectory:
데이터베이스 디렉토리에 있지 않으면, 디렉토리의 경로를 지정하여 모든 테이블을 점검할 수 있
다.
shell> isamchk /path/to/database_dir/*.ISM
또한 mysql data 디렉토리의 경로를 사용한 와일드 카드를 지정하여 모든 데이터베이스의 모든 테
이블을 점검할 수 있다:
shell> isamchk /path/to/datadir/*/*.ISM
isamchk는 다음의 옵션을 지원한다:
-a, --analyze
Analyze the distribution of keys. This will make some joins in MySQL faster.
키의 분포를 분석. mysql에서 특정한 조인을 빠르게 만든다.
-#, --debug=debug_options
Output debug log. The debug_options string often is 'd:t:o,filename'.
디버그 로그 출력. debug_options 문자는 흔지 'd:t:o,filename' 이다.
-d, --description
테이블의 정보 출력
-e, --extend-check
테이블을 매우 상세하게 점검. 아주 특정한 경우에만 필요하다. 일반적으로 isamchk는 이 옵션이
없어도 모든 에러를 찾을 수 있다.
-f, --force
Overwrite old temporary files. If you use -f when checking tables (running isamchk without -r), isamchk
will automatically restart with -r on any table for which an error occurs during checking.
이전의 오래된 임시 파일을 덮어씀. 테이블을 점검할때 -f를 사용하면(-r 없이 isamchk를 실행) isa
mchk는 점검하는 동안 에러가 발생하는 테이블에서 자동으로 -r 옵션을 시작한다.
--help
도움말 출력.
-i, --information
점검을 한 테이블의 통계 정보 출력.
-k #, --keys-used=#
Used with -r. Tell the NISAM table handler to update only the first # indexes. Higher-numbered indexes
are deactivated. This can be used to get faster inserts! Deactivated indexes can be reactivated by using isa
mchk -r.
-r 과 함께 사용. NISAM 테이블 핸들러에 첫 # 인덱스만 업데이트하라는 것을 알려준다. Higher-nu
mberd(?) 인덱스가 해제된다. 이것은 insert를 빠르게 할때 사용한다! 해제된 인덱스는 isamchk -r 을
사용하여 재활성화된다.
-l, --no-symlinks
복구할때 심볼릭 링크를 따르지 않는다. 일반적으로 isamchk는 심볼릭 링크가 가리키는 테이블을
복구한다.
-q, --quick
빠르게 복구하기 위해 -r 과 함께 사용. 일반적으로 원래의 데이타 파일은 건드리지 않는다; 두번째
-q를 지정하여 원래의 데이타 파일을 사용하도록 할 수 있다.
-r, --recover
복구 모드. 유일하지 않는 unique 키만 제외하고 거의 모든 것을 복구한다.
-o, --safe-recover
복구 모드. 구식 복구 방법을 사용; -r을 사용하여 복구하는 것보다 느리다. 그렇지만 -r이 다룰 수
없는 몇가지 경우에 사용할 수 있다.
(** -r이 다룰 수 없는 경우란 무엇인지 잘 모르겠네요... **)
-O var=option, --set-variable var=option
변수값 설정. 설정가능한 변수는 아래에서 설명.
-s, --silent
침묵 모드. 에러가 발생할 때만 출력을 한다. 두개의 -s(-ss)를 사용하면 isamchk에서 매우 조용하
게 작업을 할 수 있다.
-S, --sort-index
Sort index blocks. This speeds up "read-next" in applications.
인덱스 블락 정열. 애플리케이션에서 "read-next" 속도를 향상.(??)
-R index_num, --sort-records=index_num
인덱스에 따라 레코드를 정렬. 이 작업을 하면 데이타를 집중시킬 수 있고 이 인덱스를 사용한 SE
LECT 와 ORDER BY 작업의 속도를 증가시킬 수 있다. (처음에는 정렬하는 시간이 매우 느리다!)
테이블의 인덱스 번호를 찾기 위해 SHOW INDEX를 사용한다. SHOW INDEX는 isamchk에서 사용
하는 것과 같은 순서로 테이블의 인덱스를 보여준다. 인덱스는 1번부터 시작하여 번호가 매겨진
다.
-u, --unpack
Unpack a table that was packed with pack_isam.
pack_isam 으로 압축된 테이블의 압축 해제.
-v, --verbose
Verbose 모드. 정보를 출력. -d 와 -e 와 함께 사용할 수 있다. 여러개의 -v를 사용(-vv, -vvv)하여 더
자세하게 볼 수 있다.
-V, --version
isamchk 버전 출력.
-w, --wait
테이블에 락이 걸려 있으면 기다림.
--set-variable (-O) 옵션의 설정 가능한 변수는 다음과 같다:
keybuffer default value: 520192
readbuffer default value: 262136
writebuffer default value: 262136
sortbuffer default value: 2097144
sort_key_blocks default value: 16
decode_bits default value: 9
{{}}
13.2 isamchk 메모리 사용법
Memory allocation is important when you run isamchk. isamchk uses no more memory than you specify
with the -O options. If you are going to use isamchk on very large files, you should first decide how much
memory you want it to use. The default is to use only about 3M to fix things. By using larger values, you
can get isamchk to operate faster. For example, if you have more than 32M RAM, you could use options s
uch as these (in addition to any other options you might specify):
메모리 할당은 isamchk를 실행할 때 중요하다.isamchk는 -O 옵션에서 지정한 것 이상으로 메모리
를 사용하지 않는다. 매우 큰 파일에서 isamchk를 사용하려 하면, 얼마마 많은 메모리를 사용할 것
인지 먼저 결정해야 한다. 기본값은 문제를 고치는데 3M를 사용한다. 더 많은 값을 사용해 더 빠르
게 isamchk를 사용할 수 있다. 예를 들어 32M 이상 램을 가지고 있다면 다음과 같은 옵션을 사용할
수 있다. (사용자가 지정한 옵션에 추가하여):
shell> isamchk -O sortbuffer=16M -O keybuffer=16M \
-O readbuffer=1M -O writebuffer=1M ...
-O sortbuffer=16M 를 사용하면 대부분의 경우에는 충분하다.
Be aware that isamchk uses temporary files in TMPDIR. If TMPDIR points to a memory file system, you
may easily get out of memory errors.
isamchk 는 TMPDIR의 임시 파일을 사용한다는 것에 주의하자. 만약 TMPDIR이 메모리 파일 시스
템을 가리킨다면 쉽게 메모리 에러에서 벗어날 수 있다.
13. 3 테이블 유지보수 설정
{{}}13.3 Setting up a table maintenance regime
문제가 생길때를 기다리는 것보다 정기적으로 테이블을 점검하는 게 좋다. 유지보수 계획를 위하
여 isamchk -s 를 사용해 테이블을 점검할 수 있다. -s 옵션을 사용하면 isamchk가 침묵 모드로 작동
을 하며 에러가 발생했을 때만 메시지를 출력한다.
서버를 시작할때 테이블을 점검하는 것도 좋은 생각이다. 예를 들어 업데이트 도중에 시스템이 리
부팅을 했을 때마다 일반적으로 영향을 받은 모든 테이블(이것을 "expected crashed table"이라고 한
다)을 점검해야 한다. 만약 오래된 '.pid' (프로세스 ID) 파일이 재부팅후에 남아 있다면 최근 24시간
동안 변경이 된 모든 테이블을 점검하기 위해 safe_mysqld에 isamchk를 실행하는 테스트를 추가해
야 한다.('.pid' 파일은 mysqld가 시작할때 만들어지며 일반적으로 mysqld가 종료될때 제거된다. 시
스템이 시작할때 '.pid' 파일이 있다는 것은 mysqld가 비정상적으로 종료되었다는 것을 나타낸다.)
더 좋은 테스트는 최근에 변경된 시간이 '.pid' 파일보다 최근인 테이블을 점검하는 것이다.
또한 일반적인 시스템 운영중에 정기적으로 테이블을 점검할 수 있다. TcX에서는 'crontab' 파일에
다음의 라인을 사용하여 일주일에 한번씩 우리의 중요한 테이블을 점검하도록 cron 작업을 돌린
다:
35 0 * * 0 /path/to/isamchk -s /path/to/datadir/*/*.ISM
이렇게 하면 손상된 테이블에 대한 정보를 출력하여 필요할때 테이블을 점검하고 복구할 수 있다.
몇년동안 우리는 예상하지 못하게 테이블이 손상(하드웨어 문제가 아닌 다른 이유로 문제가 생긴
테이블)된 경우가 없어서 우리에겐 일주일만으로도 충분하다. (이것은 정말로 진실이다)
우리만큼 mysql에 대해 신뢰를 할 때까지 최근 24시간동안 업데이트된 모든 테이블에 대해 매일
밤마다 isamchk -s 를 실행할 것을 추천한다.
13.4 테이블 정보 얻기
테이블에 대한 정보나 통계를 얻기 위해 아래의 명령을 사용하자. 뒤에서 자세하게 정보에 대해
설명할 것이다.
isamchk -d tbl_name
테이블에 대한 정보를 얻기 위해 "describe(설명) 모드"로 isamchk를 실행. mysql 서버를 --skip-locki
ng 옵션을 사용해 시작하면, isamchk는 서버가 실행되는 동안 업데이트된 테이블에서 에러가 난
것을 보고한다. 그러나 isamchk는 describe 모드에서 테이블을 변경하지 못하기 때문에 데이타를
읽을 위험이 없다.
isamchk -d -v tbl_name
isamchk가 수행하는 것에 대해 더 자세한 정보를 보기위해 -v 옵션을 추가하여 verbose 모드로 수
행할 수 있다.
isamchk -eis tbl_name
테이블에서 가장 중요한 정보만 보여준다. 전체 테이블을 다 읽어야 하기 때문에 속도가 느리다.
isamchk -eiv tbl_name
-eiv 와 비슷하지만 현재 무엇이 진행되고 있는지 보여준다.
isamchk -d 출력 예제:
ISAM file: company.ISM
Data records: 1403698 Deleted blocks: 0
Recordlength: 226
Record format: Fixed length
table description:
Key Start Len Index Type
1 2 8 unique double
2 15 10 multip. text packed stripped
3 219 8 multip. double
4 63 10 multip. text packed stripped
5 167 2 multip. unsigned short
6 177 4 multip. unsigned long
7 155 4 multip. text
8 138 4 multip. unsigned long
9 177 4 multip. unsigned long
193 1 text
isamchk -d -v 출력 예제:
ISAM file: company.ISM
Isam-version: 2
Creation time: 1996-08-28 11:44:22
Recover time: 1997-01-12 18:35:29
Data records: 1403698 Deleted blocks: 0
Datafile: Parts: 1403698 Deleted data: 0
Datafilepointer (bytes): 3 Keyfile pointer (bytes): 3
Max datafile length: 3791650815 Max keyfile length: 4294967294
Recordlength: 226
Record format: Fixed length
table description:
Key Start Len Index Type Root Blocksize Rec/key
1 2 8 unique double 15845376 1024 1
2 15 10 multip. text packed stripped 25062400 1024 2
3 219 8 multip. double 40907776 1024 73
4 63 10 multip. text packed stripped 48097280 1024 5
5 167 2 multip. unsigned short 55200768 1024 4840
6 177 4 multip. unsigned long 65145856 1024 1346
7 155 4 multip. text 75090944 1024 4995
8 138 4 multip. unsigned long 85036032 1024 87
9 177 4 multip. unsigned long 96481280 1024 178
193 1 text
Example of isamchk -eis 출력 예제:
Checking ISAM file: company.ISM
Key: 1: Keyblocks used: 97% Packed: 0% Max levels: 4
Key: 2: Keyblocks used: 98% Packed: 50% Max levels: 4
Key: 3: Keyblocks used: 97% Packed: 0% Max levels: 4
Key: 4: Keyblocks used: 99% Packed: 60% Max levels: 3
Key: 5: Keyblocks used: 99% Packed: 0% Max levels: 3
Key: 6: Keyblocks used: 99% Packed: 0% Max levels: 3
Key: 7: Keyblocks used: 99% Packed: 0% Max levels: 3
Key: 8: Keyblocks used: 99% Packed: 0% Max levels: 3
Key: 9: Keyblocks used: 98% Packed: 0% Max levels: 4
Total: Keyblocks used: 98% Packed: 17%
Records: 1403698 M.recordlength: 226 Packed: 0%
Recordspace used: 100% Empty space: 0% Blocks/Record: 1.00
Recordblocks: 1403698 Deleteblocks: 0
Recorddata: 317235748 Deleted data: 0
Lost space: 0 Linkdata: 0
User time 1626.51, System time 232.36
Maximum resident set size 0, Integral resident set size 0
Non physical pagefaults 0, Physical pagefaults 627, Swaps 0
Blocks in 0 out 0, Messages in 0 out 0, Signals 0
Voluntary context switches 639, Involuntary context switches 28966
isamchk -eiv 출력 예제:
Checking ISAM file: company.ISM
Data records: 1403698 Deleted blocks: 0
- check file-size
- check delete-chain
index 1:
index 2:
index 3:
index 4:
index 5:
index 6:
index 7:
index 8:
index 9:
No recordlinks
- check index reference
- check data record references index: 1
Key: 1: Keyblocks used: 97% Packed: 0% Max levels: 4
- check data record references index: 2
Key: 2: Keyblocks used: 98% Packed: 50% Max levels: 4
- check data record references index: 3
Key: 3: Keyblocks used: 97% Packed: 0% Max levels: 4
- check data record references index: 4
Key: 4: Keyblocks used: 99% Packed: 60% Max levels: 3
- check data record references index: 5
Key: 5: Keyblocks used: 99% Packed: 0% Max levels: 3
- check data record references index: 6
Key: 6: Keyblocks used: 99% Packed: 0% Max levels: 3
- check data record references index: 7
Key: 7: Keyblocks used: 99% Packed: 0% Max levels: 3
- check data record references index: 8
Key: 8: Keyblocks used: 99% Packed: 0% Max levels: 3
- check data record references index: 9
Key: 9: Keyblocks used: 98% Packed: 0% Max levels: 4
Total: Keyblocks used: 9% Packed: 17%
- check records and index references
[LOTS OF ROW NUMBERS DELETED]
Records: 1403698 M.recordlength: 226 Packed: 0%
Recordspace used: 100% Empty space: 0% Blocks/Record: 1.00
Recordblocks: 1403698 Deleteblocks: 0
Recorddata: 317235748 Deleted data: 0
Lost space: 0 Linkdata: 0
User time 1639.63, System time 251.61
Maximum resident set size 0, Integral resident set size 0
Non physical pagefaults 0, Physical pagefaults 10580, Swaps 0
Blocks in 4 out 0, Messages in 0 out 0, Signals 0
Voluntary context switches 10604, Involuntary context switches 122798
다음은 앞의 예제에서 사용한 테이블의 데이타와 인덱스 파일 크기이다:
-rw-rw-r-- 1 monty tcx 317235748 Jan 12 17:30 company.ISD
-rw-rw-r-- 1 davida tcx 96482304 Jan 12 18:35 company.ISM
isamchk가 출력하는 정보 타입에 대한 설명은 아래와 같다. "keyfile"은 인덱스 파일이다. "Record"
와 "row"는 같은 말이다.
ISAM file
ISAM (index) 파일 이름.
Isam-version
ISAM 포맷 버전. 현재는 항상 2.
Creation time
데이타 파일 생성 시간.
Recover time
인덱스/데이타 파일이 최근에 복구된 시간.
Data records
테이블에 있는 레코드 수.
Deleted blocks
지워진 블락이 차지하고 있는 공간. 이러한 공간을 줄이기 위해 테이블의 최적화를 할 수
있다. 13.5.3 [최적화] 참고.
Datafile: Parts
동적인 레코드 포맷을 위해, 얼마나 많은 데이타 블락이 있는지를 알림. 단편화된 레코드
가 없는 최적화된 테이블에서는 Data records 와 같다.
Deleted data
회수하지 않은 지원진 데이타의 바이트 수. 이렇나 공간을 없애기 위해 테이블을 최적화
할 수 있다. 13.5.3 [최적화] 참고.
Datafile pointer
데이타 파일 포인터의 크기로 바이트수. 일반적으로 2,3,4,5 바이트이다. 대부분의 테이
블은 2바이트로 관리를 한다. 그렇지만 아직까지 mysql에서는 제어를 할 수 없다. 고정 테이블에서
이는 레코드 주소(address)이다. 동적 테이블에서 이는 바이트 주소이다.
Keyfile pointer
인덱스 파일 포인터의 크기로 바이트. 일반적으로 1,2,3 바이트이다. 대부분의 테이블은
2바이트로 관리를 한다. 그렇지만 이 크기는 mysql에서 자동으로 계산이 된다. 항상 블락 주소이
다.
Max datafile length
테이블의 데이터 파일(.ISD 파일)의 최대 크기. 바이트.
Max keyfile length
테이블의 key file(.ISM 파일)의 최대 크기. 바이트.
Recordlength
각 레코드가 차지하고 있는 공간. 바이트.
Record format
테이블의 레코드를 저장하는데 사용된 포맷. 위에서 보여준 예제는 고정 길이를 사용하고 있다.
다른 값은 Compressed 와 Packed 이다.
table description
테이블의 모든 키의 목록. 각 키에 대한 자세한 설명은 다음과 같다:
Key
키의 숫자.
Start
Where in the record this index part starts.
레코드에서 인덱스가 시작하는 위치.
Len
How long this index part is. For packed numbers, this should always be the full length of the column. For
strings, it may be shorter than the full length of the indexed column, because you can index a prefix of a st
ring column.
인덱스 부분의 길이. For packed numbers(꽉 찬 숫자를 위해??? 번역이 이상..), 컬럼의 총
길이가 되어야 한다. 문자열에서는 인덱스된 컬럼의 총 길이보다 작아야 한다. 왜냐하면 문자열
컬럼 앞에 인덱....
Index
이 인덱스에 같은 값이 여러개 존재할 수 있는지 없는지를 나타냄.
Type
인덱스 부부의 데이터 타입. packed, stripped, empty 옵션을 가진 NISAM 데이타 타입이
다.
Root
루트 인덱스 블락의 주소.
Blocksize
각 인덱스 블락의 크기.기본값은 1024이다. 그렇지만 이 값은 컴파일 할때 변경할 수 있
다.
Rec/key
This is a statistical value used by the optimizer. It tells how many records there are per value for this key.
A unique key always has a value of 1. This may be updated after a table is loaded (or greatly changed) wit
h isamchk -a. If this is not updated at all, a default value of 30 is given.
최적화기(optimizer)에서 사용하는 통계적인 값. It tells how many records there are per valu
e for this key. unique 키는 항상 1의 값을 가진다. 이 값은 isamchk -a로 테이블이 로딩된 후에(또는
매우 많이 변경되었을때) 업데이트된다. 전혀 업데이트되지 않으면 기본값으로 30이 주어진다.
위의 첫번째 예제에서, 9번째 키는 두부분을 가진 멀티-파트 키이다.
Keyblocks used
What percentage of the keyblocks are used. Since the table used in the examples had just been reorganize
d with isamchk, the values are very high (very near the theoretical maximum).
키블락이 사용하고 있는 비율.(%) 예제의 테이블은 isamchk로 재조직화(reorganize)되었
기 때문에 값이 매우 높다.(이론적인 최대값에 매우 근접)
Packed
MySQL tries to pack keys with a common suffix. This can only be used for CHAR/VARCHAR/DECIM
AL keys. For long strings like names, this can significantly reduce the space used. In the third example ab
ove, the 4th key is 10 characters long and a 60% reduction in space is achieved.
.... 이름과 같은 long 문자열에서 공간 사용을 상당히 줄인다. 위의 네번째 예제에서 4번째 키는 10
문자 long 이고 60%의 공간이 줄었다.
(** 번역이 잘 안되는데 접미사같은 것을 붙여서 문자열 등의 공간을 줄인다 머 그런 것이겠지요 *
*)
Max levels
How deep the B-tree for this key is. Large tables with long keys get high values.
Records
테이블의 레코드수.
M.recordlength
평균 레코드 길이. 고정 길리 레코드의 테이블에서 이 값은 레코드 길이와 같다.
Packed
MySQL strips spaces from the end of strings. The Packed value indicates the percentage saving
s achieved by doing this.
mysql은 문자끝의 공백을 제거한다.Packed value는 이렇게 해서 절약된 공간의 비율을 말한다.
Recordspace used
데이타 파일이 사용하는 공간의 비율.
Empty space
데이타 파일이 사용하지 않는 공간의 비율.
Blocks/Record
레코드당 평균 블락수.(즉, 단편화된 레코드가 몇개의 링크로 구성되어 있는지) 고정-포
맷 테이블에서는 항상 1이다. 이 값은 가능한한 1에 가깝게 유지해야한다. 이 값이 너무 커지면 isa
mchk로 테이블을 최적화(reorganize)해야 한다. 13.5.3 [Optimizaiton] 참고.
Recordblocks
사용하는 블락(링크)수. 고정 포맷에서 이값은 레코드수와 같다.
Deleteblocks
삭제된 블락(링크)수.
Recorddata
데이타 파일이 사용하는 바이트수.
Deleted data
데이터 파일에서 삭제된(사용하지 않는) 바이트수.
Lost space
레코드가 매우 짧은 길이로 업데이트되면 약간의 공간을 잃게 된다. 이 값은 이러한 공간
의 bytes 합계이다.
Linkdata
동적 테이블 포맷을 사용할 때,레코드 조각은 포이터로 링크된다.Linkdata는 이런 포인터
에서 사용하는 저장 공간의 합이다.
pack_isam으로 테이블을 압축했으면, isamchk -d 는 각 테이블 컬럼에 대한 추가적인 정보를 출력
한다.이러한 정보와 그 정보가 무엇을 의미하는지에 대해서는 12.3 [pack_isam]을 참고.
{{}}13.5 파손 복구에 isamchk 사용하기.
mysql에서 데이타를 저장하는데 사용하는 파일 포맷은 광범위하게 테스트되었다. 그렇지만 데이
터베이스 테이블의 손상될 수 있는 외부적인 상황이 항상 있다:
ㅇ 쓰기 도중에 mysqld 프로세스가 죽었을때.
ㅇ 예상치 못하게 컴퓨터가 셧다운되었을때(예를 들어, 컴퓨터의 전원이 나가는 경우)
ㅇ 하드웨어 에러
이번 절에서는 mysql 데이터베이스에서 data의 손상을 체크하고 이에 대처하는 방법에 대해서 설
명한다.
손상 복구 작업을 할 때 테이터베이스의 각 테이블 tbl_name은 데이터베이스 디렉토리의 세 파일
에 조응한다는 것에 대해서 이해하고 있는 것이 중요하다:
파일 용도
`tbl_name.frm' 테이블 정의(형식) 파일
`tbl_name.ISD' 데이타 파일
`tbl_name.ISM' 인덱스 파일
세가지 파일 타입은 다양한 방법으로 손상을 당한다. 그렇지만 대부분의 문제는 데이타 파일과 인
덱스 파일에서 생긴다.
isamchk는 '.ISD' (데이타) 파일의 복사복을 만들어 작업을 한다. 이전의 '.ISD' 파일을 제거하고 새
로운 파일을 이전의 파일 이름으로 바꾸면서 복구 작업을 마친다. --quick 옵션을 사용하면 isamchk
는 임시 '.ISD' 파일을 만들지 않는다. 대신 '.ISD' 파일이 정확하다고 가정하여 '.ISD' 파일은 손대지
않고 새로운 인덱스 파일만 생성한다. isamchk는 자동으로 'ISD' 파일이 손상되었는지 확인하고 손
상되었을 경우 복구 작업을 중지하므로 --quick 옵션을 사용하는 것은 안전하다. 두개의 -quick 옵
션을 사용할 수 있다. 이런 경우 특정한 에러(중복된 키 등)에서 취소를 하지는 않지만 '.ISD' 파일
을 수정하여 문제를 해결하려고 한다.일반적으로 두개의 --quick 옵션을 사용하는 것은 복구작업
을 수행하기 위한 디스크 공간이 거의 없을 경우에만 유용하다. 이런 경우 isamchk를 수생하기전
에 최소한 백업을 해 놓아야 한다.
{{}}
13.5.1 에러가 났을때 테이블 점검 방법
테이블을 점검하기 위해 다음의 명령을 사용한다:
:
isamchk tbl_name
모든 에러의 99.99%를 발견할 수 있다. 이 경우 발견하지 못하는 것은 데이타 파일과 관
련된 손상이다.(일반적으로 거의 생기지 않는다) 테이블을 점검하고자 한다면 일반적으로는 아무
런 옵션을 주지 않거나 -s 나 --silent 옵션을 주어 isamchk를 수행하는 것이다.
isamchk -e tbl_name
이 옵션은 모든 데이터를 완전하게 점검한다.( -e 는 "extended check" 를 의미한다) 모든
키가 정확한 레코드를 가리키고 있는지 점검한다.It does a check-read of every key for each row to ve
rify that they indeed point to the correct row. 많은 키를 가진 큰 테이블에서는 시간이 많이 걸린다. is
amchk는 일반적으로 첫번째 에러를 발견하면 실행을 멈춘다. 더 많은 정보를 얻고자 한다면, --ver
bose (-v) 옵션을 추가할 수 있다. 이 옵션을 추가하면 isamchk는 최대 20개의 에러가 있을 때까지
계속 실행을 한다. 일반적으로는 간단한 isamchk (테이블 이름 외에 아무런 인수도 없는)만으로 충
분하다.
isamchk -e -i tbl_name
위의 명령과 같다. 그렇지만 -i 옵션을 붙이면 isamchk가 정보의 통계를 출력한다.
13.5.2 테이블 복구방법
손상된 테이블의 징후는 일반적으로 질의가 갑자기 중지되고 다음과 같은 에러를 낸다:
ㅇ`tbl_name.frm' is locked against change
ㅇCan't find file `tbl_name.ISM' (Errcode: ###)
ㅇGot error ### from table handler (Error 135 is an exception in this case)
ㅇUnexpected end of file
ㅇRecord file is crashed
이런 경우, 테이블을 고쳐야 한다. isamchk는 일반적으로 잘못된 것을 감지하고 대부분을 고친다.
복구 과정은 아래에서 설명하는대로 4단계가 있다.시작하기 전에 먼저 데이타베이스 디렉토리로
이동하고(cd 명령 이용) 테이블 파일의 퍼미션을 확인해야 한다. mysqld를 실행할 수 잇는 유닉스
사용자가 읽을 수 있는지 확인해야 한다. (또한 작업을 하려는 사용자. 왜냐하면 점검하려는 파일
에 접근해야 하기 때문이다) 파일을 수정해야 한다면 파일에 쓰기 권한이 있어야 ㅎ난다.
1단계 : 테이블 점검
isamchk *.ISM 또는 (충분한 시간이 있다면 isamchk -e *.ISM). 불필요한 정보를 보지 않으려면 -s (s
ilent) 옵션을 사용한다.
isamchk에서 에러가 있다고 알리는 테이블만 고쳐야 한다. 이런 테이블의 경우는 2단계로 넘어간
다.
점검하면서 에러를 만났을 때(out of memory 에러 등) 또는 isamchk가 기능을 멈추었을 때 3단계로
넘어간다.
2단계 : 쉽고 안전한 복구
먼저 isamchk -r -r tbl_name을 시도한다. (-r -q는 "빠른 복구 모드"를 의미) 이경우 데이타 파일은 손
대지 않고 인덱스 파일 복구를 시도한다. 데이타 파일이 제대로 되어 있고 삭제 링크가 데이타 파
일내의 정확한 위치를 가리키고 있다면, 원활하게 작동을 하고 테이블을 고칠 것이다.(If the data fi
le contains everything that it should and the delete links point at the correct locations within the data file, t
his should work and the table is fixed.) 다음 테이블을 고치자. 그게 아니라면 다음 과정을 사용한다:
1. 진행하기 전에 데이타 파일의 백업본 만들기
2. isamchk -r tbl_name 사용.(-r 는 "복구 모드" 의미) 그러면 데이타 파일에서 정확하지 않
은 레코드와 삭제된 레코드를 제거하고 인덱스 파일을 재구성한다.
3. 앞의 과정이 실패하면, isamchk --safe_recover tbl_name을 사용. Safe recovery 모드는 구
식 복구 방법을 사용하며 일반적인 복구 모드로 할 수 없는 몇가지 경우에 사용할 수 있다.(그렇지
만 더 느리다)
점검하면서 에러를 만났을 때(out of memory 에러 등) 또는 isamchk가 기능을 멈추었을 때 3단계로
넘어간다.
3단계 : 어려운 복구
인덱스 파일의 첫 16k 블락이 파괴되거나 정확하지 않은 정보를 가지고 있을 때, 또는 인덱스 파일
이 없는 경우에만 이번 단계까지 온다. 이경우 새로운 인덱스 파일을 만들어야 한다. 다음과 같이
하자:
1. 데이타 파일을 안전한 장소로 이동.
2. 새로운(빈) 데이타와 인덱스 파일을 만들기 위해 table description 파일을 사용:
shell> mysql db_name
mysql> DELETE FROM tbl_name;
mysql> quit
3. 이전의 데이타 파일을 새롭게 만든 데이터 파일로 복사. (이전의 데이타 파일을 새로운
파일로 옮기지는 말자; 잘못되었을 경우 복사본을 유지하길 원할 것이다)
2단계로 가자. isamchk -r -q는 이제 제대로 작동을 할 것이다. (무한 루프가 되면 안된다. This shoul
dn't be an endless loop).
4단계 : 매우 어려운 복구
description 파일 또한 손상을 입었을 경우에만 이번 단계까지 온다. description 파일은 테이블을 만
든 이후에 변경이 되지 않기 때문에, 이러한 경우는 결코 생겨서는 안된다.
1. 백업본에서 description 파일을 복구해 3단계로 넘어간다. 또한 인덱스 파일을 복구할
수 있고 2단계로 넘어간다. 뒤의 경우 isamchk -r로 시작을 해야 한다.
2. 백업본이 없지만 정확히 어떻게 테이블을 만들었는지 알고 있다면, 다른 데이터베이
스에 테이블의 복사본을 만든다. 새로운 데이타 파일을 제거하고 다른 데이터베이스의 description
과 인덱스 파일을 손상된 데이터베이스로 옮긴다. 이렇게 하면 새로운 description 과 인덱스 파일
을 얻을 수 있지만 데이타 파일만 따로 남아있다. 2단계로 가서 인덱스 파일을 재구성한다.
13.5.3 테이블 최적화
레코드를 삭제하거나 업그레이드 하면서 생긴 단편화된 레코드를 모으고 불필요하고 낭비된 공간
을 제거하기 위해 복구 모드로 isamchk를 실행한다:
shell> isamchk -r tbl_name
SQL OPTIMIZE TABLE 문을 이용하여 같은 방법으로 테이블을 최적화할 수 있다. OPTIMIZE TA
BLE 은 쉽지만 isamchk가 더 빠르다.
또한 isamchk는 테이블의 성능을 향상시킬 수 있는 몇가지 옵션을 사용할 수 있다:
-S, --sort-index
high-low 순서로 인덱스 트리 블락을 정열. 검색을 최적화하고 키에 의한 테이블 검색을
빠르게 한다.
-R index_num, --sort-records=index_num
인덱스에 따라 레코드를 정열. 데이타를 지역화하고 이 인덱스를 사용하는 SELECT 와 O
RDER BY 오퍼레이션의 속도를 향상시킨다. (처음에는 정열을 하는 시간이 엄청 느리다!) 테이블
의 인덱스 번호를 확인하려면 SHOW INDEX를 사용하면 되며, SHOW INDEX는 isamchk가 인덱스
를 검색하는 순서대로 테이블의 인덱스를 보여준다. 인덱스는 1번부터 번호가 매겨진다.
-a, --analyze
테이블에서 키의 분포를 분석. 나중에 테이블에서 레코드를 가져올 때 조인의 성능을 향
상시킨다.
15. mysql ODBC 지원
mysql은 MyODBC 프로그램을 통해 ODBC에 대한 지원을 제공한다.
15.1 MyODBC 를 지원하는 운영체제
MyODBC 는 윈도우95와 NT에서 32비트 ODBC(2.50) 레벨 0 드라이버이다. 우리는 누군가가 윈
도우 3.x 에 이 프로그램을 포팅해주길 바란다.
(** 당근, 저는 능력안됨 **)
15.2 MyODBC에 문제가 있는 경우
ODBC는 액세스, Admndemo.exe, C++-빌더, Centura Team Developer (formerly Gupta SQL/Win
dows), 콜드퓨전(솔라리스용), 크리스탈 레포트, 델파이, 엑셀, iHTML, FileMaker Pro, 폭
스프로, 노츠 Notes 4.5/4.6, SBSS, perl DBD-ODBC, 파라독스, 파워빌더, VC++, 비주얼 베
이직에서 테스팅되었다.
MyODBC 에서 잘 작동하는 다른 애플리케이션이 있으면 myodbc@tcx.se 에 메일을 보내주세
요~ (** 이정도는 해 주어야 서로서로 좋겠지용**)
어려움에 부딪치면, ODBC 매니저에서의 로그 파일과 MyODBC 로그에 대해서 알고 싶다. 이런
파일이 있으면 문제를 조금이나마 줄이는데 도움이 될 것이다.
MyODBC log 파일을 얻으려면 MyODBC 연결/설정 화면의 'Trace MyODBC' 옵션에 체크를 한다.
로그는 `c:\myodbc.log' 에 기록될 것이다. 이 옵션이 제대로 작동하려면 MYSQL2.DLL 이 아
니라 MYSQL.DLL 을 사용해야 한다는 것을 기억하자!
15.3 MyODBC 와 잘 작동하는 프로그램
대부분의 프로그램은 myodbc 와 잘 작동한다. 그렇지만 아래의 각 목록에 있는 것은 우리가
직접 테스팅하였거나 다른 사람들이 제대로 작동한다고 확증해 준 것이다::
ㅇ액세스
액세스와는 잘 작동한다:
- 테이블에서 프라이머리 키를 지정해야 한다.
- 업데이트가 되길 원하는 모든 테이블에 timestamp를 가지고 있어야 한다.
- double float 필드만을 사용해야 한다. single floats 와 비교를 하면 실패한다.
- mysql에 연결할 때 'Return matching rows' 옵션 필드에 체크를 하자.
- NT에서의 액세스는 BLOB 컬럼을 OLE OBJECTS 로 보고한다. 대신 MEMO 컬럼을 가
지길 원하면 ALTER TABLE 을 이용해 컬럼을 TEXT 로 바꾸자.
ㅇ 엑셀
잘 작동한다 몇가지 팁이 있다:
dates 에서 문제가 있으면 CONCAT() 함수를 사용하여 string 으로서 select 를 사용하자.
예를 들면:
select CONCAT(rise_time), CONCAT(set_time) from sunrise_sunset;
문자열로서 값을 가져오며 엑셀97에서 time 값이 제대로 인식될 것이다.
이 예제에서 CONCAT()의 목적은 ODBC가 컬럼을 "string type"으로 생각하도록 속이는 것이
다. CONCAT() 가 없으면, ODBC는 컬럼을 time 타입으로 인식하며 엑셀은 이것을 이해하는데
실패한다.
이것은 엑셀의 버그라는 것을 기억하자. 엑셀은 자동적으로 문자열(string)을 time으로 변
환한다. 소스가 텍스트 파일이라면 잘 될 것이다. 그렇지만 소스가 각 컬럼의 정확한 타입
을 보고하는 ODBC 연결이라면 분명히 어리석은 짓이다.
ㅇ odbcadmin
ODBC 테스트 프로그램.
ㅇ 델파이
DBE 3.2 나 이후 버전을 사용해야 한다. mysql에 연결할 때 'Don't optimize column width'
옵션 필드에 체크를 한다.
물론, 여기에는 myodbc 를 위한 ODBC 목록과 BDE 목록을 세팅하기 위해 잠재적으로 유용한
델파이 코드가 있다. (BDE 목록은 델파이 슈퍼 페이지에서 공개로 받을 수 있는 BDE Alias
데이터를 필요로 한다) : (Thanks to Bryan Brunton bryan@flesherfab.com for this)
fReg:= TRegistry.Create;
fReg.OpenKey('\Software\ODBC\ODBC.INI\DocumentsFab', True);
fReg.WriteString('Database', 'Documents');
fReg.WriteString('Description', ' ');
fReg.WriteString('Driver', 'C:\WINNT\System32\myodbc.dll');
fReg.WriteString('Flag', '1');
fReg.WriteString('Password', ");
fReg.WriteString('Port', ' ');
fReg.WriteString('Server', 'xmark');
fReg.WriteString('User', 'winuser');
fReg.OpenKey('\Software\ODBC\ODBC.INI\ODBC Data Sources', True);
fReg.WriteString('DocumentsFab', 'MySQL');
fReg.CloseKey;
fReg.Free;
Memo1.Lines.Add('DATABASE NAME=');
Memo1.Lines.Add('USER NAME=');
Memo1.Lines.Add('ODBC DSN=DocumentsFab');
Memo1.Lines.Add('OPEN MODE=READ/WRITE');
Memo1.Lines.Add('BATCH COUNT=200');
Memo1.Lines.Add('LANGDRIVER=');
Memo1.Lines.Add('MAX ROWS=-1');
Memo1.Lines.Add('SCHEMA CACHE DIR=');
Memo1.Lines.Add('SCHEMA CACHE SIZE=8');
Memo1.Lines.Add('SCHEMA CACHE TIME=-1');
Memo1.Lines.Add('SQLPASSTHRU MODE=SHARED AUTOCOMMIT');
Memo1.Lines.Add('SQLQRYMODE=');
Memo1.Lines.Add('ENABLE SCHEMA CACHE=FALSE');
Memo1.Lines.Add('ENABLE BCD=FALSE');
Memo1.Lines.Add('ROWSET SIZE=20');
Memo1.Lines.Add('BLOBS TO CACHE=64');
Memo1.Lines.Add('BLOB SIZE=32');
AliasEditor.Add('DocumentsFab','MySQL',Memo1.Lines);
ㅇ C++빌더
BDE 3.0과 테스팅을 했다. 유일하게 알려진 문제는 테이블 스키마를 변경할 대로 질의 필드
가 업데이트되지 않는다. 그런데 BDE는 문제는 아닌 것 같지만 index PRIMARY 에서만 프라
이머리 키를 인식하지 못하는 것으로 보인다.
Tested with BDE 3.0. The only known problem is that when the table schema changes, q
uery fields are not updated. BDE however does not seem to recognize primary keys, onl
y the index PRIMARY, though this has not been a problem.
ㅇ 비주얼 베이직
테이블을 업데이트 가능하게 하려면 테이블의 프라이머리 키를 정의해야 한다.
(** 이 부분은 제가 출력한 ps 파일에는 없는데 웹사이트에는 있네요... **)
{{}}
15.4 ODBC 관리자 프로그렘 설정 방법
윈도우 95에서 서버의 이름을 지정하는 것에는 세가지 방법이 있다:
- 서버의 IP 주소 사용.
-'lmhosts' 파일에 다음의 정보 추가:
ip hostname
예를 들면
194.216.84.21 my
- DNS를 사용하여 PC를 설정
"ODBC setup" 을 채우는 예제:
Windows DSN name: taejun
Description: This is my love database
MySql Database: love
Server: 194.216.84.21
User: taejun
Password: my_password
Port:
윈도우즈 DSN 이름 필드의 값은 윈도우즈 ODBC 셋업에서 유일한 값이다.
ODBC 셋업 화면에서 서버, 유저, 패스워드, 포드 필드에 값을 지정할 필요는 없다. 그러나
지정을 해두면 그 값이 연결을 시도할 때 기본값으로 사용된다. 그때마다 값을 바꿀 수 있
다.
포트 번호가 주어지지 않으면, 기본 포트(3306)이 사용된다.
15.5 ODBC에서 AUTO_INCREMENT 컬럼의 값 가져오기
일반적인 문제는 INSERT 에서 어떻게 자동으로 생성되는 ID 값을 가져올 수 있느냐이다. OD
BC에서 다음과 같이 할 수 있다. (auto 가 AUTO_INCREMENT 필드라고 가정):
INSERT INTO foo (auto,text) VALUES(NULL,'text');
SELECT LAST_INSERT_ID();
또는, 다른 테이블에 ID를 입력한다면 다음과 같이 할 수 있다:
INSERT INTO foo (auto,text) VALUES(NULL,'text');
INSERT INTO foo2 (id,text) VALUES(LAST_INSERT_ID(),'text');
다른 ODBC 애플리케이션(최소한 델파이와 액세스)에서 유용하게 사용하기 위해 다음의 질의
를 새롭게 입력된 열을 찾는데 사용할 수 있다:
SELECT * FROM tbl_name WHERE auto IS NULL;
17. 일반적인 문제 해결 방법
17. 1. 데이터베이스 복사(복제?)
데이터베이스를 복사하는 가장 일반적인 방법은 업데이트 로그를 이용하는 것이다. 9.2 [Th
e update log] 참고. 이 경우 마스터로 작동하는 데이터베이스 하나(데이터가 변경된 곳)와
슬레이브로 작동하는 다른 하나의 데이터베이스가 필요하다. 슬레이브를 업데이트하려면 단
지 mysql < update_log을 하면 된다. 슬레이드 데이터베이스에 맞는 호스트, 유저, 패스워
드 옵션을 지정한다. 그리고 입력값으로 마스터 데이터베이스의 업데이트 로그를 사용한다.
테이블에서 삭제한 것이 없다면, 마지막으로 복사를 한 후 (마지막으로 복사한 시간을 비
교) 테이블에서 입력되거나 변경된 열을 찾아내기 위해 TIMESTAMP 컬럼을 사용할 수 있고
미러링되는 데이터베이스에 변경된 자료만 복사를 한다.
업데이트 로그(for deletes)와 timestamps(on both sides)를 같이 사용하여 두가지 방법으
로 업데이트하는 시스템을 만들 수 있다. 그러나 이런 경우 두가지 ends(?)에서 변경된 동
일한 데이터에서 충돌을 관리할 수 있어야 한다. 아마도 어떤 것이 업데이트되었는지 결정
하기 위해 예전 버전을 유지하고 싶을 것이다.
It is possible to make a two-way updating system using both the update log (for delet
es) and timestamps (on both sides). But in that case you must be able to handle confl
icts when the same data have been changed in both ends. You probably want to keep the
old version to help with deciding what has been updated.
이 경우 복사(복제)는 SQL문으로 이루어지기 때문에, 데이터베이스를 업데이트하는 문장에
서 다음의 함수를 사용해서는 안된다; 여기에서는 원본 데이터베이스와 동일한 값을 반환하
지 않을 수 있다:
DATABASE()
GET_LOCK() and RELEASE_LOCK()
RAND()
USER(), SYSTEM_USER() or SESSION_USER()
VERSION()
timestamp는 필요한 경우에 미러되는 곳으로 보내기지 때문에 모든 time 함수는 안전하게
사용할 수 있다. LAST_INSERT_ID() 또한 안전하게 사용할 수 있다.
All time functions are safe to use, as the timestamp is sent to the mirror if needed.
LAST_INSERT_ID() is also safe to use.
17.2 데이터베이스 백업
mysql 테이블은 파일로 저장되기 때문에 백업하기가 쉽다. 일관된 백업 작업을 위해
관련된 테이블에 LOCK TABLES를 실행하자. 7.23 [LOCK TABLES/UNLOCK TABLES synta
x]를 참고. 단지 읽기 락만이 필요하다; 데이터베이스 디렉토리의 파일 복사본을 만드
는 동안에도 다른 스레드에서는 테이블에 질의를 계속 할 수 있다. SQL 레벨의 백업을
하고자 한다면 SELECT INTO OUTFILE을 사용할 수 있다.
데이터베이스를 백업하는 다른 방법은 mysqldump 프로그램을 사용하는 것이다:
데이터베이스에 대한 풀 백업 실행:
shell> mysqldump --tab=/path/to/some/dir --lock-tables --opt
서버에서 업데이트를 하지 않는한 간단하게 모든 테이블 파일(`*.frm', `*.ISD' , `*.
ISM' 파일)을 복사할 수 있다. mysqld가 실행되고 있으면 멈추어야 한다. 그러고나서
--log-update 옵션으로 다시 시작하자. ''hostname.n'의 형식을 가진 로그 파일이 생
성될 것이다. n은 mysqladmin refresh, mysqladmin flush-logs, the FLUSH LOGS 문,
또는 서버를 재시작할때마다 증가하는 숫자이다. 이렇게 생긴 로그 파일을 이용해 mys
qldump를 수행하고 나서 데이터베이스에 변화된 내용을 복사(복제)하는데 필요한 정보
를 얻을 수 있다.
복원하고자 한다면, 먼저 isamchk -r을 사용해 테이블을 복구하자. 모든 경우 99.9%가 제대
로 수행된다. isamchk가 실패하면 다음의 과정대로 따르자:
기존의 mysqldump 백업을 복원한다.
업데이트 로그에서 업데이트를 다시 수행하기 위해 다음의 명령을 실행한다:
shell> ls -1 -t -r hostname.[0-9]* | xargs cat | mysql
ls는 정확한 순서대로 로그 파일을 가져오는데 사용된다.
또한 SELECT * INTO OUTFILE 'file_name' FROM tbl_name을 이용해 선택적인 백업을 할 수
있으며 레코드가 중복되는 것을 방지하기 위해 LOAD DATA INFILE 'file_name' REPLACE ...
을 이용해 복원할 수 있다. 이경우에는 테이블에서 PRIMARY 키나 UNIQUE 키가 필요하다. RE
PLACE 키워드는 새로운 레코드에서 unique 키 값이 같은 이전의 레코드가 중복되는 경우 이
전의 레코드를 새로운 레코드로 교체한다.
17.3 같은 머신에서 여러개의 mysqld 서버 실행하기
같은 머신에서 다중의 서버를 사용하길 원할 수 있다. 예를 들어, 이전의 서버를 그대
로 두고 새로운 mysql 릴리즈를 테스팅하는 경우가 있을 수 있다. 또는 다른 고객들
에게 독립적인 mysql 설치를 제공하길 원하는 인터넷 서비스 제공자일 수 있다.
다중 서버를 사용하길 원하면, 가장 쉬운 방법은 다른 TCP/IP 포트와 소켓 파일로 서버를
컴파일해서 서버에서 동일한 TCP/IP 포트나 소켓 파일을 청취하지 않도록 할 수 있다.
이미 사용하고 있는 서버가 기본 포트와 소켓 파일로 구성되어 있다고 가정해보자. 그러면
다음과 같은 명령으로 새로운 서버를 설정하자:
shell> ./configure --with-tcp-port=port_number \
--with-unix-socket=file_name \
--prefix=/usr/local/mysql-3.22.9
여기서 port_number와 file_name은 기본 포트 숫자 및 소켓 파일의 경로와는 달라야하며, -
-prefix 값은 현재 설치되어 있는 mysql과는 다른 디렉토리를 지정해야 한다.
Here port_number and file_name should be different than the default port number and s
ocket file pathname, and the --prefix value should specify an installation directory
different than the one under which the existing MySQL installation is located.
다음의 명령으로 현재 실행되고 있는 mysql 서버의 소켓과 파일을 확인할 수 있다:
shell>; mysqladmin -h hostname --port port_number variables
사용하고 있는 포트에서 실행되고 있는 mysql 서버가 있다면, 소켓 이름을 포함해 mysql의
가장 중요한 설정 변수의 목록을 알 수 있다. 다중 mysqld 서버를 시작하고 중지시키기 위
해 시스템의 초기화 스크립트(일반적으로 ''mysql.server')를 수정해야 한다.
다른 포트와 소켓으로 서버를 시작하기 위해 새로운 mysql 서버를 재컴파일할 필요는 없다.
safe_mysqld를 시작할 때 옵션으로 포트와 소켓을 지정할 수 있다:
shell>; /path/to/safe_mysqld --socket=file-name --port=file-name
동일한 데이터베이스 디렉토리에서 로그를 기록하도록 하면서 또 다른 서버를 실행하고자
한다면, safe_mysqld 에 --log 와 --log-update 를 이용해 로그 파일의 이름을 지정해 주어
야 한다. 그렇지 않으면 두 서버가 같은 로그 파일에 기록을 하려고 할 것이다.
주의 : 일반적으로 동일한 데이터베이스의 자료를 업데이트하는 두개의 서버를 사용해서는
안된다! 운영체제에서 fault-free 시스템 로킹(locking)을 지원하지 않는다면, 좋지 않은
결과를 보게 될 것이다. (** fault-free란 정확히 무엇인지 모르겠군요. 아마도 락을 거는
데 문제가 있다면 그 락을 해제하는 것으로 보입니다. **)
두번재 서버에서 다른 데이터베이스 디렉토리를 사용하기 원하면 safe_mysqld 에 --datadir
=path 옵션을 사용할 수 있다.
다른 포트에서 실행중인 mysql 서버에 접근하길 원한다면 다음의 방법을 사용할 수 있다:
ㅇ 클라이언트에서 다음의 옵션을 가지고 시작. --host 'hostname' --port=port-n
umer or [--host localhost] --socket=file-name.
ㅇ C나 펄 프로그램에서 mysql 서버에 접속할 때 포트와 소켓 인자를 준다.
ㅇ 클라이언트를 시작하기 전에 MYSQL_UNIX_PORT 와 MYSQL_TCP_PORT 환경 변수를
설정. 일반적으로 특정한 소켓이나 포트를 사용하면, 'login' 파일에 환경 변수를 설정하
자. 12.1 [Programs] 참고.
ㅇ 홈 디렉토리에서 '.my.cnf' 파일에 기본 소켓과 TCP/IP 소켓을 지정. 4.15.4
[Option files] 참고.
18 MySQL client tools and APIs
18.1 MySQL C API
C API 코드는 MYSQL에 함께 배포되며, 이것은 mysqlclient 라이브러리에 포함되어져 C 프
로그램으로 하여금 데이터베이스에 접근할 수 있도록 해준다. MySQL 소스 배포판의 많은
클라이언트들이 C로 코딩되어 있으며, C API를 사용하는 방법에 대한 설명을 찾고자 할 때
이 클라이언트들의 코드를 참조할 수 있다.
18.2 C API datatypes
-----------------------------------------------------------------------------------------
|데이터 형식 | 설명 |
-----------------------------------------------------------------------------------------
| MYSQL | 데이터 베이스와의 하나의 연결을 다루는 구조체로서 거의 모든 |
| | MySQL 함수들에서 사용된다. |
-----------------------------------------------------------------------------------------
| MYSQL_RES | 행을 리턴하는 질의들(SELECT, SHOW, DESCRIBE, EXPLAIN)의 결 |
| | 과를 표현하는 구조체로서 어떤 질의의 결과로서 리턴되는 정보들 |
| | 을 결과 셋(result set)이라고 부른다. |
-----------------------------------------------------------------------------------------
| MYSQL_ROW | 한 행의 데이터를 표현하는 데이터 형식이다. 현재 이것은 counted |
| | byte string들의 배열로 구현되어 있다. 필드값이 이진 데이터를 포 |
| | 함할 수 있는 경우에는 값 내부에 null 바이트를 가지고 있을 수 |
| | 있기 때문에 이 데이터 형식을 null-terminated string으로 다룰 수 |
| | 없다. 행들은 mysql_fetch_row() 함수를 호출함으로써 얻어올 수 있 |
| | 다. |
-----------------------------------------------------------------------------------------
| MYSQL_FIELD | 필드 명, 형식, 크기와 같은 필드에 대한 정보를 포함하는 구조체 |
| | 이다. 이 구조체의 멤버들은 아래에서 상세히 기술된다. 각각의 필 |
| | 드에 대하여 mysql_fetch_field() 함수를 호출함으로써 각 필드에 대|
| | 한 MYSQL_FIELD 구조체의 값을 얻을 수 있다. 필드에 들어있는 |
| | 실제 값은 이 구조체의 멤버가 아니며, 실제 데이터는 |
| | MYSQL_ROW 구조체에 들어가게 된다. |
-----------------------------------------------------------------------------------------
| MYSQL_FIELD_OFFSET | MySQL 필드 리스트에 들어가는 변위(offset)을 표현하는 type-safe |
| | 형식이다(mysql_field_seek() 함수에서 사용된다). Offset은 행 내에|
| | 서의 필드의 개수이며 0에서 시작한다. |
-----------------------------------------------------------------------------------------
| my_ulonglong | 행들의 개수, mysql_affected_rows(), mysql_num_rows(), |
| | mysql_insert_id() 함수에서 사용되는 형식이다. 이 형식은 0에서 |
| | 1.84e19까지의 값을 가질 수 있다. 어떤 시스템에서는 |
| | my_ulonglong 형식의 값을 출력하는데 문제가 있을 수 있는데, 이 |
| | 경우에 이 값을 출력하기 위해서는 이것을 unsigned long 형식으로 |
| | 변환한 후 '%lu' 프린트 형식을 사용한다. 예를 들면 다음과 같다: |
| | |
| | printf (Number of rows: %lu\n", (unsigned long) \ |
| | mysql_num_rows(result)); |
-----------------------------------------------------------------------------------------
MYSQL_FIELD 구조체는 다음과 같은 멤버들을 가진다:
char * name
- 필드의 이름
char * table
- 이 필드가 계산된 필드(calculated field)가 아닌 경우, 이 필드를 가지고 있는
테이블의 이름. 계산된 필드인 경우 NULL 포인터를 가진다
char * def
- 이 필드의 디폴트 값(mysql_list_fields() 함수를 사용하는 경우에만 설정된다)
enum enum_field_types type
- 필드의 형식(type). 필드 형식은 다음 테이블 값 중에 하나이다.
-------------------------------------------------------------------------
| Type value | Type meaning |
-------------------------------------------------------------------------
| FIELD_TYPE_TINY | TINYINT field |
-------------------------------------------------------------------------
| FIELD_TYPE_SHORT | SMALLINT field |
-------------------------------------------------------------------------
| FIELD_TYPE_LONG | INTEGER field |
-------------------------------------------------------------------------
| FIELD_TYPE_INT24 | MEDIUMINT field |
-------------------------------------------------------------------------
| FIELD_TYPE_LONGLONG | BIGINT field |
-------------------------------------------------------------------------
| FIELD_TYPE_DECIMAL | DECIMAL or NUMERIC field |
-------------------------------------------------------------------------
| FIELD_TYPE_FLOAT | FLOAT field |
-------------------------------------------------------------------------
| FIELD_TYPE_DOUBLE | DOUBLE or REAL field |
-------------------------------------------------------------------------
| FIELD_TYPE_TIMESTAMP | TIMESTAMP field |
-------------------------------------------------------------------------
| FIELD_TYPE_DATE | DATE field |
-------------------------------------------------------------------------
| FIELD_TYPE_TIME | TIME field |
-------------------------------------------------------------------------
| FIELD_TYPE_DATETIME | DATETIME field |
-------------------------------------------------------------------------
| FIELD_TYPE_YEAR | YEAR field |
-------------------------------------------------------------------------
| FIELD_TYPE_STRING | String (CHAR or VARCHAR) field |
-------------------------------------------------------------------------
| FIELD_TYPE_BLOB | BLOB or TEXT field (use max_length to |
| | determine the maximum length) |
-------------------------------------------------------------------------
| FIELD_TYPE_SET | SET field |
-------------------------------------------------------------------------
| FIELD_TYPE_ENUM | ENUM field |
-------------------------------------------------------------------------
| FIELD_TYPE_NULL | NULL-type field |
-------------------------------------------------------------------------
| FIELD_TYPE_CHAR | Deprecated: use FIELD_TYPE_TINY instead |
-------------------------------------------------------------------------
IS_NUM() 매크로(macro)를 이용하여 필드가 정수형(numeric type)인가를 테스트할 수 있다.
IS_NUM()에 형식값(type value)를 인수로 넘겼을 때 필드가 정수형이면 'TRUE'를 리턴한다:
if (IS_NUM(field->type)) {
printf("Field is numeric\n");
}
unsigned int length
- 필드의 길이(width)
unsigned int max_length
- 결과 셋에 대한 필드의 최대 길이(maximum width). mysql_list_fields() 함수를
사용하는 경우 이 멤버에는 필드의 최대 길이가 저장된다.
unsigned int flags
- 필드에 대한 Different bit-flags. 플래그 값은 0 혹은 다음의 비트 셋(bit set) 중에
하나이다.
-----------------------------------------------------------------
| 플래그 값 | 의미 |
-----------------------------------------------------------------
| NOT_NULL_FLAG | Field can't be NULL |
-----------------------------------------------------------------
| PRI_KEY_FLAG | Field is part of a primary key |
-----------------------------------------------------------------
| UNIQUE_KEY_FLAG | Field is part of a unique key |
-----------------------------------------------------------------
| MULTIPLE_KEY_FLAG | Field is part of a key |
-----------------------------------------------------------------
| UNSIGNED_FLAG | Field has the UNSIGNED attribute |
-----------------------------------------------------------------
| ZEROFILL_FLAG | Field has the ZEROFILL attribute |
-----------------------------------------------------------------
| BINARY_FLAG | Field has the BINARY attribute |
-----------------------------------------------------------------
| AUTO_INCREMENT_FLAG | Field has the AUTO_INCREMENT attribute|
-----------------------------------------------------------------
| ENUM_FLAG | Field is an ENUM (deprecated) |
-----------------------------------------------------------------
| BLOB_FLAG | Field is a BLOB or TEXT (deprecated) |
-----------------------------------------------------------------
| TIMESTAMP_FLAG | Field is a TIMESTAMP (deprecated) |
-----------------------------------------------------------------
BLOB_FLAG, ENUM_FLAG, TIMESTAMP_FLAG 플래그들은 이들 플래그들이 자신의 형식
(type)의 속성을 표시하기 보다는 필드의 형식을 표시하기 때문에 이 플래그들을 사용하는
것은 좋지 않다. 그 대신 'field->type' 값을 FIELD_TYPE_BLOB, FIELD_TYPE_ENUM, 혹은
FIELD_TYPE_TIMESTAMP과 비교하는 것이 좋다. 아래의 예제는 플래그 값들의 전형적인
사용법에 대하여 설명한다:
if (field->flags & NOT_NULL_FLAG) {
printf("Field can't be null\n");
}
플래그 값의 불리언 상태(boolean status)를 결정하는데 다음과 같은 매크로(macro)들을 사용
할 수 있다:
IS_NOT_NULL(flags) 이 필드가 'NOT NULL'로 정의되어 있으면 참
IS_PRI_KEY(flags) 이 필드가 primary key인 경우에 참
IS_BLOB(flags) 이 필드가 BLOB이나 TEXT인 경우에 참
unsigned int decimals
- 정수형 필드(numeric field)인 경우 자리수(number of decimal)
18.3 C API function overview
-------------------------------------------------------------------------------------------------
| Function | Description |
-------------------------------------------------------------------------------------------------
| mysql_affected_rows() | 가장 최근의 UPDATE, DELETE, INSERT 질의에 의한 결과 |
| | 행의 개수 를 리턴한다. |
-------------------------------------------------------------------------------------------------
| mysql_close() | 서버와의 연결을 종료한다. |
-------------------------------------------------------------------------------------------------
| mysql_connect() | 서버와 연결하며 이 함수를 사용하기보다는 |
-------------------------------------------------------------------------------------------------
| | mysql_real_connect() 함수를 사용하는 것이 권장된다. |
| mysql_create_db() | DB를 생성한다. 이 함수를 사용하기보다는 SQL 명령어인 |
| | CREATE DATABASE 문을 사용하는 것이 좋다. |
-------------------------------------------------------------------------------------------------
| mysql_data_seek() | 질의 결과 셋에서 임의의 행을 찾는다. |
-------------------------------------------------------------------------------------------------
| mysql_debug() | 주어진 문자열로 DBUG_PUSH를 수행한다. |
-------------------------------------------------------------------------------------------------
| mysql_drop_db() | DB를 드롭한다. 이 함수를 사용하기보다는 SQL 명령어인 DROP |
| | DATABASE 문을 사용하는 것이 좋다. |
-------------------------------------------------------------------------------------------------
| mysql_dump_debug_info() | 서버로 하여금 디버깅 정보를 로그에 남기도록 한다. |
-------------------------------------------------------------------------------------------------
| mysql_eof() | 결과셋의 마지막 행이 읽혀졌는가를 표시한다. 이 함수를 |
| | 사용하기보다는 mysql_errno()나 mysql_error()함수가 사용된다. |
-------------------------------------------------------------------------------------------------
| mysql_errno() | 가장 최근에 수행된 MySQL 함수에 대한 에러넘버를 리턴한다. |
-------------------------------------------------------------------------------------------------
| mysql_error() | 가장 최근에 수행된 MySQL 함수에 대한 에러메세지를 리턴한다. |
-------------------------------------------------------------------------------------------------
| mysql_escape_string() | SQL 문 내부의 특수 문자를 처리한다. |
-------------------------------------------------------------------------------------------------
| mysql_fetch_field() | 테이블의 다음 필드의 형식(type)을 리턴한다. |
-------------------------------------------------------------------------------------------------
| mysql_fetch_field_direct() | 주어진 필드 번호에 대한 필드 형식을 리턴한다. |
-------------------------------------------------------------------------------------------------
| mysql_fetch_fields() | 모든 필드 구조에 대한 배열을 리턴한다. |
-------------------------------------------------------------------------------------------------
| mysql_fetch_lengths() | 현재 행의 모든 컬럼들의 길이를 리턴한다. |
-------------------------------------------------------------------------------------------------
| mysql_fetch_row() | 결과셋으로부터 다음 행을 가져온다. |
-------------------------------------------------------------------------------------------------
| mysql_field_seek() | 컬럼커서를 특정 컬럼으로 놓는다. |
-------------------------------------------------------------------------------------------------
| mysql_free_result() | 결과셋에 의해 사용된 메모리를 해제한다. |
-------------------------------------------------------------------------------------------------
| mysql_get_client_info() | 클라이언트의 버전 정보를 리턴한다. |
-------------------------------------------------------------------------------------------------
| mysql_get_host_info() | 현재 연결에 대한 정보를 가진 문자열을 리턴한다. |
-------------------------------------------------------------------------------------------------
| mysql_get_proto_info() | 연결에 사용된 프로토콜 버전을 리턴한다. |
-------------------------------------------------------------------------------------------------
| mysql_get_server_info() | 서버의 버전 넘버를 리턴한다. |
-------------------------------------------------------------------------------------------------
| mysql_info() | 가장 최근에 수행된 질의에 대한 정보를 리턴한다. |
-------------------------------------------------------------------------------------------------
| mysql_init() | MYSQL 구조체를 생성하거나 초기화한다. |
-------------------------------------------------------------------------------------------------
| mysql_insert_id() | AUTO_INCREMENT 필드에 대하여 가장 최근에 생성된 ID를 리턴. |
-------------------------------------------------------------------------------------------------
| mysql_list_dbs() | 간단한 정규식에 의해 매칭되는 DB 이름들을 리턴한다. |
-------------------------------------------------------------------------------------------------
| mysql_list_fields() | 간단한 정규식에 의해 매칭되는 필드 이름들을 리턴한다. |
-------------------------------------------------------------------------------------------------
| mysql_list_processes() | 현재 서버의 쓰레드들의 리스트를 리턴한다. |
-------------------------------------------------------------------------------------------------
| mysql_list_tables() | 간단한 정규식에 의해 매칭되는 테이블 이름들을 리턴한다. |
-------------------------------------------------------------------------------------------------
| mysql_num_fields() | 결과셋 내의 컬럼 개수를 리턴한다. |
-------------------------------------------------------------------------------------------------
| mysql_num_rows() | 결과셋 내의 행 개수를 리턴한다. |
-------------------------------------------------------------------------------------------------
| mysql_ping() | 서버와의 연결이 제대로 수행되고 있나를 체크하며, 필요하면 |
| | 서버와 재연결한다. |
-------------------------------------------------------------------------------------------------
| mysql_query() | Null terminated 문자열로 주어지는 SQL 질의를 수행한다. |
-------------------------------------------------------------------------------------------------
| mysql_real_connect() | MySQL 서버와 연결한다. |
-------------------------------------------------------------------------------------------------
| mysql_real_query() | Counted 문자열로 주어진 SQL 질의를 수행한다. |
-------------------------------------------------------------------------------------------------
| mysql_reload() | 서버로 하여금 grant 테이블을 다시 리로드하게 한다. |
-------------------------------------------------------------------------------------------------
| mysql_row_seek() | mysql_row_tell() 함수가 리턴한 값을 가지고 결과셋 내의 한 |
| | 행을 찾는다. |
-------------------------------------------------------------------------------------------------
| mysql_row_tell() | Row cursor 위치를 리턴한다. |
-------------------------------------------------------------------------------------------------
| mysql_select_db() | 특정 DB에 연결한다. |
-------------------------------------------------------------------------------------------------
| mysql_shutdown() | DB 서버를 셧다운시킨다. |
-------------------------------------------------------------------------------------------------
| mysql_stat() | 서버의 상태를 표시하는 문자열을 리턴한다. |
-------------------------------------------------------------------------------------------------
| mysql_store_result() | 전체 결과셋을 클라이언트로 가져온다. |
-------------------------------------------------------------------------------------------------
| mysql_thread_id() | 현재 쓰레드의 ID를 리턴한다. |
-------------------------------------------------------------------------------------------------
| mysql_use_result() | 행단위로 데이터를 넘겨받기 위한 결과 셋을 초기화한다. |
-------------------------------------------------------------------------------------------------
서버에 연결할 때는 먼저 mysql_init() 함수를 호출함으로써 connection handler를 초기화한 후,
그 handler와 hostname, user name, password와 같은 다른 정보들을 가지고 mysql_real_connect()
함수를 호출한다. 모든 작업이 끝나면 mysql_close() 함수를 호출함으로써 연결을 종료한다.
연결이 이루어져 있는 동안 클라이언트는 mysql_query()나 mysql_real_query() 함수를 이용하
여 서버에 SQL 질의를 보낼 수 있다. mysql_query()는 질의가 null-terminated string이어야 하
며, mysql_real_query()는 counted string이어야 한다. 만약 string이 바이너리 데이터(중간에
NULL 바이트를 가질 수도 있는)인 경우에는 반드시 mysql_real_query()를 사용하여야 한다.
SELECT 질의가 아닌 질의(INSERT, UPDATE, DELETE)에 대해서는 mysql_affected_row() 함수
를 호출함으로써 얼마나 많은 행이 affect되어졌나를 알 수 있다.
SELECT 질의의 경우, select되어진 행들을 결과셋(result set)으로 얻게 된다(SHOW, DESCRIBE,
EXPLAIN과 같은 문은 행을 리턴하는 것에 있어서 SELECT와 비슷하며, 이들은 SELECT
문과 동일하게 처리되어야 한다)
클라이언트가 결과셋을 처리하는 방법에는 두가지가 있다. 하나는 mysql_store_result() 함수
를 호출함으로써 전체 결과 셋을 한번에 얻어오는 것으로써, 이 함수는 질의에 의해 리턴된
모든 행들을 서버로부터 얻어내어 클라이언트에 저장한다. 두번째는 mysql_use_result() 함수
를 호출함으로써 클라이언트가 행별로 결과셋을 얻어오는 것이다. 이 함수는 행을 얻어오기 위한
작업을 초기화하기만 하며 실제로 서버로부터 행을 가져오지는 않는다.
위 두가지 경우 모두, mysql_fetch_row() 함수를 호출함으로써 행들에 접근하게 된다.
mysql_store_result()의 경우 mysql_fetch_row()는 서버로부터 이미 fetch된 행들에 접근하며,
mysql_use_result()의 경우, mysql_fetch_row()는 실제로 서버로부터 행들을 얻어온다. 각 행의
데이터 값의 크기에 대한 정보는 mysql_fetch_lengths() 함수를 호출함으로써 얻을 수 있다.
결과 셋을 이용한 작업이 끝나면 mysql_free_result()를 호출함으로써 결과 셋을 위해 사용된
메모리를 해제한다.
이 두가지 retrieval 체계는 상호 보완적이다. 클라이언트 프로그램은 각각의 요구에 따라 적
절한 접근 방법을 선택하여야 한다. 실질적으로는 mysql_store_result()가 주로 사용된다.
mysql_store_result()의 이점은 행들이 클라이언트로 fetch된 이후에는 클라이언트가 행들에
순차적으로 접근할 수 있을 뿐만 아니라 mysql_data_seek()나 mysql_row_seek()를 이용하여 결
과 셋 안에서 현행 위치(current row position)를 변경함으로써 결과 셋 내에서 앞뒤로 움직일
수 있다는 것이다. 또한 mysql_num_rows()를 호출함으로써 얼마나 많은 행들이 있나를 알
수도 있다. 다른 한편으로, mysql_store_result()를 위해 요구되는 메모리가 많기 때문에 out-of-
memory 상태를 만날 가능성이 많다.
mysql_use_result()의 이점은 한번에 하나의 행만을 관리하기 때문에 결과 셋을 위한 메모리
가 적게 필요하다는 것이며 또한 더 적은 메모리 할당 부하로 인하여 더 속도가 빠를 수 있
다. 단점은 서버를 tying up하는 것을 피하기 위하여 각 행을 빠르게 처리해주어야 하며 결
과 셋 내에서 랜덤하게 행들에 접근할 수 없고 단지 순차적으로만 접근할 수 있다. 또한 모
든 행들을 받기 전에는 결과 셋 내에 얼마나 많은 행들이 있나를 알 수가 없다. 결과 셋 중
간에 찾고자 하는 정보를 찾았더라도 모든 행을 끝까지 받고 있어야 한다.
API를 이용함으로써 질의가 SELECT인가 아닌가를 모른 상태에서도 클라이언트가 질의에
적절히 대응할 수 있게 할 수 있는데, 이는 mysql_query() (혹은 mysql_real_query())를 호출한
후에 mysql_store_result()를 호출함으로써 가능하다. 만약 결과 셋이 성공(succeed)이면 질의가
SELECT이며 행들을 읽을 수 있다. 만약 실패이면 mysql_num_fields()를 호출하여 result가
정말로 기대되어지는가를 결정할 수 있으며, mysql_num_fields()가 0을 리턴하면 질의는 아무
데이터도 리턴하지 않는다(이것은 질의가 INSERT, UPDATE, DELETE 등임을 의미한다). 만약
mysql_num_fields()가 0이 아니면 질의는 반드시 행을 리턴하여야 하는데 리턴하지 않았음을
의미하며, 이는 질의가 SELECT였으며 수행에 실패하였음을 알려준다.
mysql_store_result()과 mysql_use_result()은 결과 셋을 구성하는 필드들에 대한 정보(필드의 개
수, 이름, 형식 등)를 얻을 수 있게 해준다. mysql_fetch_field()를 각각 호출하여 행 내에서의
필드 정보를 순차적으로 접근하거나, mysql_fetch_field_direct()를 호출함으로써 얻은 행 내의
필드 번호를 통하여 접근할 수 있다. 현쟁의 필드 커서 위치(current field cursor position)는
mysql_field_seek() 함수를 호출함으로써 변경될 수 있다. Setting the field cursor affects subsequent
calls to mysql_fetch_field(). 또한 mysql_fetch_fields()를 호출함으로써 한꺼번에 모든 필드 정보
를 얻을 수도 있다.
에러를 찾고 리포팅하기 위해서 MySQL은 mysql_errno()와 mysql_error() 함수를 통하여 에러
정보에 접근할 수 있게 해준다. 이 두 함수는 가장 최근에 invoke된 성공하거나 실패할 수
있는 함수에 대한 에러 코드 혹은 에러 메시지를 리턴하며, 이를 통하여 언제 에러가 발생
하고 그것이 무엇인가를 알 수 있다.
18.4 C API function descriptions
아래의 함수 설명에 있어서 NULL로 표시한 인수나 리턴값은 C 프로그래밍 언어에서의
NULL의 의미이며, MySQL에서의 NULL 값을 의미하는 것이 아니다.
어떤 값을 리턴하는 함수들은 보통 포인터나 정수를 리턴한다. 만약 별 다른 표시가 없다면
포인터를 리턴하는 함수들은 성공하였을 때 NULL이 아닌 값을, 에러를 표시하기 위해서는
NULL 값을 리턴한다. 정수를 리턴하는 함수의 경우에는 성공하였을 경우 0을, 에러인 경우
에는 0이 아닌 값을 리턴한다.
함수가 에러를 리턴한 경우에는 mysql_errno(), mysql_error() 함수를 이용하여 에러를 체크할
수 있다.
18.4.1 mysql_affected_rows()
my_ulonglong mysql_affected_rows(MYSQL *mysql)
18.4.1.1 Description
마지막으로 수행된 UPDATE, DELETE, INSERT 질의에 의한 행의 수를 리턴하며, 주로
UPDATE, DELETE, INSERT 문에 대한 mysql_query() 함수가 호출된 후 즉시 호출된다.
SELECT 문의 경우 mysql_affected_rows() 함수는 mysql_num_row() 함수처럼 동작한다.
mysql_affected_rows() 함수는 현재 매크로(macro)로 구현되어 있다.
18.4.1.2 Return values
0보다 큰 정수는 affected되거나 retrieved된 행의 수를 의미한다. 0은 WHERE 조건에 합당
하는 레코드가 없거나 아무 질의도 아직 수행되지 않았음을 의미한다. -1은 질의가 에러를
리턴하였거나 혹은 SELECT 질의인 경우 mysql_affected_rows() 함수가 mysql_store_result() 함
수의 호출 이전에 호출되었음을 의미한다.
18.4.1.3 Errors
없음.
18.4.1.4 Example
mysql_query(&mysql,"UPDATE products SET cost=cost*1.25 WHERE group=10");
printf("%d products updated",mysql_affected_rows(&mysql));
18.4.2 mysql_close()
void mysql_close(MYSQL *mysql)
18.4.2.1 Description
현재 열려있는 서버와의 연결을 끊는다. 만약 연결 핸들(connection handle)이 mysql_init()이나
mysql_real_connect()에 의해서 자동으로 할당되었다면 mysql_close()는 mysql에 의해 지정된
연결 핸들을 deallocation한다.
18.4.2.2 Return values
없음.
18.4.2.3 Errors
CR_COMMANDS_OUT_OF_SYNC
Commands were executed in an improper order.
CR_SERVER_GONE_ERROR
The MySQL server has gone away.
CR_SERVER_LOST
The connection to the server was lost during the query.
CR_UNKNOWN_ERROR
An unknown error occurred.
18.4.3 mysql_connect()
MYSQL *mysql_connect(MYSQL *mysql, const char *host, const char *user, const char *passwd)
18.4.3.1 Description
이 함수를 사용하는 것은 권장되지 않으며, 대신 mysql_real_connect() 함수가 주로 사용된다.
mysql_connect() 함수는 호스트에서 돌아가고 있는 MySQL DB 엔진과의 연결을 시도한다.
Mysql_connect()는 mysql_get_client_info() 함수를 제외한 다른 모든 API 함수를 수행하기 이
전에 반드시 성공적으로 수행되어져야 한다.
함수의 인수들이 가지는 의미는 mysql_real_connect() 함수와 동일하다.
18.4.3.2 Return values
mysql_real_connect() 함수와 동일.
18.4.3.3 Errors
mysql_real_connect() 함수와 동일.
18.4.4 mysql_create_db()
int mysql_create_db(MYSQL *mysql, const char *db)
18.4.4.1 Description
'db' 인수로 주어진 이름의 데이터베이스를 생성한다.
이 함수를 사용하는 것은 권장되지 않으며, 대신 'CREATE DATABASE'와 같은 SQL 문을
mysql_query() 함수를 이용하여 수행하는 것이 좋다.
18.4.4.2 Return values
데이터베이스가 성공적으로 생성된 경우 0, 에러가 발생한 경우 0이 아닌 값을 리턴한다.
18.4.4.3 Errors
CR_COMMANDS_OUT_OF_SYNC
Commands were executed in an improper order.
CR_SERVER_GONE_ERROR
The MySQL server has gone away.
CR_SERVER_LOST
The connection to the server was lost during the query.
CR_UNKNOWN_ERROR
An unknown error occurred.
18.4.4.4 Example
if(mysql_create_db(&mysql, "my_database"))
{
fprintf(stderr, "Failed to create new database. Error: %s\n", mysql_error(&mysql));
}
18.4.5 mysql_data_seek()
void mysql_data_seek(MYSQL_RES *result, unsigned int offset)
18.4.5.1 Description
결과 셋 내에서 임의의 행을 찾는다. 이를 위해서는 결과 셋 구조체가 질의에 의한 전체 결
과를 포함하고 있어야 하며, 따라서 mysql_data_seek() 함수는 mysql_use_result() 함수와는 사
용할 수 없고 mysql_store_result() 함수와 사용한다.
Offset 인수는 0에서 mysql_num_rows(result)-1 사이의 값을 가져야 한다.
18.4.5.2 Return values
None.
18.4.5.3 Errors
None.
18.4.6 mysql_debug()
void mysql_debug(char *debug)
18.4.6.1 Description
debug 인수로 주어진 문자열을 가지고 DBUG_PUSH를 수행한다. mysql_debug() 함수는 Fred
Fish debug 라이브러리를 사용한다. 이 함수를 사용하기 위해서는 반드시 클라이언트 라이브
러리를 디버깅을 지원하도록 컴파일하여야 한다. 19.10 절에서 MySQL 서버의 디버깅에 대하
여 논의하며, 19.11절에서 MySQL 클라이언트의 디버깅에 대하여 논의한다.
18.4.6.2 Return values
None.
18.4.6.3 Errors
None.
18.4.6.4 Example
아래와 같은 호출은 클라이언트 라이브러리로 하여금 클라이언트의에 '/tmp/client.trace' 파일
에 trace file을 생성하게 해준다:
mysql_debug("d:t:O,/tmp/client.trace");
18.4.7 mysql_drop_db()
int mysql_drop_db(MYSQL *mysql, const char *db)
18.4.7.1 Description
db 인수로 주어진 이름의 데이터베이스를 드롭시킨다.
이 함수를 사용하는 것은 권장되지 않으며, 대신 'DROP DATABASE'와 같은 SQL 문을
mysql_query() 함수를 이용하여 수행하는 것이 좋다.
18.4.7.2 Return values
데이터베이스가 성공적으로 드롭된 경우 0을, 에러가 발생한 경우 0이 아닌 값을 리턴한다.
18.4.7.3 Errors
CR_COMMANDS_OUT_OF_SYNC
Commands were executed in an improper order.
CR_SERVER_GONE_ERROR
The MySQL server has gone away.
CR_SERVER_LOST
The connection to the server was lost during the query.
CR_UNKNOWN_ERROR
An unknown error occurred.
18.4.7.4 Example
if(mysql_drop_db(&mysql, "my_database"))
fprintf(stderr, "Failed to drop the database: Error: %s\n", mysql_error(&mysql));
18.4.8 mysql_dump_debug_info()
int mysql_dump_debug_info(MYSQL *mysql)
18.4.8.1 Description
서버로 하여금 로그에 디버깅 정보를 기록하게 한다. 연결되어 있는 사용자(connected user)는
이 작업을 위한 권한을 가지고 있어야 한다.
18.4.8.2 Return values
명령이 성공하면 0, 에러가 발생하면 0이 아닌 값을 리턴한다.
18.4.8.3 Errors
CR_COMMANDS_OUT_OF_SYNC
Commands were executed in an improper order.
CR_SERVER_GONE_ERROR
The MySQL server has gone away.
CR_SERVER_LOST
The connection to the server was lost during the query.
CR_UNKNOWN_ERROR
An unknown error occurred.
18.4.9 mysql_eof()
my_bool mysql_eof(MYSQL_RES *result)
18.4.9.1 Description
이 함수를 사용하는 것은 권장되지 않으며, 대신 mysql_errno() 함수나 mysql_error() 함수를
사용한다.
mysql_eof() 함수는 결과 셋의 마지막 행이 읽혀졌나를 판단한다.
mysql_store_result() 함수로부터 성공적으로 결과 셋을 얻었다면 클라이언트는 한번의 작업으
로 전체 셋을 얻게된다. 이 경우 mysql_fetch_row() 함수로부터 리턴되는 NULL은 항상 결과
셋의 마지막에 도달하였음을 의미하게 되며 mysql_eof() 함수를 호출할 필요가 없다.
한편으로 mysql_use_result() 함수를 사용하여 결과 셋을 얻었다면 셋의 행들은
mysql_fetch_row() 함수를 호출할 때마다 서버로부터 하나씩 얻어진다. 이 과정 중에 연결 에
러가 발생할 수 있기 때문에 myql_fetch_row() 함수가 리턴하는 NULL 값은 반드시 결과 셋
의 마지막에 도달하였음을 의미한다고 볼 수 없다. 이 경우 mysql_eof() 함수를 사용하여 무
엇이 일어났나를 결정할 수 있다. 이때 mysql_eof() 함수는 결과 셋의 마지막에 도달한 경우
라면 0이 아닌 값을 리턴하며, 에러인 경우에는 0을 리턴하게 된다.
표준 mySQL 에러 함수인 mysql_errno()와 mysql_error() 함수가 더 많은 정보를 제공하기 때
문에 이들을 사용하는 것이 좋다…
18.4.9.2 Return values
에러이면 0을, 결과 셋의 마지막에 도달하였으면 0이 아닌 값을 리턴한다.
18.4.9.3 Errors
None.
18.4.9.4 Example
다음은 mysql_eof()의 사용예를 보여준다:
mysql_query(&mysql,"SELECT * FROM some_table");
result = mysql_use_result(&mysql);
while((row = mysql_fetch_row(result)))
{
// do something with data
}
if(!mysql_eof(result)) // mysql_fetch_row() failed due to an error
{
fprintf(stderr, "Error: %s\n", mysql_error(&mysql));
}
However, you can achieve the same effect with the standard MySQL error functions:
mysql_query(&mysql,"SELECT * FROM some_table");
result = mysql_use_result(&mysql);
while((row = mysql_fetch_row(result)))
{
// do something with data
}
if(mysql_errno(&mysql)) // mysql_fetch_row() failed due to an error
{
fprintf(stderr, "Error: %s\n", mysql_error(&mysql));
}
18.4.10 mysql_errno()
unsigned int mysql_errno(MYSQL *mysql)
18.4.10.1 Description
mysql 인수에 의해 지정된 연결에 대하여 mysql_errno()는 가장 최근에 수행된 API 함수에
대한 에러 코드를 리턴한다. 0을 리턴하면 아무 에러도 발생하지 않음을 의미한다. 클라이언
트 에러 메시지 넘버들은 MYSQL의 'errmsg.h' 헤더 파일에 나열되어 있으며, 서버 에러 메
시지 넘버들은 'mysqld_error.h' 파일에 있다.
18.4.10.2 Return values:
에러 코드 값을 리턴. 아무 에러도 없으면 0을 리턴한다.
18.4.10.3 Errors
None.
18.4.11 mysql_error()
char *mysql_error(MYSQL *mysql)
18.4.11.1 Description
mysql 인수에 의해 지정된 연결에 대하여 mysql_error()는 가장 최근에 수행된 API 함수에
대한 에러 메시지를 리턴한다. 비어 있는 문자열("")을 리턴하면 아무 에러도 발생하지 않음
을 의미한다. 이것은 다음의 두가지 테스트가 동일함을 의미한다:
if(mysql_errno(&mysql)) {
// an error occurred
}
if(mysql_error(&mysql)[0] != '\0') {
// an error occurred
}
클라이언트 에러 메시지의 언어는 MySQL 클라이언트 라이브러리를 재컴파일함으로써 변경
될 수 있다. 현재 몇가지 다른 언어로 된 에러 메시지를 선택할 수 있으며, 9.1 절에서는
MySQL에 의해 지원되는 언어들을 다룬다.
18.4.11.2 Return values
에러를 기술하는 문자열. 에러가 없는 경우에는 비어있는 문자열을 리턴한다.
18.4.11.3 Errors
None.
18.4.12 mysql_escape_string()
unsigned int mysql_escape_string(char *to, const char *from, unsigned int length)
18.4.12.1 Description
from 인수에 있는 문자열을 서버로 넘겨질 escaped SQL 문으로 인코딩하여 to 인수에 넣는다.
인코딩되어지는 문자들은 NUL(ASCII 0), `\n', `\r', `\', `'' 등이다(7.1절에서는 문자열과 숫자들을
사용하는 방법에 대하여 다룬다).
from 인수인 문자열은 length 인수에서 주어진 바이트 수만큼의 길이(terminating NULL을 제
외한)를 가져야 한다. to 인수는 반드시 적어도 length 인수에서 주어진 길이의 2배에 1을
더한 만큼의 바이트가 할당되어야 한다. mysql_escape_string() 함수가 리턴할 때 to 인수의 내
용은 null-terminated 문자열이 된다. 리턴값은 인코딩되어진 문자열의 길이이며, 이것은
terminating null 문자가 포함되지 않은 길이다.
to 인수에 들어가는 문자열은 null-terminated 문자열이지만 이 문자열을 strlen() 함수나
strcpy() 함수에서 사용하여서는 안된다. 만약 from 인수로 주어진 문자열이 null을 포함하고
있다면 mysql_escape_string() 함수는 이 문자를 '\'을 앞에 붙여서 to 인수에 넣게 되며, 이것
을 위의 함수들은 여전히 terminating null로 인식하게 된다.
또한 이러한 내부적인 null 바이트는 mysql_query()에 의해서 terminating null로 여겨지기 때
문에 질의를 적절하게 수행할 수 없게 된다. 따라서 mysql_escape_query() 함수를 이용하여
질의를 만든 경우 mysql_query() 함수를 사용하기 보다는 mysql_real_query() 함수를 사용하는
것이 좋다.
18.4.12.2 Example
char query[1000],*end;
end = strmov(query, "INSERT INTO test_table values(");
*end++ = '\";
end += mysql_escape_string(query,"What's this",11);
*end++ = '\";
*end++ = ',';
*end++ = '\";
end += mysql_escape_string(query,"binary data: \0\r\n",16);
*end++ = '\";
*end++ = ')';
if (mysql_real_query(&mysql,query,(int) (end - query))) {
fprintf(stderr, "Failed to insert row, Error: %s\n",
mysql_error(&mysql));
}
예제에서 사용된 strmov() 함수는 mysqlclient 라이브러리에 포함되어 있으며, strcpy() 함수와
비슷하게 동작을 하지만 첫번째 인수의 terminating null에 대한 포인터를 리턴하는 것이 다
르다.
18.4.12.3 Return values
terminating null 문자를 제외한 to 인수에 들어간 값의 길이
18.4.12.4 Errors
None.
18.4.13 mysql_fetch_field()
MYSQL_FIELD *mysql_fetch_field(MYSQL_RES *result)
18.4.13.1 Description
결과 셋의 한 컬럼의 정의(definition)를 MYSQL_FIELD 구조체에 담아서 리턴한다. 결과 셋
의 모든 컬럼들에 대한 정보를 얻고자 하는 경우에는 이 함수를 반복하여 호출한다. 더 이
상의 필드가 남아있지 않으면 mysql_fetch_field() 함수는 NULL을 리턴한다.
새로운 SELECT 질의가 수행될 때마다 mysql_fetch_field()는 새로운 첫번째 필드에 대한 정
보를 리턴하기 위해 초기화된다. mysql_fetch_field() 함수에 의해 리턴되는 필드는 또한
mysql_field_seek() 함수의 호출에 의해 영향을 받는다.
SELECT 문을 수행하기 위해 msyql_query()를 호출하였지만 mysql_store_result()를 호출하지
않은 경우, mysql_fetch_field()를 호출하여 BLOB 필드의 길이를 요청하게 되면 MySQL은 디
폴트 blob 길이인 8K 바이트를 리턴한다. 일단 한번 결과를 얻어오게 되면 field->max_length
는 주어진 질의에 있는 컬럼의 가장 큰 값의 길이를 가지게 된다.
18.4.13.2 Return values
현재 컬럼에 대한 MYSQL_FIELD 구조체를 리턴하며, 더 이상 남은 필드가 없으면 NULL을
리턴한다.
18.4.13.3 Errors
None.
18.4.13.4 Example
MYSQL_FIELD *field;
while((field = mysql_fetch_field(result)))
{
printf("field name %s\n", field->name);
}
18.4.14 mysql_fetch_fields()
MYSQL_FIELD *mysql_fetch_fields(MYSQL_RES *result)
18.4.14.1 Description
결과 셋에 대한 모든 MYSQL_FIELD 구조체의 배열을 리턴한다. 각각의 구조체는 결과 셋
내의 각 컬럼들에 대한 필드 정의에 대한 정보를 가지고 있다.
18.4.14.2 Return values
결과 셋의 모든 컬럼들에 대한 MYSQL_FIELD 구조체의 배열
18.4.14.3 Errors
None.
18.4.14.4 Example
unsigned int num_fields;
unsigned int i;
MYSQL_FIELD *fields;
num_fields = mysql_num_fields(result);
fields = mysql_fetch_fields(result);
for(i = 0; i < num_fields; i++) {
printf("Field %u is %s\n", i, fields[i].name);
}
18.4.15 mysql_fetch_field_direct()
MYSQL_FIELD *mysql_fetch_field_direct(MYSQL_RES *result, unsigned int fieldnr)
18.4.15.1 Description
결과 셋 내에서 fieldnr 인수로 주어진 필드 번호의 필드에 대한 필드 정의를 MYSQL_FIELD
구조체로 리턴한다. 이 함수를 이용하여 임의의 컬럼에 대한 정의를 얻어올 수 있다. fieldnr
값은 0에서 mysql_num_fields(result)-1 사이의 값을 가져야 한다.
18.4.15.2 Return values
지정된 필드에 대한 MYSQL_FIELD 구조체
18.4.15.3 Errors
None.
18.4.15.4 Example
unsigned int num_fields;
unsigned int i;
MYSQL_FIELD *field;
num_fields = mysql_num_fields(result);
for(i = 0; i < num_fields; i++) {
field = mysql_fetch_field_direct(result, i);
printf("Field %u is %s\n", i, field->name);
}
18.4.16 mysql_fetch_lengths()
unsigned long *mysql_fetch_lengths(MYSQL_RES *result)
18.4.16.1 Description
결과 셋 내의 현재 행의 컬럼들의 길이를 리턴한다. 만약 필드 값들을 복사하고자 하는 경
우 이 길이 정보는 최적화(optimization)을 위해 유용하게 사용할 수 있다. strlen() 함수를 호
출할 필요가 없기 때문이다. 특히 결과 셋이 이진 데이터를 포함하고 있는 경우에는 strlen()
함수가 NULL 문자를 포함하고 있는 필드에 대하여 잘못된 결과를 리턴할 수 있기 때문에
데이터의 크기를 결정하는데 이 함수를 사용하여야 한다.
빈 컬럼이나 NULL 값을 가지는 컬럼에 대한 길이는 0이 된다. 이 두가지 경우를 구분하는
방법은 mysql_fetch_row() 함수에 대한 설명을 참조한다.
18.4.16.2 Return values
각 컬럼(null termination character를 제외한)의 크기를 가지고 있는 unsigned long 정수형의 배
열. 에러가 발생한 경우에는 NULL을 리턴한다.
18.4.16.3 Errors
mysql_fetch_lengths()는 결과 셋의 현재 행에 대해서만 유효하다. mysql_fetch_row() 함수를 호
출하기 전에 이 함수를 호출하거나 결과 셋 내의 모든 행들을 얻어온 후에 호출하는 경우에
NULL을 리턴한다.
18.4.16.4 Example
MYSQL_ROW row;
unsigned long *lengths;
unsigned int num_fields;
unsigned int i;
row = mysql_fetch_row(result);
if (row) {
num_fields = mysql_num_fields(result);
lengths = mysql_fetch_lengths(result);
for(i = 0; i < num_fields; i++) {
printf("Column %u is %lu bytes in length.\n", i, lengths[i]);
}
}
18.4.17 mysql_fetch_row()
MYSQL_ROW mysql_fetch_row(MYSQL_RES *result)
18.4.17.1 Description
결과 셋의 다음 행을 얻어온다. mysql_store_result() 함수를 호출한 후에 사용한 경우, 더 이
상 얻어올 행들이 없으면 mysql_fetch_row()는 NULL을 리턴한다. mysql_use_result() 함수를
호출한 후에 사용한 경우, 더 이상 얻어올 행들이 없거나 에러가 발생하였을 때 NULL을
리턴한다.
행 내부의 값들의 개수는 mysql_num_fields(result)에 의해 주어진다. mysql_fetch_row()의 호출
에 의하여 행이 얻어졌을 때 행 내부의 값들은 row[0]부터 row[mysql_num_fields(result)-1]까
지의 값들로 참조될 수 있다. 행 내부에 NULL 값이 있는 경우에는 NULL 포인터로 표시된다.
행 내부의 필드 값들의 길이들은 mysql_fetch_lengths() 함수를 호출함으로써 얻어질 수 잇다.
비어있는 필드나 NULL을 포함하는 필드들은 모두 0의 길이를 가지며, 필드 값에 대한 포
인터를 체크함으로써 이 두가지 경우를 구분할 수 있다. 만약 포인터가 NULL이면 해당 필
드가 NULL인 경우이며, 아니면 비어있는 필드임을 의미한다.
18.4.17.2 Return values
다음 행에 대한 MYSQL_ROW 구조체. 더 이상 얻어올 행이 없거나 에러가 발생한 경우
NULL을 리턴한다.
18.4.17.3 Errors
CR_SERVER_LOST
The connection to the server was lost during the query.
CR_UNKNOWN_ERROR
An unknown error occurred.
18.4.17.4 Example
MYSQL_ROW row;
unsigned int num_fields;
unsigned int i;
num_fields = mysql_num_fields(result);
while ((row = mysql_fetch_row(result))) {
unsigned long *lengths;
lengths = mysql_fetch_lengths(result);
for(i = 0; i < num_fields; i++) {
printf("[%.*s] ", (int) lengths[i], row[i] ? row[i] : "NULL");
}
printf("\n");
}
18.4.18 mysql_field_seek()
MYSQL_FIELD_OFFSET mysql_field_seek(MYSQL_RES *result, MYSQL_FIELD_OFFSET offset)
18.4.18.1 Description
필드 커서를 offset 인수로 주어진 위치로 설정한다. 다음 mysql_fetch_field() 함수의 호출은
해당 offset로 이동한 만큼에 해당되는 컬럼에 대한 필드 정보를 얻어오게 된다.
행의 첫부분으로 보내기 위해서는 offset을 0으로 주고 함수를 호출하면 된다.
18.4.18.2 Return values
필드 커서의 이전 값(previous value)
18.4.18.3 Errors
None.
18.4.19 mysql_field_tell()
MYSQL_FIELD_OFFSET mysql_field_tell(MYSQL_RES *result)
18.4.19.1 Description
마지막 mysql_fetch_field() 함수에 의해 사용된 필드 커서의 위치를 알려준다. 이 리턴값을
mysql_field_seek() 함수의 offset 인수로 사용할 수 있다.
18.4.19.2 Return values
필드 커서의 현재 변위(current offset)
18.4.19.3 Errors
None.
18.4.20 mysql_free_result()
void mysql_free_result(MYSQL_RES *result)
18.4.20.1 Description
mysql_store_result(), mysql_use_result(), mysql_list_dbs() 등에 의한 결과셋을 위해 할당되었던
메모리를 해제한다. 결과 셋을 가지고 작업을 끝내고 나면 반드시 mysql_free_result() 함수를
호출하여 메모리를 해제해 주어야 한다.
18.4.20.2 Return values
None.
18.4.20.3 Errors
None.
18.4.21 mysql_get_client_info()
char *mysql_get_client_info(void)
18.4.21.1 Description
클라이언트 라이브러리 버전(client library version)에 대한 정보를 표시하는 문자열을 리턴한다.
18.4.21.2 Return values
MySQL client library version을 표시하는 문자열
18.4.21.3 Errors
None.
18.4.22 mysql_get_host_info()
char *mysql_get_host_info(MYSQL *mysql)
18.4.22.1 Description
서버 호스트 네임을 포함하는 현재 사용되고 있는 연결(connection)의 형식(type)을 기술하는
문자열을 리턴한다.
18.4.22.2 Return values
서버 호스트 네임(server host name)과 연결 형식(connection type)을 나타내는 문자열
18.4.22.3 Errors
None.
18.4.23 mysql_get_proto_info()
unsigned int mysql_get_proto_info(MYSQL *mysql)
18.4.23.1 Description
현재 연결에 사용되고 있는 프로토콜의 버전을 리턴한다.
18.4.23.2 Return values
현재 연결에 사용되고 있는 프로토콜 버전을 나타내는 unsigned integer
18.4.23.3 Errors
None.
18.4.24 mysql_get_server_info()
char *mysql_get_server_info(MYSQL *mysql)
18.4.24.1 Description
서버 버전 넘버(server version number)를 표시하는 문자열을 리턴한다.
18.4.24.2 Return values
서버 버전 넘버를 표시하는 문자열
18.4.24.3 Errors
None.
18.4.25 mysql_info()
char *mysql_info(MYSQL *mysql)
18.4.25.1 Description
가장 최근에 수행된 질읭 peogks 정보를 제공하는 문자열을 리턴한다. 문자열의 형식(format)
은 질의의 타입에 따라 달라지며, 아래와 같다. 문자열은 질의에 대한 적절한 값들을 포함하
게 된다.
INSERT INTO ... SELECT ...
String format: Records: 100 Duplicates: 0 Warnings: 0
INSERT INTO ... VALUES (...),(...),(...)...
String format: Records: 3 Duplicates: 0 Warnings: 0
LOAD DATA INFILE ...
String format: Records: 1 Deleted: 0 Skipped: 0 Warnings: 0
ALTER TABLE
String format: Records: 3 Duplicates: 0 Warnings: 0
18.4.25.2 Return values
가장 최근에 수행된 질의에 대한 부가적인 정보를 표현하는 문장열. 해당 질의에 대하여 아
무런 정보도 얻을 수 없는 경우 NULL을 리턴한다.
18.4.25.3 Errors
None.
18.4.26 mysql_init()
MYSQL *mysql_init(MYSQL *mysql)
18.4.26.1 Description
mysql_real_connect() 함수를 위한 MYSQL 객체를 할당(allocate)하거나 초기화(initialize)한다.
만약 mysql 인수가 NULL 포인터이면 mysql_init() 함수는 새로운 객체를 할당, 초기화하여
그 객체를 리턴한다. NULL 포인터가 아니면 객체는 초기화된 후 객체의 주소가 리턴된다.
만약 mysql_init() 함수가 새로운 객체를 할당하게 되면 그 객체는 연결을 닫기 위해
mysql_close() 함수가 호출될 때 해제되게 된다.
18.4.26.2 Return values
초기화된 MYSQL * handle. 새로운 객체를 할당하기 위한 메모리가 부족한 경우 NULL을 리
턴한다.
18.4.26.3 Errors
메모리가 부족한 경우 NULL이 리턴된다.
18.4.27 mysql_insert_id()
my_ulonglong mysql_insert_id(MYSQL *mysql)
18.4.27.1 Description
AUTO_INCREMENT 필드에 대하여 가장 최근에 생성된 ID를 리턴한다. 이 함수는
AUTO_INCREMENT 필드를 포함하는 테이블에 INSERT 질의를 수행한 이후에 사용된다.
18.4.27.2 Return values
가장 최근에 갱신된 AUTO_INCREMENT 필드의 값
18.4.27.3 Errors
None.
18.4.28 mysql_kill()
int mysql_kill(MYSQL *mysql, unsigned long pid)
18.4.28.1 Description
서버로 하여금 pid 인수로 주어진 쓰레드(thread)를 죽이도록(kill) 요청한다.
18.4.28.2 Return values
성공인 경우 0을, 에러가 발생한 경우 0이 아닌 값을 리턴한다.
18.4.28.3 Errors
CR_COMMANDS_OUT_OF_SYNC
Commands were executed in an improper order.
CR_SERVER_GONE_ERROR
The MySQL server has gone away.
CR_SERVER_LOST
The connection to the server was lost during the query.
CR_UNKNOWN_ERROR
An unknown error occurred.
18.4.29 mysql_list_dbs()
MYSQL_RES *mysql_list_dbs(MYSQL *mysql, const char *wild)
18.4.29.1 Description
wild 인수로 지정된 간단한 정규식(simple regular expression)에 매치되는 서버 상의 데이터베
이스 이름들을 포함하고 있는 결과 셋을 리턴한다. wild 인수는 '%', '_'와 같은 와일드카드 문
자를 포함할 수 있으며 모든 데이터베이스 이름을 얻고자 하는 경우 NULL을 지정할 수 있
다. mysql_list_dbs() 함수를 호출하는 것은 'SHOW databases [LIKE wild]'와 같은 질의를 수행하
는 것과 비슷하다.
반드시 mysql_free_result() 함수를 이용하여 결과 셋을 해제시켜 주어야 한다.
18.4.29.2 Return values
성공한 경우 MYSQL_RES 결과 셋을 리턴하며, 에러인 경우 NULL을 리턴한다.
18.4.29.3 Errors
CR_COMMANDS_OUT_OF_SYNC
Commands were executed in an improper order.
CR_OUT_OF_MEMORY
Out of memory.
CR_SERVER_GONE_ERROR
The MySQL server has gone away.
CR_SERVER_LOST
The connection to the server was lost during the query.
CR_UNKNOWN_ERROR
An unknown error occurred.
18.4.30 mysql_list_fields()
MYSQL_RES *mysql_list_fields(MYSQL *mysql, const char *table, const char *wild)
18.4.30.1 Description
wild 인수로 지정된 간단한 정규식(simple regular expression)에 매치되는 테이블 상의 필드명
들을 포함하고 있는 결과 셋을 리턴한다. wild 인수는 '%', '_'와 같은 와일드카드 문자를 포함
할 수 있으며 모든 필드명을 얻고자 하는 경우 NULL을 지정할 수 있다. mysql_list_fields()
함수를 호출하는 것은 'SHOW fields FROM table [LIKE wild]'와 같은 질의를 수행하는 것과 비
슷하다.
반드시 mysql_free_result() 함수를 이용하여 결과 셋을 해제시켜 주어야 한다.
18.4.30.2 Return values
성공한 경우 MYSQL_RES 결과 셋을 리턴하며, 에러인 경우 NULL을 리턴한다.
18.4.30.3 Errors
CR_COMMANDS_OUT_OF_SYNC
Commands were executed in an improper order.
CR_SERVER_GONE_ERROR
The MySQL server has gone away.
CR_SERVER_LOST
The connection to the server was lost during the query.
CR_UNKNOWN_ERROR
An unknown error occurred.
18.4.31 mysql_list_processes()
MYSQL_RES *mysql_list_processes(MYSQL *mysql)
18.4.31.1 Description
현재의 서버 쓰레드들을 기술하는 결과 셋을 리턴한다. 이것은 'mysqladmin processlist'에 의
한 결과와 동일한 정보를 보여준다.
반드시 mysql_free_result() 함수를 이용하여 결과 셋을 해제시켜 주어야 한다.
18.4.31.2 Return values
성공한 경우 MYSQL_RES 결과 셋을 리턴하며, 에러인 경우 NULL을 리턴한다.
18.4.31.3 Errors
CR_COMMANDS_OUT_OF_SYNC
Commands were executed in an improper order.
CR_SERVER_GONE_ERROR
The MySQL server has gone away.
CR_SERVER_LOST
The connection to the server was lost during the query.
CR_UNKNOWN_ERROR
An unknown error occurred.
18.4.32 mysql_list_tables()
MYSQL_RES *mysql_list_tables(MYSQL *mysql, const char *wild)
18.4.32.1 Description
wild 인수로 지정된 간단한 정규식(simple regular expression)에 매치되는 현재 데이터베이스
상의 테이블명들을 포함하고 있는 결과 셋을 리턴한다. wild 인수는 '%', '_'와 같은 와일드카
드 문자를 포함할 수 있으며 모든 테이블명을 얻고자 하는 경우 NULL을 지정할 수 있다.
mysql_list_tables() 함수를 호출하는 것은 'SHOW tables [LIKE wild]'와 같은 질의를 수행하는
것과 비슷하다.
반드시 mysql_free_result() 함수를 이용하여 결과 셋을 해제시켜 주어야 한다.
18.4.32.2 Return values
성공한 경우 MYSQL_RES 결과 셋을 리턴하며, 에러인 경우 NULL을 리턴한다.
18.4.32.3 Errors
CR_COMMANDS_OUT_OF_SYNC
Commands were executed in an improper order.
CR_SERVER_GONE_ERROR
The MySQL server has gone away.
CR_SERVER_LOST
The connection to the server was lost during the query.
CR_UNKNOWN_ERROR
An unknown error occurred.
18.4.33 mysql_num_fields()
unsigned int mysql_num_fields(MYSQL_RES *result)
혹은,
unsigned int mysql_num_fields(MYSQL *mysql)
18.4.33.1 Description
결과 셋 내의 컬럼의 개수를 리턴한다.
mysql_num_fields()를 호출할 때 결과 셋에 대한 포인터 혹은 연결 핸들을 가지고 호출할 수
있다. 만약 mysql_store_result() 함수가 NULL을 리턴한 경우(즉 결과 셋 포인터를 얻어올 수
없을 때) 연결 핸들을 사용하게 되며, 이 경우 mysql_num_fields() 함수를 호출함으로써
mysql_store_result() 함수가 비어있지 않은 결과(non-empty result)를 생성하였나의 여부를 결정
할 수 있다. 이것은 클라이언트 프로그램으로 하여금 질의가 SELECT (혹은 SELECT-like) 문
인가 아닌가를 알지 못하는 상태에서 적절한 행동을 취할 수 있도록 해준다. 아래에 예가
있다.
18.4.33.2 Return values
결과 셋 내의 필드 개수를 표시하는 unsigned integer.
18.4.33.3 Errors
None.
18.4.33.4 Example
MYSQL_RES *result;
unsigned int num_fields;
unsigned int num_rows;
if (mysql_query(&mysql,query_string)) {
// error
}
else { // query succeeded, process any data returned by it
result = mysql_store_result(&mysql);
if (result) { // there are rows
num_fields = mysql_num_fields(result);
// retrieve rows, then call mysql_free_result(result)
}
else { // mysql_store_result() returned nothing; should it have?
if(mysql_num_fields(&mysql) == 0) {
// query does not return data
// (it was not a SELECT)
num_rows = mysql_affected_rows(&mysql);
}
else { // mysql_store_result() should have returned data
fprintf(stderr, "Error: %s\n", mysql_error(&mysql));
}
}
}
또 다른 대안은 mysql_num_fields(&mysql) 대신에 mysql_errno(&mysql)을 호출하는 것이다.
이 경우, 질의가 SELECT 문인가를 msyql_num_fields()의 리턴값으로 결정하기보다는
mysql_store_result()로부터의 에러를 직접 체크하게 된다.
18.4.34 mysql_num_rows()
my_ulonglong mysql_num_rows(MYSQL_RES *result)
18.4.34.1 Description
결과 셋 내의 행의 개수를 리턴한다.
mysql_num_rows() 함수의 사용 여부는 결과 셋을 얻기 위해서 mysql_store_result() 함수를 사
용하는가 mysql_use_result() 함수를 사용하는가에 달려있다. 만약 mysql_store_result() 함수를
사용한다면 mysql_num_rows() 함수는 즉시 호출될 수 있다. 만약 mysql_use_result() 함수를
사용한다면 mysql_num_rows() 함수는 결과 셋 내의 모든 행들이 retrieve되기 이전에는 올바
른 값을 리턴하지 못한다.
18.4.34.2 Return values
결과 셋 내의 행의 개수
18.4.34.3 Errors
None.
18.4.35 mysql_ping()
int mysql_ping(MYSQL *mysql)
18.4.35.1 Description
서버에 대한 연결이 제대로 동작하고 있나를 확인하며, 만약 연결이 끊어진 경우에는 자동
으로 재연결을 시동한다.
이 함수는 클라이언트가 너무 오랫동안 쉬고 있을 때 서버가 연결을 끊었나를 체크하고 필
요하다면 다시 연결하기 위해 사용될 수 있다.
18.4.35.2 Return values
서버가 살아있으면 0, 에러인 경우 0이 아닌 값을 리턴한다.
18.4.35.3 Errors
CR_COMMANDS_OUT_OF_SYNC
Commands were executed in an improper order.
CR_SERVER_GONE_ERROR
The MySQL server has gone away.
CR_UNKNOWN_ERROR
An unknown error occurred.
18.4.36 mysql_query()
int mysql_query(MYSQL *mysql, const char *query)
18.4.36.1 Description
null-terminated 문자열인 query 인수에 지정된 SQL 질의를 수행한다. 질의는 반드시 하나의
SQL 문으로 이루어져야 하며, 질의문에 세미콜론(;)이나 '\g'를 붙여서는 안된다.
mysql_query()는 이진 데이터를 포함하는 질의에는 사용할 수 없다. 이진 데이터는 중간에
NULL 문자를 포함할 수 있으며 이경우 mysql_query() 함수는 거기서 질의 문자열이 끝난 것
으로 인식하기 때문에 이경우에는 mysql_real_query() 함수를 사용하여야 한다.
18.4.36.2 Return values
성공이면 0, 에러이면 0이 아닌 값을 리턴.
18.4.36.3 Errors
CR_COMMANDS_OUT_OF_SYNC
Commands were executed in an improper order.
CR_SERVER_GONE_ERROR
The MySQL server has gone away.
CR_SERVER_LOST
The connection to the server was lost during the query.
CR_UNKNOWN_ERROR
An unknown error occurred.
18.4.37 mysql_real_connect()
MYSQL *mysql_real_connect(MYSQL *mysql, const char *host, const char *user, const char *passwd,
const char *db, uint port, const char *unix_socket, uint client_flag)
18.4.37.1 Description
mysql_real_connect() 함수는 호스트에서 돌아가고 있는 MySQL 데이터베이스 엔진에 연결을
시도한다. mysql_real_connect()는 mysql_get_client_info() 함수를 제외한 다른 모든 API 함수를
수행하기 이전에 반드시 성공적으로 수행되어져야 한다.
사용하는 인수들은 다음과 같다:
mysql 인수는 MYSQL connection 구조체이거나 NULL이 될 수 있다. 만약 mysql 인수가
NULL이면 C API는 자동으로 연결 구조체를 위한 메모리를 할당하고 mysql_close()가 호출
될 때 이를 해제한다. 이경우 단점은 연결이 실패한 경우 에러 메시지를 얻어올 수 없다는
것이다(mysql_errno()나 mysql_error() 함수로부터 에러 메시지를 얻기 위해서는 유효한
MYSQL 포인터를 제공하여야 한다). mysql 인수가 NULL이 아니면 이미 존재하는 MYSQL
구조체의 주소가 되어야 한다. 이 경우, mysql_real_connect() 함수를 호출하기 전에 반드시
mysql_init() 함수를 호출하여 MYSQL 구조체를 초기화해 주어야 한다. 다음의 예를 보라.
host 인수는 호스트명이 되거나 IP 어드레스가 될 수 있다. 만약 host 인수가 NULL이거나
"localhost"인 경우 로컬 호스트로의 접속으로 간주된다. 만약 OS가 소켓(socket-Unix)이나 파
이프(pipe-Win32)를 지원한다면 서버와의 연결을 위하여 TCP/IP 대신 이들을 사용할 수 있다.
user 인수에는 사용자의 MySQL 로그인 아이디를 넣어준다. User 인수가 NULL이면 현재 사
용자로 간주된다. Unix 환경에서는 현재 시스템 로그인명이 사용되며, Windows ODBC에서는
현재 사용자명이 명확히 지정되어야 한다. 15.4절에서는 ODBC 관리 프로그램에서 각 필드
들을 어떻게 채울 것인가에 대하여 논의한다.
passwd 인수에는 사용자에 대한 패스워드를 넣어준다. 만약 passwd가 NULL이면 user 테이
블에서 패스워드 필드가 비어있는 사용자들만이 매치를 위해 체크되어진다. 이것은 데이터
베이스 관리자로 하여금 데이터베이스 사용자가 자신의 패스워드를 명시하였나에 따라서 다
른 권한을 가지도록 하는 MySQL 권한 시스템을 설정할 수 있도록 해준다. 주의할 것은
mysql_real_connect() 함수를 호출하기 전에 패스워드를 암호화하려고 하지 말아야 한다는 것
이며, 패스워드의 암호화는 클라이언트 API에 의하여 자동으로 수행된다.
db 인수는 사용할 데이터베이스의 이름을 넣어준다. 만약 db 인수가 NULL이면 디폴트 데
이터베이스에 연결을 시도하게 된다.
port 인수가 0이 아니면 port 인수에 명시된 포트 번호를 TCP/IP 연결을 위한 포트 번호로
사용하게 된다. host 인수가 연결의 형식을 결정한다는 것에 주의한다.
unix_socket 인수가 NULL이 아니면 이 인수 문자열이 사용될 socket이나 named pipe가 된다.
client_flag 값은 보통 0이지만 매우 특별한 경우에 다음의 플래그들의 조합으로 설정할 수
있다.
-----------------------------------------------------------------------------------------
| Flag name | Flag meaning |
-----------------------------------------------------------------------------------------
| CLIENT_FOUND_ROWS | affected row의 갯수가 아닌 found row의 갯수를 리턴한다. |
-----------------------------------------------------------------------------------------
| CLIENT_NO_SCHEMA | db_name.tbl_name.col_name 형식의 문법(syntax)을 허용하지 않는다. |
| | 이것은 ODBC를 위한 것으로서, 만약 이와 같은 문법을 사용하면 파서가|
| | 에러를 발생시키게 된다. 이것은 ODBC 프로그램에서 버그를 찾아낼 때 |
| | 유용하게 사용할 수 있다. |
-----------------------------------------------------------------------------------------
| CLIENT_COMPRESS | 압축 프로토콜(compression protocol)을 사용한다. |
-----------------------------------------------------------------------------------------
| CLIENT_ODBC | 클라이언트가 ODBC 클라이언트임을 알려주며, 이것은 mysqld가 좀더 |
| | ODBC에 적합하도록 해준다. |
-----------------------------------------------------------------------------------------
18.4.37.2 Return values
연결이 성공하면 MYSQL * 연결 핸들(connection handle)을 리턴하며, 연결에 실패하면 NULL
을 리턴한다. 연결이 성공한 경우 리턴 값은 첫번째 인수에 NULL을 지정하지 않았다면 그
인수와 동일하다.
18.4.37.3 Errors
CR_CONN_HOST_ERROR
MySQL 서버로의 연결에 실패
CR_CONNECTION_ERROR
로컬 MySQL 서버로의 연결에 실패
CR_IPSOCK_ERROR
IP 소켓의 생성에 실패
CR_OUT_OF_MEMORY
메모리가 없음(Out of memory).
CR_SOCKET_CREATE_ERROR
Unix 소켓의 생성에 실패
CR_UNKNOWN_HOST
해당 호스트명에 대한 IP 주소를 찾을 수 없음.
CR_VERSION_ERROR
일치하지 않는 프로토콜 버전을 사용하는 클라이언트 라이브러리를 가지고 서버에 접속
하려 시도함으로 인하여 프로토콜 불일치가 발생함. 이것은 매우 오래된 클라이언트
라이브러리를 사용하여 새로운 버전의 서버에 접속하고자 하는 경우에 발생한다. 이런
경우에는 서버를 시동할 때 '--old-protocol' 옵션을 넣어서 시동하면 해결할 수 있다.
CR_NAMEDPIPEOPEN_ERROR;
Win32 환경에서 named pipe를 생성하는데 실패함.
CR_NAMEDPIPEWAIT_ERROR;
Win32 환경에서 named pipe를 기다리는데 실패함.
CR_NAMEDPIPESETSTATE_ERROR;
Win32 환경에서 pipe 핸들러를 얻는데 실패함.
18.4.37.4 Example
MYSQL mysql;
mysql_init(&mysql);
if (!mysql_real_connect(&mysql,"host","user","passwd","database",0,NULL,0)) {
fprintf(stderr, "Failed to connect to database: Error: %s\n", mysql_error(&mysql));
}
18.4.38 mysql_real_query()
int mysql_real_query(MYSQL *mysql, const char *query, unsigned int length)
18.4.38.1 Description
query 인수에 지정된 SQL 질의를 수행하며, query 인수는 length 인수에 지정된 길이를 가져
야 한다. 질의는 하나의 SQL 문으로 이루어져야 하며, 세미콜론이나 '\g'를 SQL문에 붙여서
는 안된다.
이진 데이터를 포함하는 질의 데이터인 경우 mysql_query() 함수가 아닌 mysql_real_query()
함수를 사용하여야 한다. 또한 mysql_real_query()함수는 질의문의 길이를 얻기 위한 strlen()
함수를 수행하지 않기 때문에 mysql_query() 함수에 비하여 수행 속도가 빠르다.
18.4.38.2 Return values
질의에 성공하면 0, 에러가 발생하면 0이 아닌 값을 리턴한다.
18.4.38.3 Errors
CR_COMMANDS_OUT_OF_SYNC
Commands were executed in an improper order.
CR_SERVER_GONE_ERROR
The MySQL server has gone away.
CR_SERVER_LOST
The connection to the server was lost during the query.
CR_UNKNOWN_ERROR
An unknown error occurred.
18.4.39 mysql_reload()
int mysql_reload(MYSQL *mysql)
18.4.39.1 Description
MySQL 서버로 하여금 grant 테이블을 다시 읽도록 요청한다. 현재 연결되어 있는 사용자는
반드시 권한 설정을 다시 읽어야 한다.
이 함수를 사용하는 것은 권장되지 않으며, 대신 'FLUSH PRIVILEGES' SQL 문을
mysql_query() 함수를 이용하여 수행하는 것이 좋다.
18.4.39.2 Return values
성공하면 0, 에러면 0이 아닌 값을 리턴한다.
18.4.39.3 Errors
CR_COMMANDS_OUT_OF_SYNC
Commands were executed in an improper order.
CR_SERVER_GONE_ERROR
The MySQL server has gone away.
CR_SERVER_LOST
The connection to the server was lost during the query.
CR_UNKNOWN_ERROR
An unknown error occurred.
18.4.40 mysql_row_seek()
MYSQL_ROW_OFFSET mysql_row_seek(MYSQL_RES *result, MYSQL_ROW_OFFSET offset)
18.4.40.1 Description
결과 셋 내에 행 커서(row cursor)를 임의의 위치로 설정한다. 이를 위해서는 결과 셋 구조체
가 전체 질의 결과를 가지고 있어야 하며, 따라서 mysql_row_seek() 함수는 mysql_use_result()
함수와는 사용할 수 없고 mysql_store_result() 함수와 사용할 수 있다.
offset 인수는 mysql_row_tell() 함수나 mysql_row_seek() 함수를 호출한 리턴값이 되어야 하며,
이 값은 단순한 행 번호를 의미하는 것이 아니다. 만약 행 번호를 이용하여 결과 셋 내에서
행을 찾고자 하는 경우에는 mysql_data_seek() 함수를 사용하여야 한다.
18.4.40.2 Return values
행 커서(row cursor)의 이전값(previous value). 이 값은 mysql_row_seek() 함수의 인수로 넘겨진
다.
18.4.40.3 Errors
None.
18.4.41 mysql_row_tell()
MYSQL_ROW_OFFSET mysql_row_tell(MYSQL_RES *result)
18.4.41.1 Description
마지막 mysql_fetch_row() 함수 호출에 의한 행 커서의 현재 위치를 리턴한다. 이값은
mysql_row_seek() 함수의 인수로 넘겨진다.
mysql_row_tell() 함수는 반드시 mysql_store_result() 함수 뒤에 사용되어야 하며,
mysql_use_result() 함수 뒤에는 사용할 수 없다.
18.4.41.2 Return values
행 커서의 현재 변위(The current offset of the row cursor).
18.4.41.3 Errors
None.
18.4.42 mysql_select_db()
int mysql_select_db(MYSQL *mysql, const char *db)
18.4.42.1 Description
db 인수에 지정한 데이터베이스를 mysql 인수가 가진 연결에 대한 현재 작업 데이터베이스
가 되도록 한다. 이후의 질의에 대해서 여기서 지정한 데이터베이스가 데이터베이스를 명시
하지 않은 테이블 참조에 대한 디폴트 데이터베이스로 사용된다.
연결되어 있는 사용자가 db 인수에 지정된 데이터베이스를 사용할 권한을 가지고 있다는 것
이 인증되지 않으면 mysql_select_db() 함수는 실패한다.
18.4.42.2 Return values
성공이면 0, 에러이면 0이 아닌 값
18.4.42.3 Errors
CR_COMMANDS_OUT_OF_SYNC
Commands were executed in an improper order.
CR_SERVER_GONE_ERROR
The MySQL server has gone away.
CR_SERVER_LOST
The connection to the server was lost during the query.
CR_UNKNOWN_ERROR
An unknown error occurred.
18.4.43 mysql_shutdown()
int mysql_shutdown(MYSQL *mysql)
18.4.43.1 Description
데이터베이스 서버로 하여금 셧다운되도록 요청하며, 현재 연결된 사용자가 셧다운 권한을
가지고 있어야 한다.
18.4.43.2 Return values
성공이면 0, 에러이면 0이 아닌 값을 리턴한다.
18.4.43.3 Errors
CR_COMMANDS_OUT_OF_SYNC
Commands were executed in an improper order.
CR_SERVER_GONE_ERROR
The MySQL server has gone away.
CR_SERVER_LOST
The connection to the server was lost during the query.
CR_UNKNOWN_ERROR
An unknown error occurred.
18.4.44 mysql_stat()
char *mysql_stat(MYSQL *mysql)
18.4.44.1 Description
'mysqladmin status' 명령어에 의해 제공되는 정보와 비슷한 정보를 포함하고 있는 문자열을
리턴한다. 이 문자열에는 구동시간(uptime), 실행되고 있는 쓰레드 수, 질문(question), 재시동
(reload), 열려있는 테이블 등에 대한 정보가 포함되어 있다.
18.4.44.2 Return values
서버 상태를 기술하는 문자열. 에러이면 NULL을 리턴한다.
18.4.44.3 Errors
CR_COMMANDS_OUT_OF_SYNC
Commands were executed in an improper order.
CR_SERVER_GONE_ERROR
The MySQL server has gone away.
CR_SERVER_LOST
The connection to the server was lost during the query.
CR_UNKNOWN_ERROR
An unknown error occurred.
18.4.45 mysql_store_result()
MYSQL_RES *mysql_store_result(MYSQL *mysql)
18.4.45.1 Description
데이터를 얻어오는 질의(SELECT, SHOW, DESCRIBE, EXPLAIN)의 수행에 대하여
mysql_store_result() 혹은 mysql_use_result() 함수를 호출한다.
mysql_store_result() 함수는 전체 질의 결과를 클라이언트로 읽어오며, MYSQL_RES 구조체를
할당하고 결과를 이 구조체에 넣어준다. 아무 행도 리턴되지 않으면 빈 결과 셋(empty result
set)이 리턴된다(빈 결과 셋은 NULL 리턴 값과는 다르다).
mysql_store_result() 함수를 호출하면 mysql_num_rows() 함수를 호출하여 결과 셋 내에 얼마
나 많은 행들이 있는가를 알아 볼 수 있다.
mysql_fetch_row() 함수를 호출하여 결과 셋으로부터 행들을 얻어올 수 있으며, 혹은
mysql_row_seek()와 mysql_row_tell() 함수를 통하여 결과 셋 내에서의 현행 위치를 얻거나 위
치를 설정해줄 수 있다.
결과셋을 통한 작업이 끝나면 반드시 mysql_free_result() 함수를 호출해준다.
18.4.45.2 Return values
결과가 저장된 MYSQL_RES 결과 구조체(result structure). 에러이면 NULL을 리턴.
18.4.45.3 Errors
CR_COMMANDS_OUT_OF_SYNC
Commands were executed in an improper order.
CR_OUT_OF_MEMORY
Out of memory.
CR_SERVER_GONE_ERROR
The MySQL server has gone away.
CR_SERVER_LOST
The connection to the server was lost during the query.
CR_UNKNOWN_ERROR
An unknown error occurred.
18.4.46 mysql_thread_id()
unsigned long mysql_thread_id(MYSQL *mysql)
18.4.46.1 Description
현재 연결에 대한 쓰레드 ID를 리턴한다. 이 값은 mysql_kill() 함수의 인수로 사용되어 쓰래
드를 kill 하는데 사용될 수 있다.
18.4.46.2 Return values
현재 연결에 대한 쓰레드 ID.
18.4.46.3 Errors
None.
18.4.47 mysql_use_result()
MYSQL_RES *mysql_use_result(MYSQL *mysql)
18.4.47.1 Description
데이터를 얻어오는 질의(SELECT, SHOW, DESCRIBE, EXPLAIN)의 수행에 대하여
mysql_store_result() 혹은 mysql_use_result() 함수를 호출한다.
mysql_use_result() 함수는 결과 셋을 얻어오는 작업을 초기화하지만 mysql_store_result() 함수
처럼 실제로 결과 셋을 읽어서 클라이언트에게 넘겨주지는 않는다. 대신 mysql_fetch_row()
함수를 각각 호출함으로써 각 행이 하나씩 얻어진다. 이것은 질의의 결과를 임시 테이블이
나 지역 버퍼에 저장하지 않고 서버로부터 직접 읽어오게 되며, 이는 mysql_store_result() 함
수에 비하여 좀더 빠르고 훨씬 적은 양의 메모리를 차지한다. 클라이언트는 현재 행에 대한
메모리와 max_allowed_packet 바이트까지 증가할 수 있는 통신 버퍼(communication buffer)만
을 할당하게 된다.
하지만 클라이언트 측에서 각 행별로 많은 작업을 수행하고 있거나 사용자가 ^S(stop scroll)
을 입력할 수도 있는 스크린으로 결과를 내보내는 경우에는 mysql_use_result() 함수를 사용
해서는 안된다. 이것은 서버를 멈추게 하고 다른 쓰레드들로 하여금 데이터가 얻어지고 있
는 테이블을 갱신하는 것을 막게 된다.
mysql_use_result() 함수를 사용할 때는 NULL 값이 리턴될 때까지 mysql_fetch_row() 함수를
수행해야 한다. 그렇지 않으면 아직 얻어오지 않은 행들이 다음 질의에 대한 결과 셋으로
넘어가서 리턴되게 된다. C API는 'Commands out of sync' 에러를 주게 된다.
mysql_use_result() 함수로부터 리턴되는 결과에 대해서 mysql_data_seek(), mysql_row_seek(),
mysql_row_tell(), mysql_num_rows(), mysql_affected_rows()과 같은 함수들을 사용할 수 없으며,
혹은 mysql_use_result() 함수가 종료할 때까지 다른 질의를 수행할 수 없다(그러나 모든 행들
을 fetch한 후에는 mysql_num_rows() 함수가 실제로 fetch되어진 행의 개수를 리턴한다).
결과 셋에 대한 작업이 끝나면 반드시 mysql_free_result()를 호출하여야 한다.
18.4.47.2 Return values
MYSQL_RES 결과 구조체(result structure). 에러이면 NULL을 리턴한다.
18.4.47.3 Errors
CR_COMMANDS_OUT_OF_SYNC
Commands were executed in an improper order.
CR_OUT_OF_MEMORY
Out of memory.
CR_SERVER_GONE_ERROR
The MySQL server has gone away.
CR_SERVER_LOST
The connection to the server was lost during the query.
CR_UNKNOWN_ERROR
An unknown error occurred.
18.4.48 mysql_query() 함수가 성공하였는데 mysql_store_result() 함수가 가끔 NULL을 리턴하
는 이유는 무엇인가?
이런 경우가 있을 수 있으며 이것은 다음 중 하나의 상황이 발생하였음을 의미한다:
malloc()이 실패한 경우(예를 들어 결과 셋이 너무 큰 경우).
데이터를 읽을 수 없는 경우(연결에 에러가 생기는 등).
질의가 아무 데이터도 리턴하지 않는 경우(INSERT, UPDATE, DELETE 문 등의 경우).
질의문이 비어있지 않은(non-empty) 결과를 생성하였나는 mysql_num_fields() 함수를 호출함
으로써 체크해볼 수 있다. 만약 mysql_num_fields() 함수가 0을 리턴하면 결과셋이 빈 것이
고 가장 마지막 질의가 INSERT, DELETE와 같이 값을 리턴하지 않는 질의문임을 의미한다.
mysql_num_fields() 함수가 0이 아닌 값을 리턴하는 경우는 질의문이 비어있지 않는 결과를
생성해야만 함을 의미한다. 자세한 내용은 mysql_num_fields() 함수의 설명을 참조한다.
mysql_errno() 함수나 mysql_error() 함수를 호출함으로써 에러를 테스트해볼 수 있다.
18.4.49 What results can I get from a query?
질의의 결과로 리턴되는 결과 셋에 덧붙여 다음과 같은 정보들을 또한 얻을 수 있다:
- mysql_affected_rows()는 INSERT, UPDATE, DELETE 문을 수행할 때 가장 최근에 수행된
질의에 의해 affected된 행들의 개수를 리턴한다. 예외는 DELETE가 WHERE 구문없이
사용되어 테이블이 truncate되는 경우이다. 이 경우 mysql_affected_rows() 함수는 affected
된 레코드의 숫자로서 0을 리턴한다.
- mysql_num_rows()는 결과 셋 내의 행의 개수를 리턴한다. mysql_store_result() 함수와 함께
사용되는 경우에는 mysql_store_result()가 리턴되자마자 최대한 빨리 mysql_num_rows()가
호출되어진다. mysql_use_result()와 함께 사용되는 경우에는 mysql_fetch_row()가 모든 행
에 대해서 수행된 후에만 mysql_num_rows()가 호출될 수 있다.
- mysql_insert_id()는 AUTO_INCREMENT 인덱스를 가진 테이블에 행을 추가한 경우 가장
최근에 새로 생성된 ID를 리턴한다.
- 몇몇 질의들(LOAD DATA INFILE ..., INSERT INTO ... SELECT ..., UPDATE)은 부가적인 정
보를 리턴한다. 이 결과들은 mysql_info()에 의하여 리턴된다. mysql_info()는 리턴할 부가
적인 정보가 없는 경우 NULL을 리턴한다.
18.4.50 How can I get the unique ID for the last inserted row?
AUTO_INCREMENT 속성을 가지는 컬럼을 포함하고 있는 테이블에 새로운 레코드를 삽입
하는 경우, mysql_insert_id() 함수를 호출함으로써 가장 최근에 생성된 ID를 얻어올 수 있다.
다음의 코드를 수행함으로써 AUTO_INCREMENT 인덱스가 사용되었나를 체크해 볼 수 있다.
또한 질의가 AUTO_INCREMENT 인덱스를 가진 INSERT 문인가를 체크할 수 있다:
if (mysql_error(&mysql)[0] == 0 && mysql_num_fields(result) == 0 && mysql_insert_id(&mysql) != 0)
{
used_id = mysql_insert_id(&mysql);
}
하나의 테이블에서 생성된 ID를 다른 테이블에 삽입하는데 사용하고자 하는 경우 다음과
같은 SQL 문을 사용한다:
INSERT INTO foo (auto, text) VALUES(NULL, 'text'); # generate ID by inserting NULL
INSERT INTO foo2 (id, text) VALUES(LAST_INSERT_ID(), 'text'); # use ID in second table
18.4.51 Problems linking with the C API
어떤 시스템에서는 C API를 linking하여 컴파일할 때 다음과 같은 에러가 발생할 수 있다:
gcc -g -o client test.o -L/usr/local/lib/mysql -lmysqlclient -lsocket -lnsl
Undefined first referenced
symbol in file
floor /usr/local/lib/mysql/libmysqlclient.a(password.o)
ld: fatal: Symbol referencing errors. No output written to client
위와 같은 에러가 발생하는 경우에는 컴파일 시에 -lm을 추가함으로써 math 라이브러리를
함께 포함해 준다.
18.4.52 How to make a thread-safe client
클라이언트는 거의 thread-safe하다. 가장 큰 문제점은 'net.c'에서 소켓을 읽는 서브루틴들이
interrupt-safe하지 못하다는 것이다. 이것은 서버로부터 읽는 작업이 오래 걸릴 때 클라이언
트가 작업을 중단할 수 있는 기능을 원할 것이라는 생각에서 그렇게 작성되어졌다.
표준 클라이언트 라이브러리는 쓰레드 옵션없이 컴파일되어진다.
Thread-safe 클라이언트를 만들기 위해서는 -lmysys, -lstring, -ldbug 라이브러리와 서버가 사용
하는 net_serv.o를 함께 사용한다.
Threaded client를 사용하면 'thr_alarm.c' 파일에 있는 루틴들을 활용할 수 있다. mysys 라이브
러리의 루틴들을 사용할 때 기억해야할 단 한가지는 my_init() 함수를 가장 먼저 호출해야
한다는 것이다!
mysql_real_connect()를 제외한 모든 함수들은 현재 thread-safe하다. 다음의 내용에서는 thread-
safe 클라이언트 라이브러리를 컴파일하는 방법과 그것을 thread-safe 방식으로 사용하는 방
법에 대하여 기술한다(여기서는 mysql_real_connect() 함수에 대한 예를 설명하며,
mysql_connect()의 경우에도 동일하다).
mysql_real_connect() 함수를 thread-safe하게 만들기 위해서는 다음의 명령으로 클라이언트를
재컴파일하여야 한다:
shell> CPPFLAGS=-DTHREAD_SAFE_CLIENT ./configure ...
pthread 라이브러리가 디폴트로 포함되어지지 않기 때문에 표준 클라이언트(standard client)를
링킹할 때 정의되지 않은 심볼(undefined symbols)로 인한 에러가 발생할 수 있다.
결과로 나오는 'libmysqld.a' 라이브러리는 이젠 thread-safe하다. 이것은 두개의 thread가
mysql_real_connect()에 의해 리턴된 동일한 연결 핸들(connection handle)을 동시에 질의하지
않는 한 클라이언트 코드가 thread-safe하다는 것을 의미한다; 클라이언트/서버 프로토콜은
주어진 연결에 대하여 동시에 하나의 요청만을 허용한다. 동일한 연결에 대하여 복수개의
thread를 사용하길 원하는 경우에는 mysql_query()와 mysql_store_result()의 호출 묶음(call
combination)에 대하여 mutex lock을 해야 한다.
일단 mysql_store_result()가 준비되면 lock은 해제될 수 있으며 다른 thread들은 동일한 연결
에 대하여 query를 할 수 있다(다시 말해서, 서로 다른 thread들이 적절한 locking 프로토콜
을 사용하는 한 mysql_store_result()과 함께 생성된 서로 다른 MYSQL_RES 포인터들을 사용
할 수 있다). POSIX thread로 프로그램한다면 mutex lock을 생성하고 해제하는데
pthread_mutex_lock()와 pthread_mutex_unlock() 함수를 사용할 수 있다.
mysql_store_result()가 아닌 mysql_use_result()를 사용하는 경우에는 lock이 mysql_use_result()
와 mysql_fetch_row()에 대한 호출을 surround할 필요가 있다. 그러나 threaded client는
mysql_use_result()를 사용하지 않는 것이 가장 좋다.
19. 타 DB와 비교
19.1 Mysql/mSQL 비교
이번장은 Mysql 개발자가 쓴 글이므로 이점을 염두에 두고 보아야 한다.
그렇지만 개발자들이 알고 있는대로 솔직하게 작성되었다.
지원되는 함수, 타입, 제한사항등은 crash-me 웹 페이지를 참고하면 된다.
<성능>
속도 비교와 관련해서는 Mysql 벤치마크를 참고한다. (11장) mSQL은 스레
드 생성 때문에 발생하는 과부하가 없고, 파져(parser)가 작으며, 기능이
적고 보안이 간단하다. 그래서 다음과 같은 경우에는 mSQL의 속도가 빠르
다.
- 연결/해제를 반복하면서 각 연결때마다 간단한 질의를 하는 테스트
-몇개의 컬럼과 키만 있는 아주 간단한 테이블에 자료을 입력(INSER)하는
경우
- CREATE TABLE, DROP TABLE
- 인덱스 없이 SELECT 하는 경우(테이블 검색이 매우 간단)
이런 작업들은 매우 간단해서, 시작시 높은 부하가 걸리는 경우에 좋다.
연결이 되고나서는 Mysql이 더 높은 성능을 보여준다.
그 외에는 다음과 같은 면에서 Mysql이 mSQL( 및 다른 SQL 프로그램) 보다
빠르다.
- 복합적인 SELECT 연산
- 대량의 자료를 검색 (Mysql은 성능이 뛰어나고 빠르며 안전한 프로토콜
을 사용한다)
- 가변길이 문자열을 가진 테이블. Mysql은 효율적으로 되어있으며
VARCHAR 컬럼에 인덱스를 사용할 수 있다.
- 많은 컬럼을 가진 테이블을 다루는 경우
- 레코드 길이가 큰 테이블을 다루는 경우
- 많은 표현식(expression)을 가진 SELECT 문을 사용하는 경우
- 거대한 테이블에서 SELECT문을 사용하는 경우
- 동시에 다중으로 연결을 처리해야할 때. Mysql은 완전한 멀티스레드를
지원한다. 각 연결은 자신의 스레드를 가지며 이는 스레드에서 다른 스레
드를 기다릴 필요가 없다는 것을 의미한다. (현재의 스레드가 다른 스레드
에서 접근하기 원하는 테이블을 수정하고 있는 경우는 제외) mSQL에서는
하나의 연결이 성립되면 그 연결에서 질의를 수행하든 하지 않든 상관없이
첫 번째 연결이 끝날때까지 다른 것들은 기다려야한다. 첫 번째 연결이 해
제되면 다음 연결이 성립되고 또 다른 것들은 다시 기다려야한다.
- 조인. mSQL에서는 SELECT에서 테이블의 정렬 순서를 변경하면 엄청나게
느려진다. 벤치마킹 프로그램을 사용하였을 때, 그 시간은 Mysql보다 최대
15000배 느렸다. mSQL에서는 최적의 순서에 따른 테이블을 정열하기 위한
조인 최적화기가 없기 때문이다. 그렇지만, 테이블을 mSQL2의 적절한 정열
순서에 따라 정확하게 테이블을 구성하고 WHERE 가 간단하고 인덱스 컬럼
을 사용하면 조인은 상대적으로 빨라진다. 11장 Mysql 벤치마킹 참고.
- ORDER BY and GROUP BY.
- DISTINCT
- TEXT 나 BLOB 컬럼 사용
<SQL 특징>
- GROUP BY, HAVING. mSQL은 GROUP BY를 지원하지 않는다. Mysql은 완전
하게 GROUP BY 와 HAVING을 지원하며 다음의 함수를 지원한다. COUNT(),
AVG(), MIN(), MAX(), SUM() and STD(). COUNT(*)는 하나의 테이블에서
SELECT를 사용하고, 컬럼은 검색하지 않으며 WHERE 문이 없을 경우 매우
빠르게 최적화되어있다. MIN() 과 MAX()는 문자열 인자를 가진다.
- INSERT 와 UPDATE에서 계산가능.
예)Mysql> UPDATE SET x=x*10+y WHERE x<20;
- 알리아싱. Mysql에는 컬럼 알리아싱이 있다.
- 컬럼 이름 한정. Mysql에서 컬름 이름이 질의에 사용된 테이블에서 유일
하다면, 완전한 한정자를 쓸 필요가 없다. (** table_name.column_name 이
런 식으로 하지 않아도 된다는 말입니다**)
- SELECT문에서 다양한 함수 지원. 7.3 함수 참조.
<디스크 공간 효율성>
테이블을 얼마나 작게 만들 수 있는가를 말한다. Mysql에는 매우 정밀한
타입이 많으므로 매우 적은 공간만을 차지하도록 테이블을 만들 수 있다.
예를 들어 유용한 데이터타입중 하나는 MEDIUMINT로 3 바이트 long이다. 1
억건의 레코드가 있는 경우, 각 레코드당 1 바이트를 절약하는 것은 매우
중요하다. mSQL2는 지원하는 데이터 타입이 제한되어있어서 테이블을 작게
만들기가 어렵다.
<안정성>
안정성을 객관적으로 판단하는 것은 쉬운 일이 아니다. Mysql의 안정성은
1.5장 참고. 우리는(Mysql 개발팀)은 mSQL의 안정성에 대한 경험이 없으므
로 이에 대해서는 말할 것이 없다.
<가격>
주요한 주제중의 하나가 라이센스이다. Mysql은 mSQL보다 유연한 라이센스
정책을 가지고 있으며 가격도 저렴하다. 어떤 제품을 선택하든 최소한 라
이센스나 이메일 지원에 대한 비용을 고려해야한다. (물론 판매하는 제품
에 Mysql이 포함되어있으면 라이센스가 반드시 필요하다)
<펄 인터페이스>
Mysql은 몇가지 추가된 기능과 함께 mSQL과 동일한 펄 인터페이스를 가지
고 있다.
<JDBC(Java)>
Mysql은 현재 4가지 JDBC 드라이버가 있다.
- The gwe driver: A Java interface by GWE technologies (not supported
anymore).
- The jms driver: An improved gwe driver by Xiaokun Kelvin ZHU
- The twz driver: A type 4 JDBC driver by Terrence W. Zellers and
educational use.
- The mm driver: A type 4 JDBC driver by Mark Matthews{{</LI>
}}
추천하는 드라이버는 twz나 mm 드라이버이다. 둘다 훌륭하게 작동하는 것
으로 보고되었다.
mSQL에 JDBC 드라이버가 있는 것은 알고 있지만 그에 대한 비교 경험은 없
다.
<개발속도>
Mysql은 매우 작은 규모의 개발팀을 가지고 있지만, 모두 C와 C++ 코딩을
매우 빠르게 하는데 익숙해있다. 스레드, 함수, GROUP BY 등등 mSQL에는
아직 구현되지 않은 것들이 많아서 따라오려면 멀었다. mSQL의 최근
'HISTORY' 파일과 Mysql 레퍼런스 매뉴얼의 뉴스 섹션을 비교해보자. 어떤
것이 빠르게 개발되고 있는지 명확할 것이다.
<유틸리티 프로그램>
mSQL과 Mysql에는 매우 다양한 서드-파티 툴이 있다. mSQL에서 Mysql로 포
팅하는 것이 매우 쉽기 때문에, mSQL에서 사용가능한 대부분의 애플리케이
션은 Mysql에서도 사용할 수 있다.
Mysql에는 간단한 mSQL2Mysql 프로그램이 들어있는데 mSQL과 Mysql 사이의
대부분의 C-API 함수의 스펠링을 바꿀 수 있다. mSQL에서 Mysql 로 클라이
언트 프로그램을 포팅하는 것은 일반적으로 그다지 시간이 걸리지 않는다.
19.1.1 mSQL 툴을 Mysql로 바꾸기
경험상 보았을 때, mSQL C-API를 사용하는 mSQL-tcl 과 mSQLjava를 Mysql
C-API 에서 작동할 수 있도록 변환하는 것은 몇시간이면 충분하다.
변환과정은 다음과 같다:
1. 소스에서 mSQL2Mysql 스크립트를 실행한다. 여기에는 replace 프로그램
이 필요한데, Mysql과 함께 배포된다.
2. 컴파일
3. 모든 컴파일 에러 수정
mSQL C API와 Mysql C API 의 차이점은 다음과 같다.
- Mysql uses a Mysql structure as a connection type (mSQL uses an
int).
- Mysql_connect() takes a pointer to a Mysql structure as a
parameter. It is easy to define one globally or to use malloc() to
get one. Mysql_connect() also takes 2 parameters for specifying the
user and password. You may set these to NULL, NULL for default use.
- Mysql_error() takes the Mysql structure as a parameter. Just add
the parameter to your old mSQL_error() code if you are porting old
code.
- Mysql returns an error number and a text error message for all
errors. mSQL returns only a text error message.
- Some incompatibilities exist as a result of Mysql supporting
multiple connections to the server from the same process.{{</LI>
}}
(
M
ysql은 동일한 프로세스에서 서버에 다중 연결을 지원하므로 호환되지 않는 부분이 존재한다.)
19.1.2 mSQL 과 Mysql 클라이언트/서버 통신 프로토콜 차이점
mSQL과 Mysql을 둘다 지원하지 못하거나 힘든 몇가지 차이점이 있다.
Mysql 프로토콜이 mSQL 프로토콜과 다른 몇가지 주요 차이점은 다음과 같
다.
- 메시지 버퍼에 많은 검색 행을 가지고 있다.
- 메시지 버퍼는 질의나 결과가 현재의 버퍼보다 크면, 서버와 클라이언트
에서 설정한 제한선까지 동적으로 확장이 될 수 있다.
- 중복되거나 분실된 패킷을 잡아 모든 패킷의 숫자를 셀 수 있다.
- 모든 컬럼 값은 아스키로 전송된다. 컬럼과 행의 길이는 바이너리 코딩
(1, 2, 3 바이트)으로 꾸려져 전송된다.
- Mysql can read in the result unbuffered (without having to store
the full set in the client).
- 단일 쓰기/읽기 락이 30초이상 걸리면, 서버에서 연결을 해제한다.
- 연결이 8시간 이상 쉬고 있으면, 서버에서 연결을 해제한다.
19.1.3 How mSQL 2.0 SQL syntax differs from Mysql
(** 굳이 번역하지 않습니다. 심심하면 한번 읽어보세요. mSQL 써본지 워
낙 오래되었고 그다지 쓸 일이 없어서요**)
Column types
Mysql
Has the following additional types (among others; see see section
7.6)
ENUM type for one of a set of strings.
SET type for many of a set of strings.
BIGINT type for 64-bit integers.{{</LI>
}}
Mysql also supports the following additional type attributes:
UNSIGNED option for integer columns.
ZEROFILL option for integer columns.
AUTO_INCREMENT option for integer columns that are a PRIMARY KEY.
DEFAULT value for all columns.{{</LI>
}}
mSQL2
mSQL column types correspond to the Mysql types shown below:{{<TBODY>
}}
mSQLtype Corresponding Mysql type
CHAR(len) CHAR(len)
TEXT(len) TEXT(len). len is the maximal length. And LIKE works.
INT INT. With many more options!
REAL REAL. Or FLOAT. Both 4- and 8-byte versions are
available.
UINT INT UNSIGNED
DATE DATE. Uses ANSI SQL format rather than mSQL's own.
TIME TIME
MONEY DECIMAL(12,2). A fixed-point value with two decimals.{{</TBODY>
}}
{{</DD>
}}Index creation
Mysql
Indexes may be specified at table creation time with the CREATE TABLE
statement.
mSQL
Indexes must be created after the table has been created, with
separate CREATE INDEX statements.{{</DD>
}}
To insert a unique identifier into a table
Mysql
Use AUTO_INCREMENT as a column type specifier.
mSQL
Create a SEQUENCE on a table and select the _seq column.{{</DD>
}}
To obtain a unique identifier for a row
Mysql
Add a PRIMARY KEY or UNIQUE key to the table.
mSQL
Use the _rowid column. Observe that _rowid may change over time
depending on many factors.{{</DD>
}}
To get the time a column was last modified
Mysql
Add a TIMESTAMP column to the table. This column is automatically set
to the current date and time for INSERT or UPDATE statements if you
don't give the column a value or if you give it a NULL value.
mSQL
Use the _timestamp column.{{</DD>
}}
NULL value comparisons
Mysql
Mysql follows ANSI SQL and a comparison with NULL is always NULL.
mSQL
In mSQL, NULL = NULL is TRUE. You must change =NULL to IS NULL and
<>NULL to IS NOT NULL when porting old code from mSQL to Mysql.{{</DD>
}}
String comparisons
Mysql
Normally, string comparisons are performed in case-independent
fashion with the sort order determined by the current character set
(ISO-8859-1 Latin1 by default). If you don't like this, declare your
columns with the BINARY attribute, which causes comparisons to be
done according to the ASCII order used on the Mysql server host.
mSQL
All string comparisons are performed in case-sensitive fashion with
sorting in ASCII order.{{</DD>
}}
Case-insensitive searching
Mysql
LIKE is a case-insensitive or case-sensitive operator, depending on
the columns involved. If possible, Mysql uses indexes if the LIKE
argument doesn't start with a wildcard character.
mSQL
Use CLIKE.{{</DD>
}}
Handling of trailing spaces
Mysql
Strips all spaces at the end of CHAR and VARCHAR columns. Use a TEXT
column if this behavior is not desired.
mSQL
Retains trailing space.{{</DD>
}}
WHERE clauses
Mysql
Mysql correctly prioritizes everything (AND is evaluated before OR).
To get mSQL behavior in Mysql, use parentheses (as shown below).
mSQL
Evaluates everything from left to right. This means that some logical
calculations with more than three arguments cannot be expressed in
any way. It also means you must change some queries when you upgrade
to Mysql. You do this easily by adding parentheses. Suppose you have
the following mSQL query:
Mysql> SELECT * FROM table WHERE a=1 AND b=2 OR a=3 AND b=4;
To make Mysql evaluate this the way that mSQL would, you must add
parentheses:
Mysql> SELECT * FROM table WHERE (a=1 AND (b=2 OR (a=3 AND
(b=4))));
{{</DD>
}}Access control
Mysql
Has tables to store grant (permission) options per user, host and
database.
mSQL
Has a file `mSQL.acl' in which you can grant read/write privileges
for users.
19.2 PostgreSQL과 Mysql 비교
PostgreSQL은 사용자-정의 타입, 트리거, 룰, 트랜잭션 지원 등 몇가지 향
상된 기능을 가지고 있다. 그렇지만 ANSI SQL 과 ODBC의 표준 타입이나 함
수 지원이 미약하다. 지원되거나 지원되지 않는 제한, 타입, 함수는
crash-me 웹 페이지를 참고하
자.(http://www.Mysql.com/crash-me-choose.htmy)
일반적으로 PostgreSQL은 Mysql보다 느리다. 11장 [벤치마크] 참고. 이것
은 대부분 트랜잭션 시스템 때문이다. 정말로 트랜잭션이 필요하고 속도를
희생할 생각이 있다면 PostgreSQL을 고려해볼 수 있다.
**참고
http://www.postgresql.org/comp-comparison.html
여기에 가면 간략하게나마 PostgreSQL과 타 DB와 비교자료가 있습니다.
http://database.sarang.net/database/database.phtml
여기에는 위 자료 번역본이 있습니다.
|
RECENT COMMENT