[MYSQL] LIKE vs INSTR()


0. 배경

1. 영문 검색어 테스트
  1-1. 앞 부분 검색
  1-2. 중간 부분 검색
  1-3. 끝 부분 검색

2. 한글 검색어 테스트
  2-1. 앞 부분 검색
  2-2. 중간 부분 검색
  2-3. 끝 부분 검색

3. 결과 비교(표)
  3-1. 영문 검색어 결과
  3-2. 한글 검색어 결과

4. 결론

5. 후기

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

0. 배경

TRUE 인 경우만 테스트한 경우임.

... cols LIKE '%한글검색어%'
... BINARY cols LIKE '%한글검색어%'

웹 게시판에서, 후자의 경우 속도가 약 3 배, 또는 그 이상 빠름

마찬가지로,

... cols LIKE '%숫자형조합%'
... BINARY cols LIKE '%숫자형조합%'

숫자의 검색도 BINARY 로 검색할 경우 빠름.
(정수형만 테스트해 보았음)



1. 영문 검색어 테스트

1-1. 앞 부분 검색

1) 대소문자 구별시

  DO BENCHMARK(1000000, BINARY 'MSIEdddddd' LIKE 'MSIE%');
  0.47

  DO BENCHMARK(1000000, INSTR('MSIEdddddd','MSIE'));
  0.27


2) 대소문자 구별없이

  DO BENCHMARK(1000000, 'MSIEdddddd' LIKE 'MSIE%');
  0.66

  DO BENCHMARK(1000000, INSTR(LOWER('MSIEdddddd'),LOWER('MSIE')));
  1.86


1-2. 중간 부분 검색

1) 대소문자 구별시

  DO BENCHMARK(1000000, BINARY 'dddMSIEdddddd' LIKE '%MSIE%');
  0.60

  DO BENCHMARK(1000000, INSTR('dddMSIEdddddd','MSIE'));
  0.44

2) 대소문자 구별없이

  DO BENCHMARK(1000000, 'dddMSIEdddddd' LIKE '%MSIE%');
  1.15

  DO BENCHMARK(1000000, INSTR(LOWER('dddMSIEdddddd'),LOWER('MSIE')));
  2.15


1-3. 끝 부분 검색

1) 대소문자 구별시

  DO BENCHMARK(1000000, BINARY 'dddMSIE' LIKE '%MSIE');
  0.56

  DO BENCHMARK(1000000, INSTR('dddMSIE','MSIE'));
  0.43

2) 대소문자 구별없이

  DO BENCHMARK(1000000, 'dddMSIE' LIKE '%MSIE');
  1.22

  DO BENCHMARK(1000000, INSTR(LOWER('dddMSIE'),LOWER('MSIE')));
  1.77


2. 한글 검색어 테스트

2-1. 앞부분 검색

1) 대소문자 구별시

  DO BENCHMARK(10000000, BINARY '한글 테스트' LIKE '한글%');
  Query OK, 0 rows affected (4.70 sec)

  DO BENCHMARK(10000000, INSTR('한글 테스트','한글'));
  Query OK, 0 rows affected (2.73 sec)


2) 대소문자 구별없이

  DO BENCHMARK(10000000, '한글 테스트' LIKE '한글%');
  Query OK, 0 rows affected (6.60 sec)

  DO BENCHMARK(10000000, INSTR('한글 테스트',LOWER('한글')));

  Query OK, 0 rows affected (7.48 sec)

  DO BENCHMARK(10000000, INSTR(LOWER('한글 테스트'),'한글'));
  Query OK, 0 rows affected (12.23 sec)

  DO BENCHMARK(10000000, INSTR(LOWER('한글 테스트'),LOWER('한글')));

  Query OK, 0 rows affected (17.25 sec)


2-2. 중간 부분 검색

1) 대소문자 구별시

  DO BENCHMARK(10000000, BINARY '테스트 한글 테스트' LIKE '%한글%');
  Query OK, 0 rows affected (6.63 sec)

  DO BENCHMARK(10000000, INSTR('테스트 한글 테스트','한글'));
  Query OK, 0 rows affected (5.52 sec)


2) 대소문자 구별없이

  DO BENCHMARK(10000000, '테스트 한글 테스트' LIKE '%한글%');
  Query OK, 0 rows affected (19.50 sec)

  DO BENCHMARK(10000000, INSTR('테스트 한글 테스트',LOWER('한글')));

  Query OK, 0 rows affected (10.60 sec)

  DO BENCHMARK(10000000, INSTR(LOWER('테스트 한글 테스트'),'한글'));
  Query OK, 0 rows affected (18.39 sec)

  DO BENCHMARK(10000000, INSTR(LOWER('테스트 한글 테스트'),LOWER('한글')));

  Query OK, 0 rows affected (23.25 sec)


2-3. 끝 부분 검색

1) 대소문자 구별시

  DO BENCHMARK(10000000, BINARY '테스트 한글' LIKE '%한글');
  Query OK, 0 rows affected (6.40 sec)

  DO BENCHMARK(10000000, INSTR('테스트 한글','한글'));
  Query OK, 0 rows affected (5.51 sec)


2) 대소문자 구별없이

  DO BENCHMARK(10000000, '테스트 한글' LIKE '%한글');
  Query OK, 0 rows affected (19.51 sec)

  DO BENCHMARK(10000000, INSTR('테스트 한글',LOWER('한글')));

  Query OK, 0 rows affected (10.60 sec)

  DO BENCHMARK(10000000, INSTR(LOWER('테스트 한글'),'한글'));
  Query OK, 0 rows affected (15.39 sec)

  DO BENCHMARK(10000000, INSTR(LOWER('테스트 한글'),LOWER('한글')));

  Query OK, 0 rows affected (20.32 sec)


3. 결과 비교(표)

각 5번 테스트 최상,최하 버리고 중간값 선택

3-1. 영문 검색어 결과

<FONT FACE='굴림체'>
+-----------+----------+-------------------+-------------------+--------------------
+
|           |          | 대소문자 구별 (O) | 대소문자 구별 (X) |                   
|
|   구 분   |  테스트  |---------+---------+---------+---------|       비고        
|
|           |          |   LIKE  | INSTR() |   LIKE  | INSTR() |                   
|
|-----------+----------+---------+---------+---------+---------+--------------------
|
| 앞부분검색| 1,000,000|   0.47  |   0.27  |   0.66  |   1.86  |                   
|
|           |10,000,000|   4.69  |   2.72  |   6.55  |  18.58  |                   
|
|-----------+----------+---------+---------+---------+---------+--------------------
|
|  중간 부분| 1,000,000|   0.60  |   0.44  |   1.15  |   2.15  |                   
|
|           |10,000,000|   5.90  |   4.38  |  11.43  |  21.66  |                   
|
|           |10,000,000|   8.38  |  18.65  |  37.46  |  53.59  | 51 bytes          
|
|-----------+----------+---------+---------+---------+---------+--------------------
|
| 뒷부분검색| 1,000,000|   0.56  |   0.43  |   1.22  |   1.77  |                   
|
|           |10,000,000|   5.65  |   4.35  |  11.08  |  17.53  |                   
|
|-----------+----------+---------+---------+---------+---------+--------------------
|
|       결과           |  winner |         |  winner |         |                   
|
+----------------------+---------+---------+---------+---------+--------------------
+
</FONT>
*주) 단위 초(seconds), 값이 작을수록 우세

영문 검색은 대소문자를 구별하는 경우에 최단 시간이 걸림.

대소문자를 구별하는 검색에서는 검색할 데이터 분포가 중요한데,
앞부분 검색에서는 절대적(길이에 상관없이)으로 INSTR() 함수가 빠르지만,
나머지는 비슷하거나 BINARY ... LIKE 연산이 월등함.
즉,
검색 대상 길이가 길어지고 뒤쪽으로 검색할 수록 확실히 BINARY ... LIKE 연산이 더
빠름.

대소문자를 구별하지 않을 경우에서는,
모든 검색에서 LIKE 연산이 약 1.5 배 이상 우세함.

최악의 경우는 INSTR(LOWER(...),LOWER(...)) 로써 이것은 LIKE 연산보다
절대적으로 느림.

웹 게시판과 같은 검색에서는, 대부분 대소문자를 구별하지 않고 검색하는
경우가 많으므로 영문 검색은 LIKE 연산이 더 유리함.


3-2. 한글 검색어 결과

<FONT FACE='굴림체'>
+-----------+----------+-------------------+----------------------------------------
+
|           |          | 대소문자 구별 (O) |           대소문자 구별 (X)           
|
|   구 분   |  테스트 
|---------+---------+---------+---------+---------+----------|
|           |          |   LIKE  | INSTR() |   LIKE 
|INSTR(,L)|INSTR(L,)|INSTR(L,L)|
|-----------+----------+---------+---------+---------+---------+---------+----------
|
| 앞부분검색|10,000,000|
   4.70  |   2.73  |   6.60  |   7.48  |  12.23  |   17.25  |
|-----------+----------+---------+---------+---------+---------+---------+----------
|
|  중간 부분|10,000,000|   6.63  |   5.52  |  19.50  |  10.60  |  18.39  |   23.25 
|
|           |10,000,000|  21.40  |  29.62  |  95.39  |  35.19  |  66.47  |   71.71 
|
|-----------+----------+---------+---------+---------+---------+---------+----------
|
| 뒷부분검색|10,000,000|
   6.40  |   5.51  |  19.51  |  10.60  |  15.39  |   20.32  |
|-----------+----------+---------+---------+---------+---------+---------+----------
|
|       결과           |  winner |         |         |(winnner)|         |         
|
+----------------------+---------+---------+---------+---------+---------+----------
+
</FONT>
*주) 단위 초(seconds), 값이 작을수록 우세

한글은 외관적으로 대소문자를 구별하지는 않지만, MySQL 의 내부적 연산에서,
대소문자를 구별하도록 실행할 경우, 모든 면에서 항상 우세함.
(*** 이것은 '한글'뿐만 아니라 '숫자' 자료형의 경우도 그대로 적용됨 ***)

일례로, 앞의 표의 '중간 부분' 검색에서 BINARRY ... LIKE 는 LIKE 보다
약 3 배 이상 빠르다는 것을 알 수 있고 INSTR() 함수 역시 마찬가지임.

영문검색과 마찬가지로 앞부분 검색을 제외하고, 검색 대상 길이가 길어지고
뒤쪽으로 검색할 수록 확실히 BINARY ... LIKE 연산이 더 빠름.

역시 최악의 경우는 최악의 경우는 INSET(LOWER(...),LOWER(...)) 임.


4. 결론


앞의 검색 테스트와 그 결과에서 알 수 있듯이, LIKE 연산이 대부분
유리하지만, LIKE 연산이 더 유리한가 아니면 INSTR() 연산이 더 유리한가에
대한 확답은 없습니다.

이것은, 검색할 타겟(대부분 columns)의 자료형이 어떤 문자열(문자셋)과
어떤 형태로 분포되어 있느냐에 따라서 속도차이가 날 뿐입니다.

그러나,

대부분 웹 게시판 같은 경우는 찾고자하는 단어 배열 형태가 무작위로 분포되어
있고, 또한 사용자 검색어 역시 무작위 임의의 단어있기 때문에 앞에서
테스트한 '중간부분 검색'이 실제 실무에서 적용가능한 방법임을
시사하고 있습니다.

검색할 column 역시, 대부분 32 또는 255 bytes(특이한 경우 제외) 이상이라는
점에서 다름과 같은 방법을 권장합니다.

<FONT FACE='굴림체'>
+----------------+------------------------+------------------------------+
| column 형태    | 권장 (32 bytes 이상)   | 예제                         |
|----------------+------------------------+------------------------------|
| 대문자만       | BINARY str LIKE substr | BINARY cols LIKE '%KWD%'     |
| 소문자만       | BINARY str LIKE substr | BINARY cols LIKE '%kwd%'     |
| 대+소문자      | str LIKE substr        | cols LIKE '%kWd%'            |
|----------------+------------------------+------------------------------|
| 한글만         | BINARY str LIKE substr | BINARY cols LIKE '%한글%'    |
| 한글+대문자    | BINARY str LIKE substr | BINARY cols LIKE '%한글KWD%' |
| 한글+소문자    | BINARY str LIKE substr | BINARY cols LIKE '%한글kwd%' |
| 한글+대+소문자 | str LIKE substr        | cols LIKE '%한글kWd%'        |
+----------------+------------------------+------------------------------+
</FONT>
*주) column length 가 255 bytes 이상, 중간 검색이라는 가정
*주) 'kwd' 는 사용자가 검색하는 임의의 단어

PHP 적용 예)

<?php
...
$kwd = '사용자 임의 검색어'; // add quoted string

$binary = ''; // 초기값
if(!preg_match('/[a-zA-Z]/',$kwd)) // 영문문자가 들어가 있는 않는 경우
{ $binary = 'BINARY'; }

$sql = "SELECT ... WHERE $binary board.text LIKE '%$kwd%' ...";
...
?>



만약, 검색할 column 이 32 bytes 이하이고, 또한 검색위치가 중간이 아닌
앞이거나 뒤쪽이라면, 앞의 결과표를 보고 적절한 방법을 선택해야 합니다.



5. 후기

없따앙....... 


- 테스트 버전 표시 누락 <--- 3.23.55

- str LIKE substr (OK)
- BINARY str LIKE substr (OK)
- str LIKE BINARY substr (누락)
- BINARY str LIKE BINARY substr (누락)

- INSTR(str, substr) (OK)
- INSTR(BINARY str, substr) (누락)
- INSTR(str, BINARY substr) (누락)
- INSTR(BINARY str, BINARY substr) (누락)

...
4.0.x 에서 `str LIKE substr' 연산이 상당한 진전이
있군요. 약 2~4배 이상 정도로 향상.

한글 검색 부분에서,
3.23.x 와 4.0.x 를 통틀어 아주 근소한 차이로(도토리 키재기)


1. INSTR(BINARY str, substr) <-- winner
2. INSTR(str, BINARY substr) <-- winner of the semifinals
3. INSTR(BINARY str, BINARY substr)
4. BINARY str LIKE substr
5. str LIKE BINARY substr
6. BINARY str LIKE BINARY substr
(여기까지가 거의 대동소이....)

7. str LIKE substr <--- 4.0.x
8. INSTR(str, substr) <--- 3.23.x, 4.0.x
9. str LIKE substr <--- 3.23.x

------

3.23.x

DO BENCHMARK(10000000, '앞부분 검색에서는 절대적(길이에 상관없이)으로 INSTR() 함수가
빠르지만' LIKE '%길이%');
Query OK, 0 rows affected (47.02 sec)

DO BENCHMARK(10000000, BINARY '앞부분 검색에서는 절대적(길이에 상관없이)으로 INSTR()
함수가 빠르지만' LIKE '%길이%');
Query OK, 0 rows affected (7.98 sec)

DO BENCHMARK(10000000, '앞부분 검색에서는 절대적(길이에 상관없이)으로 INSTR() 함수가
빠르지만' LIKE BINARY '%길이%');
Query OK, 0 rows affected (7.93 sec)

DO BENCHMARK(10000000, BINARY '앞부분 검색에서는 절대적(길이에 상관없이)으로 INSTR()
함수가 빠르지만' LIKE BINARY '%길이%');
Query OK, 0 rows affected (8.42 sec)


DO BENCHMARK(10000000, INSTR('앞부분 검색에서는 절대적(길이에 상관없이)으로 INSTR()
함수가 빠르지만','길이'));
Query OK, 0 rows affected (14.05 sec)

DO BENCHMARK(10000000, INSTR(BINARY '앞부분 검색에서는 절대적(길이에 상관없이)으로
INSTR() 함수가 빠르지만','길이'));
Query OK, 0 rows affected (6.75 sec)

DO BENCHMARK(10000000, INSTR('앞부분 검색에서는 절대적(길이에 상관없이)으로 INSTR()
함수가 빠르지만',BINARY '길이'));
Query OK, 0 rows affected (6.95 sec)

DO BENCHMARK(10000000, INSTR(BINARY '앞부분 검색에서는 절대적(길이에 상관없이)으로
INSTR() 함수가 빠르지만',bINARY '길이'));
Query OK, 0 rows affected (7.32 sec)

DO BENCHMARK(10000000, INSTR(LOWER('앞부분 검색에서는 절대적(길이에 상관없이)으로
INSTR() 함수가 빠르지만'),LOWER('길이')));

Query OK, 0 rows affected (54.91 sec)




4.0.9

DO BENCHMARK(10000000, '앞부분 검색에서는 절대적(길이에 상관없이)으로 INSTR() 함수가
빠르지만' LIKE '%길이%');
Query OK, 0 rows affected (11.40 sec)

DO BENCHMARK(10000000, BINARY '앞부분 검색에서는 절대적(길이에 상관없이)으로 INSTR()
함수가 빠르지만' LIKE '%길이%');
Query OK, 0 rows affected (7.64 sec)

DO BENCHMARK(10000000, '앞부분 검색에서는 절대적(길이에 상관없이)으로 INSTR() 함수가
빠르지만' LIKE BINARY '%길이%');
Query OK, 0 rows affected (7.76 sec)

DO BENCHMARK(10000000, BINARY '앞부분 검색에서는 절대적(길이에 상관없이)으로 INSTR()
함수가 빠르지만' LIKE BINARY '%길이%');
Query OK, 0 rows affected (9.26 sec)



DO BENCHMARK(10000000, INSTR('앞부분 검색에서는 절대적(길이에 상관없이)으로 INSTR()
함수가 빠르지만','길이'));
Query OK, 0 rows affected (14.01 sec)

DO BENCHMARK(10000000, INSTR(BINARY '앞부분 검색에서는 절대적(길이에 상관없이)으로
INSTR() 함수가 빠르지만','길이'));
Query OK, 0 rows affected (6.75 sec)

DO BENCHMARK(10000000, INSTR('앞부분 검색에서는 절대적(길이에 상관없이)으로 INSTR()
함수가 빠르지만',BINARY '길이'));
Query OK, 0 rows affected (6.95 sec)

DO BENCHMARK(10000000, INSTR(BINARY '앞부분 검색에서는 절대적(길이에 상관없이)으로
INSTR() 함수가 빠르지만',bINARY '길이'));
Query OK, 0 rows affected (7.32 sec)

DO BENCHMARK(10000000, INSTR(LOWER('앞부분 검색에서는 절대적(길이에 상관없이)으로
INSTR() 함수가 빠르지만'),LOWER('길이')));

Query OK, 0 rows affected (54.91 sec)

-----

EOF