-----------------------------------------
INSERT  [LOW_PRIORITY | DELAYED] [IGNORE] [INTO] table_name ...
REPLACE [LOW_PRIORITY | DELAYED] [INTO] table_name ...
UPDATE  [LOW_PRIORITY] [IGNORE] table_name ...
DELETE  [LOW_PRIORITY] [QUICK] FROM table_name ...
ALTER   [IGNORE] TABLE table_name ...
SELECT  [HIGH_PRIORITY] ... FROM table_name ...
-----------------------------------------

LOW_PRIORITY :

데이터를 SELECT 가 아닌 추가, 수정, 삭제할 경우에 해당되며,
다른 클라이언트가 SELECT 를 모두 마칠때까지 기다린 후 실행


DELAYED :

데이터를 추가할 경우에 해당되며, 메모리에 저장해 놓고 처리함
(클라이언트는 SELECT 가 끝날때까지 기다리지 않음)
항상 '1 rows affected' 의 결과를 냄


IGNORE :

PRIMARY KEY, UNIQUE KEY 에 대한 동일한 데이터를 추가, 수정, 삭제할
경우에 해당되며, 이런 에러를 무시하고 계속 진행함.


HIGH_PRIORITY :

데이터를 SELECT 검색할 경우에만 해당되며, 다른 작업보다 우선순위가
높음(SELECT 가 더 빈번한 경우에 사용)


-----------------------------------------

예제1) 입력 > 검색

데이터의 추가, 수정, 삭제가 검색(SELECT) 보다 더 빈번하여
입력쪽에 더 비중을 두고자 한다면,
데이터의 빠른 추가, 수정, 삭제가 요구되므로,

INSERT  DELAYED [IGNORE] [INTO] table_name ...
REPLACE DELAYED [INTO] table_name ...
UPDATE  [IGNORE] table_name ...
DELETE  QUICK FROM table_name ...
SELECT  ... FROM table_name ...


이와 SELECT 에는 HIGH_PRIORITY 를 사용하지 않는 것이 좋으며,
INSERT 나 REPLACE 에는 DELAYED 를 사용을 권함.


예제2) 입력 < 검색

데이터의 검색(SELECT)이 추가, 수정, 삭제 보다 더 빈번하여
데이터의 검색쪽에 더 비중을 두고자 한다면,
더 빠른 검색이 요구되므로 예제1과 그 반대로,

INSERT  LOW_PRIORITY [IGNORE] [INTO] table_name ...
REPLACE LOW_PRIORITY [INTO] table_name ...
UPDATE  LOW_PRIORITY [IGNORE] table_name ...
DELETE  LOW_PRIORITY FROM table_name
SELECT  HIGH_PRIORITY ... FROM table_name ...


이와 SELECT 에는 HIGH_PRIORITY 를 사용하는 것이 좋으며,
나머지는 LOW_PRIORITY 사용을 권함.

*참고)
CREATE TABLE table_name ( ... ) PACK_KEYS=1;
or
ALTER TABLE table_name PACK_KEYS=1;


예제3) 입력 '=. 검색

데이터 입력과 검색을 비슷한 비중으로 하고자 한다면,

INSERT  DELAYED [IGNORE]
REPLACE DELAYED
UPDATE  LOW_PRIORITY [IGNORE] <-- 아무래도 SELECT 보다 더 비중이 적으므로
DELETE  LOW_PRIORITY QUICK    <-- 아무래도 SELECT 보다 더 비중이 적으므로
SELECT  HIGH_PRIORITY

이와 같이 SELECT 쪽에 약간 더 비중을 두어 SQL 문을
완성하는 것이 좋음.


*참고1) INSERT INTO 와 REPLACE INTO

레코드에 어떤 데이터를 추가할때 기존에 같은 PRIMARY KEY 가
있으면 INSERT 는 에러를 냄.

반면,
REPLACE 는 기존에 같은 PRIMARY KEY 가 있으면, 기존의 레코드를
삭제(DELETE)하고 새로 INSERT 하기 때문에 항상 '2 rows affected' 의
결과가 되고(DELETE and INSERT), 같은 PRIMARY KEY 가 없으면 이때는
INSERT 와 동일하게 '1 rows affected' 가 됨.

만약 테이블에서 PRIMARY KEY 나 UNIQUE 한 KEY 가 없다면,
REPLACE 구문은 필요가 없으며, 이때는 INSERT 구문을 사용해야 함


*참고2) INSERT INTO 와 INSERT DELAYED INTO

INSERT INTO 는 기존에 같은 PRIMARY KEY 가 있으면 에러를 내지만,
INSERT DELAYED INTO 내부적으로 SELECT 와 INSERT 가 이루어지기
때문에 에러없이 항상 '1 rows affected' 가 이루어짐.

즉, INSERT DELAYED INTO 는 기존에 같은 PRIMARY KEY 가 있으면,
현재의 데이터를 더 이상 INSERT 를 하지 않고, 
항상 '1 rows affected' 의 결과를 보냄.

바꾸어 말하면, 기존의 레코드는 수정(DELETE, UPDATE, REPLACE)되지
않고 그대로 있기 때문에, PRIMARY KEY 외에 다른 데이터가 서로
다를지라도 갱신되지 않음

바로 이점이 REPLACE INTO 나 REPLACE DELAYED INTO 와 서로 다름.
(REPLACE 는 기존의 레코드를 삭제하고 새로운 데이터가 추가되기
때문에 PRIMARY KEY 외의 다른 데이터는 갱신됨).

MySQL 매뉴얼에 의하면, INSERT DELAYED INTO 구문은 ISAM, MyISAM 테이블
에서만 가능하고, 사용할 수 없는 테이블에서는 INSERT 보다 느려진다고 함
(HEAP 테이블도 가능함)

  적용예
  1. SELECT COONT(*) FROM table WHERE mixed_primary_key_compare
  2. 만약 COONT(*) 값이 없다면,
     INSERT INTO table ...
     만약 COUNT(*) 값이 있다면,
     SKIP.

  이 2가지 과정을 한번에 처리할 수 있는 것이 바로 INSERT DELAYED INTO 임

  INSERT DELAYED INTO table ...

만약 PRIMARY KEY 외의 다른 값들이 항상 새로운 값으로 갱신되기
원한다면 REPLACE INTO 나 REPLACE DELAYED INTO 를 사용하면 됨.


*참고3) REPLACE INTO 와 REPLACE DELAYED INTO

우선 이 두개의 결과는 항상 동일하며,
기존에 같은 PRIMARY KEY 가 있으면 REPLACE INTO 는 기존의
레코드를 삭제하고 INSERT 하는 반면, REPLACE DELAYED INTO 는
기존의 레코드를 UPDATE 하는 방식이므로 항상 '1 rows affected' 의
결과를 보냄.

  적용예
  1. SELECT COONT(*) FROM table WHERE mixed_primary_key_compare
  2. 만약 COUNT(*) 값이 없다면,
     INSERT INTO table ...
     만약 COONT(*) 값이 있다면,
     UPDATE TABLE table SET ... WHERE mixed_primary_key_compare

  이 2가지 과정을 한꺼번에 처리할 수 있는 방법이 바로,

  REPLACE DELAYED INTO table ...

기존에 같은 PRIMARY KEY 가 없다면 결과적으로 INSERT 함.


*참고4) INSERT DELAYED INTO 와 REPLACE DELAYED INTO

DELAYED 구문은 항상 '1 rows affected' 의 결과를 보낸다는 점을
감안하면, 전자는 SELECT + INSERT 이고, 후자는 SELECT + UPDATE
의 형식임.

즉, 기존에 같은 PRIMARY KEY 가 있다면, 전자는 항상 기존의 레코드는
그대로 있고(다른 컬럼도 갱신하지 않음), 후자는 항상 새로운 레코드로
UPDATE 함.

기존에 같은 PRIMARY KEY 가 없다면 결과적으로 모두 INSERT 함.

정리하면 다음과 같음.

<FONT FACE='굴림체'>
+-----------------+----------------------+-------------+----------+----------+
| 구분(same KEY)  | exits                | not exists  | 기존 row | 비고     |
|-----------------+----------------------+-------------+----------+----------|
| INSERT          | error(FALSE), (0)    | INSERT, (1) |          |          |
|-----------------+----------------------+-------------| 갱신(X)  |----------|
| INSERT DELAYED  | SKIP(TRUE), (1)      | INSERT, (1) |          | 항상 (1) |
|-----------------+----------------------+-------------+----------+----------|
| REPLACE         | DELETE + INSERT, (2) | INSERT, (1) |          |          |
|-----------------+----------------------+-------------| 갱신(O)  |----------|
| REPLACE DELAYED | UPDATE, (1)          | INSERT, (1) |          | 항상 (1) |
+-----------------+----------------------+-------------+----------+----------+
</FONT>
*주1) 'same KEY' 는 PRIMARY KEY 또는 UNIQUE KEY 에 대한 row 존재 여부
*주2) PRIMARY KEY 또는 UNIQUE KEY 설정이 없으면 REPLACE 는 무의미함.
*주3) 괄호() 안의 숫자는 'number of rows affected'를 의미함.