14.8 String Functions and Operators

14.8.1 String Comparison Functions and Operators 14.8.2 Regular Expressions 14.8.3 Character Set and Collation of Function Results

Table 14.12 String Functions and Operators

Name	Description
ASCII()	맨 왼쪽 문자의 숫자 값을 반환
BIN()	숫자의 2진수 표현을 포함하는 문자열을 반환
BIT_LENGTH()	인자의 길이를 비트 단위로 반환
CHAR()	전달된 각 정수에 대한 문자를 반환
CHAR_LENGTH()	인자에 있는 문자 개수를 반환
CHARACTER_LENGTH()	CHAR_LENGTH()의 동의어
CONCAT()	연결된 문자열을 반환
CONCAT_WS()	구분자를 사용하여 연결한 결과를 반환
ELT()	인덱스 번호에 있는 문자열을 반환
EXPORT_SET()	값 비트에서 셋된 각 비트마다 on 문자열을, 셋되지 않은 각 비트마다 off 문자열을 반환하는 문자열을 반환
FIELD()	이후 인자들에서 첫 번째 인자의 인덱스(위치)
FIND_IN_SET()	두 번째 인자 안에서 첫 번째 인자의 인덱스(위치)
FORMAT()	지정된 소수 자릿수에 맞게 형식화된 숫자를 반환
FROM_BASE64()	base64로 인코딩된 문자열을 디코드하고 결과를 반환
HEX()	십진수 또는 문자열 값의 16진수 표현
INSERT()	지정된 위치에서 지정된 문자 수까지 부분 문자열을 삽입
INSTR()	부분 문자열이 처음 나타나는 인덱스를 반환
LCASE()	LOWER()의 동의어
LEFT()	지정된 개수만큼 가장 왼쪽 문자들을 반환
LENGTH()	문자열의 길이를 바이트 단위로 반환
LIKE	단순 패턴 매칭
LOAD_FILE()	지정된 파일을 읽음
LOCATE()	부분 문자열이 처음 나타나는 위치를 반환
LOWER()	인자를 소문자로 변환하여 반환
LPAD()	지정된 문자열으로 왼쪽을 채운 문자열 인자를 반환
LTRIM()	앞쪽 공백을 제거
MAKE_SET()	비트들에서 해당 비트가 셋된 문자열들로 구성된 쉼표로 구분된 문자열 집합을 반환
MATCH()	전문 검색 수행
MID()	지정된 위치에서 시작하는 부분 문자열을 반환
NOT LIKE	단순 패턴 매칭의 부정
NOT REGEXP	REGEXP의 부정
OCT()	숫자의 8진수 표현을 포함하는 문자열을 반환
OCTET_LENGTH()	LENGTH()의 동의어
ORD()	인자의 맨 왼쪽 문자에 대한 문자 코드를 반환
POSITION()	LOCATE()의 동의어
QUOTE()	SQL 문에서 사용하기 위해 인자를 이스케이프
REGEXP	문자열이 정규 표현식과 일치하는지 여부
REGEXP_INSTR()	정규 표현식과 일치하는 부분 문자열의 시작 인덱스
REGEXP_LIKE()	문자열이 정규 표현식과 일치하는지 여부
REGEXP_REPLACE()	정규 표현식과 일치하는 부분 문자열을 대체
REGEXP_SUBSTR()	정규 표현식과 일치하는 부분 문자열을 반환
REPEAT()	지정된 횟수만큼 문자열을 반복
REPLACE()	지정된 문자열이 나타나는 부분을 대체
REVERSE()	문자열 안의 문자 순서를 뒤집음
RIGHT()	지정된 개수만큼 가장 오른쪽 문자들을 반환
RLIKE	문자열이 정규 표현식과 일치하는지 여부
RPAD()	지정된 횟수만큼 문자열을 덧붙임
RTRIM()	뒤쪽 공백을 제거
SOUNDEX()	사운덱스 문자열을 반환
SOUNDS LIKE	발음을 비교
SPACE()	지정된 개수의 공백으로 이루어진 문자열을 반환
STRCMP()	두 문자열을 비교
SUBSTR()	지정된 대로 부분 문자열을 반환
SUBSTRING()	지정된 대로 부분 문자열을 반환
SUBSTRING_INDEX()	구분자가 지정된 횟수만큼 나타나기 전의 부분 문자열을 반환
TO_BASE64()	인자를 base-64 문자열으로 변환하여 반환
TRIM()	앞뒤 공백을 제거
UCASE()	UPPER()의 동의어
UNHEX()	숫자의 16진수 표현을 포함하는 문자열을 반환
UPPER()	대문자로 변환
WEIGHT_STRING()	문자열에 대한 weight 문자열을 반환

Name	Description

문자열 값을 반환하는 함수는 결과의 길이가 max_allowed_packet 시스템 변수 값보다 크면 NULL을 반환합니다. Section 7.1.1, “Configuring the Server”를 참조하십시오.

문자열 위치에 대해 동작하는 함수에서, 첫 번째 위치는 1번으로 번호가 매겨집니다.

길이 인자를 받는 함수에서, 정수가 아닌 인자는 가장 가까운 정수로 반올림됩니다.

• ASCII(str)

문자열 str 의 맨 왼쪽 문자의 숫자 값을 반환합니다. str 이 빈 문자열이면 0을 반환합니다. str 이 NULL이면 NULL을 반환합니다. ASCII()는 8비트 문자에 대해 동작합니다.

1mysql> SELECT ASCII('2');
2          -> 50
3mysql> SELECT ASCII(2);
4          -> 50
5mysql> SELECT ASCII('dx');
6          -> 100

ORD() 함수도 참조하십시오.

• BIN(N)

N 의 2진 값에 대한 문자열 표현을 반환합니다. 여기서 N 은 longlong (BIGINT) 숫자입니다. 이는 CONV(N,10,2)와 동일합니다. N 이 NULL이면 NULL을 반환합니다.

1mysql> SELECT BIN(12);
2          -> '1100'

• BIT_LENGTH(str)

문자열 str 의 길이를 비트 단위로 반환합니다. str 이 NULL이면 NULL을 반환합니다.

1mysql> SELECT BIT_LENGTH('text');
2          -> 32

• CHAR(N,... [USING charset_name])

CHAR()는 각 인자 N 을 정수로 해석하고, 그 정수의 코드 값으로 주어진 문자들로 구성된 문자열을 반환합니다. NULL 값은 건너뜁니다.

1mysql> SELECT CHAR(77,121,83,81,'76');
2+--------------------------------------------------+
3| CHAR(77,121,83,81,'76')                          |
4+--------------------------------------------------+
5| 0x4D7953514C                                     |
6+--------------------------------------------------+
71 row in set (0.00 sec)
8
9mysql> SELECT CHAR(77,77.3,'77.3');
10+--------------------------------------------+
11| CHAR(77,77.3,'77.3')                       |
12+--------------------------------------------+
13| 0x4D4D4D                                   |
14+--------------------------------------------+
151 row in set (0.00 sec)

기본적으로, CHAR()는 바이너리 문자열을 반환합니다. 지정된 문자 집합의 문자열을 생성하려면, 선택적인 USING 절을 사용하십시오:

1mysql> SELECT CHAR(77,121,83,81,'76' USING utf8mb4);
2+---------------------------------------+
3| CHAR(77,121,83,81,'76' USING utf8mb4) |
4+---------------------------------------+
5| MySQL                                 |
6+---------------------------------------+
71 row in set (0.00 sec)
8
9mysql> SELECT CHAR(77,77.3,'77.3' USING utf8mb4);
10+------------------------------------+
11| CHAR(77,77.3,'77.3' USING utf8mb4) |
12+------------------------------------+
13| MMM                                |
14+------------------------------------+
151 row in set, 1 warning (0.00 sec)
16
17mysql> SHOW WARNINGS;
18+---------+------+-------------------------------------------+
19| Level   | Code | Message                                   |
20+---------+------+-------------------------------------------+
21| Warning | 1292 | Truncated incorrect INTEGER value: '77.3' |
22+---------+------+-------------------------------------------+
231 row in set (0.00 sec)

USING 이 주어지고 결과 문자열이 지정된 문자 집합에 대해 유효하지 않으면, 경고가 발생합니다. 또한 strict SQL 모드가 활성화되어 있으면, CHAR()의 결과는 NULL이 됩니다.

CHAR()가 mysql 클라이언트 내에서 호출되면, 바이너리 문자열은 --binary-as-hex의 값에 따라 16진수 표기법으로 표시됩니다. 이 옵션에 대한 자세한 내용은 Section 6.5.1, “mysql — The MySQL Command-Line Client”를 참조하십시오.

CHAR()의 인자가 255보다 크면 여러 개의 결과 바이트로 변환됩니다. 예를 들어, CHAR(256)은 CHAR(1,0)과 같고, CHAR(256*256)은 CHAR(1,0,0)과 같습니다:

1mysql> SELECT HEX(CHAR(1,0)), HEX(CHAR(256));
2+----------------+----------------+
3| HEX(CHAR(1,0)) | HEX(CHAR(256)) |
4+----------------+----------------+
5| 0100           | 0100           |
6+----------------+----------------+
71 row in set (0.00 sec)
8
9mysql> SELECT HEX(CHAR(1,0,0)), HEX(CHAR(256*256));
10+------------------+--------------------+
11| HEX(CHAR(1,0,0)) | HEX(CHAR(256*256)) |
12+------------------+--------------------+
13| 010000           | 010000             |
14+------------------+--------------------+
151 row in set (0.00 sec)

• CHAR_LENGTH(str)

문자열 str 의 길이를 코드 포인트 단위로 반환합니다. 멀티바이트 문자는 하나의 코드 포인트로 계산됩니다. 이는, 두 개의 3바이트 문자를 포함하는 문자열의 경우, LENGTH()는 6을 반환하는 반면, CHAR_LENGTH()는 다음과 같이 2를 반환함을 의미합니다:

1mysql> SET @dolphin:='海豚';
2Query OK, 0 rows affected (0.01 sec)
3
4mysql> SELECT LENGTH(@dolphin), CHAR_LENGTH(@dolphin);
5+------------------+-----------------------+
6| LENGTH(@dolphin) | CHAR_LENGTH(@dolphin) |
7+------------------+-----------------------+
8|                6 |                     2 |
9+------------------+-----------------------+
101 row in set (0.00 sec)

CHAR_LENGTH()는 str 이 NULL이면 NULL을 반환합니다.

• CHARACTER_LENGTH(str)

CHARACTER_LENGTH()는 CHAR_LENGTH()의 동의어입니다.

• CONCAT(str1,str2,...)

인자를 연결한 결과 문자열을 반환합니다. 인자는 하나 이상일 수 있습니다. 모든 인자가 논바이너리 문자열이면, 결과는 논바이너리 문자열입니다. 인자에 바이너리 문자열이 하나라도 포함되면 결과는 바이너리 문자열입니다. 숫자형 인자는 그에 상응하는 논바이너리 문자열 형식으로 변환됩니다.

CONCAT()는 어떤 인자든 NULL이면 NULL을 반환합니다.

1mysql> SELECT CONCAT('My', 'S', 'QL');
2          -> 'MySQL'
3mysql> SELECT CONCAT('My', NULL, 'QL');
4          -> NULL
5mysql> SELECT CONCAT(14.3);
6          -> '14.3'

따옴표로 둘러싸인 문자열의 경우, 문자열들을 서로 붙여서 배치하는 것으로 연결을 수행할 수 있습니다:

1mysql> SELECT 'My' 'S' 'QL';
2          -> 'MySQL'

CONCAT()가 mysql 클라이언트 내에서 호출되면, 바이너리 문자열 결과는 --binary-as-hex의 값에 따라 16진수 표기법으로 표시됩니다. 이 옵션에 대한 자세한 내용은 Section 6.5.1, “mysql — The MySQL Command-Line Client”를 참조하십시오.

• CONCAT_WS(separator,str1,str2,...)

CONCAT_WS()는 Concatenate With Separator의 약자이며, CONCAT()의 특수한 형태입니다. 첫 번째 인자는 나머지 인자들을 위한 구분자입니다. 구분자는 연결될 문자열들 사이에 추가됩니다. 구분자는 나머지 인자들과 마찬가지로 문자열일 수 있습니다. 구분자가 NULL이면 결과는 NULL입니다.

1mysql> SELECT CONCAT_WS(',', 'First name', 'Second name', 'Last Name');
2          -> 'First name,Second name,Last Name'
3mysql> SELECT CONCAT_WS(',', 'First name', NULL, 'Last Name');
4          -> 'First name,Last Name'

CONCAT_WS()는 빈 문자열은 건너뛰지 않습니다. 하지만, 구분자 인자 이후의 NULL 값들은 건너뜁니다.

• ELT(N,str1,str2,str3,...)

ELT()는 문자열 리스트에서 N 번째 요소를 반환합니다: N = 1이면 str1, N = 2이면 str2 등입니다. N 이 1보다 작거나, 인자 개수보다 크거나, NULL이면 NULL을 반환합니다. ELT()는 FIELD()의 쌍대 함수입니다.

1mysql> SELECT ELT(1, 'Aa', 'Bb', 'Cc', 'Dd');
2          -> 'Aa'
3mysql> SELECT ELT(4, 'Aa', 'Bb', 'Cc', 'Dd');
4          -> 'Dd'

• EXPORT_SET(bits,on,off[,separator[,number_of_bits]])

값 bits 에서 셋된 각 비트마다 on 문자열을, 셋되지 않은 각 비트마다 off 문자열을 갖도록 하는 문자열을 반환합니다. bits 의 비트들은 오른쪽에서 왼쪽으로(하위 비트에서 상위 비트로) 검사됩니다. 문자열들은 왼쪽에서 오른쪽으로 결과에 추가되며, 기본적으로 쉼표 문자 ,인 separator 문자열로 구분됩니다. 검사할 비트의 수는 number_of_bits 로 주어지며, 지정하지 않으면 기본값은 64입니다. number_of_bits 가 64보다 크면 묵시적으로 64로 잘립니다. 이는 부호 없는 정수로 취급되므로, 값이 −1이면 사실상 64와 같습니다.

1mysql> SELECT EXPORT_SET(5,'Y','N',',',4);
2          -> 'Y,N,Y,N'
3mysql> SELECT EXPORT_SET(6,'1','0',',',10);
4          -> '0,1,1,0,0,0,0,0,0,0'

• FIELD(str,str1,str2,str3,...)

str1, str2, str3, ... 리스트에서 str 의 인덱스(위치)를 반환합니다. str 이 발견되지 않으면 0을 반환합니다.

FIELD()의 모든 인자가 문자열이면, 모든 인자는 문자열로 비교됩니다. 모든 인자가 숫자이면 숫자로 비교됩니다. 그렇지 않으면, 인자들은 double로 비교됩니다.

str 이 NULL이면, NULL은 어떤 값과도 동등 비교에 실패하므로 반환 값은 0입니다. FIELD()는 ELT()의 쌍대 함수입니다.

1mysql> SELECT FIELD('Bb', 'Aa', 'Bb', 'Cc', 'Dd', 'Ff');
2          -> 2
3mysql> SELECT FIELD('Gg', 'Aa', 'Bb', 'Cc', 'Dd', 'Ff');
4          -> 0

• FIND_IN_SET(str,strlist)

문자열 str 이 N 개의 부분 문자열로 구성된 문자열 리스트 strlist 안에 있으면 1에서 N 사이의 값을 반환합니다. 문자열 리스트는 , 문자로 구분된 부분 문자열들로 구성된 문자열입니다. 첫 번째 인자가 상수 문자열이고 두 번째 인자가 SET 타입의 컬럼이면, FIND_IN_SET() 함수는 비트 연산을 사용하도록 최적화됩니다. str 이 strlist 에 없거나 strlist 가 빈 문자열이면 0을 반환합니다. 어느 한 인자가 NULL이면 NULL을 반환합니다. 첫 번째 인자에 쉼표(,) 문자가 포함되어 있으면 이 함수는 제대로 동작하지 않습니다.

1mysql> SELECT FIND_IN_SET('b','a,b,c,d');
2          -> 2

• FORMAT(X,D[,locale])

숫자 X 를 '#,###,###.##'와 같은 형식으로, D 자리 소수점 이하로 반올림하여 형식화하고 결과를 문자열로 반환합니다. D 가 0이면 결과에는 소수점이나 소수 부분이 없습니다. X 또는 D 가 NULL이면 NULL을 반환합니다.

선택적인 세 번째 매개변수를 사용하면 결과 숫자의 소수점, 천 단위 구분자, 구분자 간 그룹핑에 사용될 로케일을 지정할 수 있습니다. 허용되는 로케일 값은 lc_time_names 시스템 변수에 대한 유효 값과 동일합니다 (Section 12.16, “MySQL Server Locale Support” 참조). 로케일이 NULL이거나 지정되지 않으면 기본 로케일은 'en_US'입니다.

1mysql> SELECT FORMAT(12332.123456, 4);
2          -> '12,332.1235'
3mysql> SELECT FORMAT(12332.1,4);
4          -> '12,332.1000'
5mysql> SELECT FORMAT(12332.2,0);
6          -> '12,332'
7mysql> SELECT FORMAT(12332.2,2,'de_DE');
8          -> '12.332,20'

• FROM_BASE64(str)

TO_BASE64()가 사용하는 base-64 인코딩 규칙으로 인코딩된 문자열을 받아, 디코딩된 결과를 바이너리 문자열으로 반환합니다. 인자가 NULL이거나 유효한 base-64 문자열이 아니면 결과는 NULL입니다. TO_BASE64()의 설명을 참조하여 인코딩 및 디코딩 규칙의 세부 사항을 확인하십시오.

1mysql> SELECT TO_BASE64('abc'), FROM_BASE64(TO_BASE64('abc'));
2          -> 'JWJj', 'abc'

FROM_BASE64()가 mysql 클라이언트 내에서 호출되면, 바이너리 문자열은 16진수 표기법으로 표시됩니다. 이 동작을 비활성화하려면 mysql 클라이언트를 시작할 때 --binary-as-hex 값을 0으로 설정하십시오. 이 옵션에 대한 자세한 내용은 Section 6.5.1, “mysql — The MySQL Command-Line Client”를 참조하십시오.

• HEX(str), HEX(N)

문자열 인자 str 에 대해, HEX()는 str 의 각 문자의 각 바이트를 두 개의 16진수 숫자로 변환한 16진수 문자열 표현을 반환합니다. (따라서 멀티바이트 문자는 두 자리보다 많은 숫자가 됩니다.) 이 연산의 역연산은 UNHEX() 함수가 수행합니다.

숫자형 인자 N 에 대해, HEX()는 N 의 값을 longlong (BIGINT) 숫자로 처리한 16진수 문자열 표현을 반환합니다. 이는 CONV(N,10,16)과 동일합니다. 이 연산의 역연산은 CONV(HEX(N),16,10)이 수행합니다.

인자가 NULL이면 이 함수는 NULL을 반환합니다.

1mysql> SELECT X'616263', HEX('abc'), UNHEX(HEX('abc'));
2          -> 'abc', 616263, 'abc'
3mysql> SELECT HEX(255), CONV(HEX(255),16,10);
4          -> 'FF', 255

• INSERT(str,pos,len,newstr)

문자열 str 에서 위치 pos 에서 시작하여 길이 len 인 부분 문자열을 문자열 newstr 로 대체한 문자열을 반환합니다. pos 가 문자열 길이 범위 밖이면 원래 문자열을 반환합니다. len 이 문자열의 나머지 길이 범위 밖이면 위치 pos 부터 문자열의 나머지 전체를 대체합니다. 인자 중 하나라도 NULL이면 NULL을 반환합니다.

1mysql> SELECT INSERT('Quadratic', 3, 4, 'What');
2          -> 'QuWhattic'
3mysql> SELECT INSERT('Quadratic', -1, 4, 'What');
4          -> 'Quadratic'
5mysql> SELECT INSERT('Quadratic', 3, 100, 'What');
6          -> 'QuWhat'

이 함수는 멀티바이트 세이프입니다.

• INSTR(str,substr)

문자열 str 안에서 부분 문자열 substr 이 처음 나타나는 위치를 반환합니다. 이는 인자 순서만 반대인 두 인자 형태의 LOCATE()와 동일합니다.

1mysql> SELECT INSTR('foobarbar', 'bar');
2          -> 4
3mysql> SELECT INSTR('xbar', 'foobar');
4          -> 0

이 함수는 멀티바이트 세이프이며, 인자 중 하나라도 바이너리 문자열이면 대소문자를 구분합니다. 어느 인자라도 NULL이면 이 함수는 NULL을 반환합니다.

• LCASE(str)

LCASE()는 LOWER()의 동의어입니다.

뷰에서 사용된 LCASE()는 뷰 정의를 저장할 때 LOWER()로 다시 작성됩니다. (Bug #12844279)

• LEFT(str,len)

문자열 str 의 가장 왼쪽에서 len 개의 문자를 반환하거나, 어떤 인자라도 NULL이면 NULL을 반환합니다.

1mysql> SELECT LEFT('foobarbar', 5);
2          -> 'fooba'

이 함수는 멀티바이트 세이프입니다.

• LENGTH(str)

문자열 str 의 길이를 바이트 단위로 반환합니다. 멀티바이트 문자는 여러 바이트로 계산됩니다. 이는 다섯 개의 2바이트 문자를 포함하는 문자열의 경우, LENGTH()는 10을 반환하고, CHAR_LENGTH()는 5를 반환함을 의미합니다. str 이 NULL이면 NULL을 반환합니다.

1mysql> SELECT LENGTH('text');
2          -> 4

참고

Length() OpenGIS spatial 함수는 MySQL에서 ST_Length()라는 이름을 가집니다.

• LOAD_FILE(file_name)

파일을 읽고 파일 내용을 문자열로 반환합니다. 이 함수를 사용하려면 파일이 서버 호스트에 있어야 하고, 파일에 대한 전체 경로 이름을 지정해야 하며, FILE 권한이 있어야 합니다. 파일은 서버에서 읽을 수 있어야 하고 크기는 max_allowed_packet 바이트보다 작아야 합니다. secure_file_priv 시스템 변수가 비어 있지 않은 디렉터리 이름으로 설정된 경우, 로드할 파일은 해당 디렉터리 안에 있어야 합니다.

파일이 존재하지 않거나 위의 조건 중 하나라도 만족하지 못해 읽을 수 없으면, 함수는 NULL을 반환합니다.

character_set_filesystem 시스템 변수는 리터럴 문자열으로 주어진 파일 이름의 해석을 제어합니다.

1mysql> UPDATE t
2              SET blob_col=LOAD_FILE('/tmp/picture')
3              WHERE id=1;

• LOCATE(substr,str), LOCATE(substr,str,pos)

첫 번째 구문은 문자열 str 안에서 부분 문자열 substr 이 처음 나타나는 위치를 반환합니다. 두 번째 구문은 문자열 str 안에서 위치 pos 에서 시작하여 부분 문자열 substr 이 처음 나타나는 위치를 반환합니다. substr 이 str 안에 없으면 0을 반환합니다. 어느 인자라도 NULL이면 NULL을 반환합니다.

1mysql> SELECT LOCATE('bar', 'foobarbar');
2          -> 4
3mysql> SELECT LOCATE('xbar', 'foobar');
4          -> 0
5mysql> SELECT LOCATE('bar', 'foobarbar', 5);
6          -> 7

이 함수는 멀티바이트 세이프이며, 인자 중 하나라도 바이너리 문자열이면 대소문자를 구분합니다.

• LOWER(str)

현재 문자 집합 매핑에 따라 모든 문자를 소문자로 변환한 문자열 str 을 반환하거나, str 이 NULL이면 NULL을 반환합니다. 기본 문자 집합은 utf8mb4입니다.

1mysql> SELECT LOWER('QUADRATICALLY');
2          -> 'quadratically'

LOWER() 및 UPPER()는 바이너리 문자열 (BINARY, VARBINARY, BLOB)에 대해 적용해도 효과가 없습니다. 바이너리 문자열의 대소문자 변환을 수행하려면 먼저 문자열에 저장된 데이터에 적합한 문자 집합을 사용하여 논바이너리 문자열으로 변환하십시오:

1mysql> SET @str = BINARY 'New York';
2mysql> SELECT LOWER(@str), LOWER(CONVERT(@str USING utf8mb4));
3+-------------+------------------------------------+
4| LOWER(@str) | LOWER(CONVERT(@str USING utf8mb4)) |
5+-------------+------------------------------------+
6| New York    | new york                           |
7+-------------+------------------------------------+

유니코드 문자 집합의 콜레이션의 경우, LOWER() 및 UPPER()는 콜레이션 이름에 버전이 있으면 그 UCA(Unicode Collation Algorithm) 버전에 따라, 버전이 없으면 UCA 4.0.0에 따라 동작합니다. 예를 들어, utf8mb4_0900_ai_ci 와 utf8mb3_unicode_520_ci 는 각각 UCA 9.0.0 및 5.2.0에 따라 동작하는 반면, utf8mb3_unicode_ci 는 UCA 4.0.0에 따라 동작합니다. Section 12.10.1, “Unicode Character Sets”를 참조하십시오.

이 함수는 멀티바이트 세이프입니다.

뷰 내에서 사용된 LCASE()는 LOWER()로 다시 작성됩니다.

• LPAD(str,len,padstr)

문자열 str 을 문자열 padstr 로 왼쪽을 채워 길이가 len 인 문자열로 반환합니다. str 이 len 보다 길면 반환 값은 len 길이로 잘립니다.

1mysql> SELECT LPAD('hi',4,'??');
2          -> '??hi'
3mysql> SELECT LPAD('hi',1,'??');
4          -> 'h'

어느 인자라도 NULL이면 NULL을 반환합니다.

• LTRIM(str)

문자열 str 의 앞쪽 공백 문자들을 제거한 문자열을 반환합니다. str 이 NULL이면 NULL을 반환합니다.

1mysql> SELECT LTRIM('  barbar');
2          -> 'barbar'

이 함수는 멀티바이트 세이프입니다.

• MAKE_SET(bits,str1,str2,...)

, 문자로 구분된 부분 문자열들로 구성된 문자열인 set 값을 반환합니다. 이 set 값은 bits 에서 해당 비트가 셋된 문자열들로 구성됩니다. str1 은 비트 0에, str2 는 비트 1에 해당하며, 그 이후도 같은 방식입니다. str1, str2, ... 에 있는 NULL 값은 결과에 추가하지 않습니다.

1mysql> SELECT MAKE_SET(1,'a','b','c');
2          -> 'a'
3mysql> SELECT MAKE_SET(1 | 4,'hello','nice','world');
4          -> 'hello,world'
5mysql> SELECT MAKE_SET(1 | 4,'hello','nice',NULL,'world');
6          -> 'hello'
7mysql> SELECT MAKE_SET(0,'a','b','c');
8          -> ''

• MID(str,pos), MID(str FROM pos), MID(str,pos,len), MID(str FROM pos FOR len)

MID(str,pos,len)는 SUBSTRING(str,pos,len)의 동의어입니다.

• OCT(N)

N 의 8진 값에 대한 문자열 표현을 반환합니다. 여기서 N 은 longlong (BIGINT) 숫자입니다. 이는 CONV(N,10,8)과 동일합니다. N 이 NULL이면 NULL을 반환합니다.

1mysql> SELECT OCT(12);
2          -> '14'

• OCTET_LENGTH(str)

OCTET_LENGTH()는 LENGTH()의 동의어입니다.

• ORD(str)

문자열 str 의 맨 왼쪽 문자가 멀티바이트 문자이면, 그 문자의 코드를 해당 바이트의 숫자 값으로부터 다음 공식을 사용하여 계산한 값을 반환합니다:

1    (1st byte code)
2+ (2nd byte code * 256)
3+ (3rd byte code * 256^2) ...

맨 왼쪽 문자가 멀티바이트 문자가 아니면, ORD()는 ASCII() 함수와 동일한 값을 반환합니다. str 이 NULL이면 함수는 NULL을 반환합니다.

1mysql> SELECT ORD('2');
2          -> 50

• POSITION(substr IN str)

POSITION(substr IN str)는 LOCATE(substr,str)의 동의어입니다.

• QUOTE(str)

문자열을 따옴표로 감싸 SQL 문에서 제대로 이스케이프된 데이터 값으로 사용할 수 있는 결과를 생성합니다. 반환되는 문자열은 작은따옴표로 둘러싸여 있으며, 백슬래시(\), 작은따옴표('), ASCII NUL, Control+Z의 각 인스턴스는 백슬래시가 앞에 붙습니다. 인자가 NULL이면 반환 값은 작은따옴표 없이 “NULL”이라는 단어입니다.

1mysql> SELECT QUOTE('Don\'t!');
2          -> 'Don\'t!'
3mysql> SELECT QUOTE(NULL);
4          -> NULL

비교를 위해, 리터럴 문자열과 C API 내에서의 quoting 규칙은 Section 11.1.1, “String Literals” 및 mysql_real_escape_string_quote()를 참조하십시오.

• REPEAT(str,count)

문자열 str 을 count 번 반복한 문자열을 반환합니다. count 가 1보다 작으면 빈 문자열을 반환합니다. str 이나 count 가 NULL이면 NULL을 반환합니다.

1mysql> SELECT REPEAT('MySQL', 3);
2          -> 'MySQLMySQLMySQL'

• REPLACE(str,from_str,to_str)

문자열 str 에서 문자열 from_str 이 나타나는 모든 부분을 문자열 to_str 로 대체한 문자열을 반환합니다. REPLACE()는 from_str 를 검색할 때 대소문자를 구분하는 매칭을 수행합니다.

1mysql> SELECT REPLACE('www.mysql.com', 'w', 'Ww');
2          -> 'WwWwWw.mysql.com'

이 함수는 멀티바이트 세이프입니다. 인자 중 하나라도 NULL이면 NULL을 반환합니다.

• REVERSE(str)

문자열 str 의 문자 순서를 역순으로 한 문자열을 반환하거나, str 이 NULL이면 NULL을 반환합니다.

1mysql> SELECT REVERSE('abc');
2          -> 'cba'

이 함수는 멀티바이트 세이프입니다.

• RIGHT(str,len)

문자열 str 의 가장 오른쪽에서 len 개의 문자를 반환하거나, 어떤 인자라도 NULL이면 NULL을 반환합니다.

1mysql> SELECT RIGHT('foobarbar', 4);
2          -> 'rbar'

이 함수는 멀티바이트 세이프입니다.

• RPAD(str,len,padstr)

문자열 str 을 문자열 padstr 로 오른쪽을 채워 길이가 len 인 문자열으로 반환합니다. str 이 len 보다 길면 반환 값은 len 길이로 잘립니다. str, padstr, len 중 하나라도 NULL이면 함수는 NULL을 반환합니다.

1mysql> SELECT RPAD('hi',5,'?');
2          -> 'hi???'
3mysql> SELECT RPAD('hi',1,'?');
4          -> 'h'

이 함수는 멀티바이트 세이프입니다.

• RTRIM(str)

문자열 str 의 뒤쪽 공백 문자들을 제거한 문자열을 반환합니다.

1mysql> SELECT RTRIM('barbar   ');
2          -> 'barbar'

이 함수는 멀티바이트 세이프이며, str 이 NULL이면 NULL을 반환합니다.

• SOUNDEX(str)

str 에서 사운덱스 문자열을 반환하거나, str 이 NULL이면 NULL을 반환합니다. 발음이 거의 비슷한 두 문자열은 동일한 사운덱스 문자열을 가져야 합니다. 표준 사운덱스 문자열은 네 글자 길이지만, SOUNDEX() 함수는 임의 길이의 문자열을 반환합니다. 표준 사운덱스 문자열을 얻으려면 결과에 SUBSTRING()을 사용할 수 있습니다. str 의 모든 비알파벳 문자는 무시됩니다. A-Z 범위 밖의 모든 국제 알파벳 문자는 모음으로 처리됩니다.

주의

SOUNDEX()를 사용할 때 다음 제한 사항을 알아야 합니다:

• 현재 구현된 이 함수는 영어로 된 문자열에 대해서만 잘 동작하도록 설계되었습니다. 다른 언어의 문자열은 신뢰할 수 있는 결과를 내지 않을 수 있습니다.

• 이 함수는 utf-8을 포함한 멀티바이트 문자 집합을 사용하는 문자열에 대해서는 일관된 결과를 제공한다고 보장되지 않습니다. 자세한 내용은 Bug #22638을 참조하십시오.

1mysql> SELECT SOUNDEX('Hello');
2        -> 'H400'
3mysql> SELECT SOUNDEX('Quadratically');
4        -> 'Q36324'

참고

이 함수는 원래 Soundex 알고리즘을 구현하며, D. Knuth가 설명한 더 일반적인 강화된 버전은 구현하지 않습니다. 차이점은 원래 버전은 먼저 모음을 버리고 나서 중복을 버리는 반면, 강화된 버전은 먼저 중복을 버리고 나서 모음을 버린다는 점입니다.

• expr1 SOUNDS LIKE expr2

이는 SOUNDEX(expr1) = SOUNDEX(expr2)와 동일합니다.

• SPACE(N)

N 개의 공백 문자로 구성된 문자열을 반환하거나, N 이 NULL이면 NULL을 반환합니다.

1mysql> SELECT SPACE(6);
2          -> '      '

• SUBSTR(str,pos), SUBSTR(str FROM pos), SUBSTR(str,pos,len), SUBSTR(str FROM pos FOR len)

SUBSTR()는 SUBSTRING()의 동의어입니다.

• SUBSTRING(str,pos), SUBSTRING(str FROM pos), SUBSTRING(str,pos,len), SUBSTRING(str FROM pos FOR len)

len 인자가 없는 형태는 문자열 str 에서 위치 pos 에서 시작하는 부분 문자열을 반환합니다. len 인자가 있는 형태는 문자열 str 에서 위치 pos 에서 시작하는 길이 len 의 부분 문자열을 반환합니다. FROM 을 사용하는 형태는 표준 SQL 문법입니다. pos 에 음수 값을 사용하는 것도 가능합니다. 이 경우 부분 문자열의 시작 위치는 문자열의 시작이 아니라 끝에서부터 pos 문자 떨어진 위치입니다. 이 함수의 모든 형태에서 pos 에 음수 값을 사용할 수 있습니다. pos 가 0이면 빈 문자열을 반환합니다.

SUBSTRING()의 모든 형태에서 부분 문자열을 추출할 기준이 되는 문자열의 첫 번째 문자의 위치는 1입니다.

1mysql> SELECT SUBSTRING('Quadratically',5);
2          -> 'ratically'
3mysql> SELECT SUBSTRING('foobarbar' FROM 4);
4          -> 'barbar'
5mysql> SELECT SUBSTRING('Quadratically',5,6);
6          -> 'ratica'
7mysql> SELECT SUBSTRING('Sakila', -3);
8          -> 'ila'
9mysql> SELECT SUBSTRING('Sakila', -5, 3);
10          -> 'aki'
11mysql> SELECT SUBSTRING('Sakila' FROM -4 FOR 2);
12          -> 'ki'

이 함수는 멀티바이트 세이프입니다. 인자 중 하나라도 NULL이면 NULL을 반환합니다.

len 이 1보다 작으면 결과는 빈 문자열입니다.

• SUBSTRING_INDEX(str,delim,count)

문자열 str 에서 구분자 delim 이 count 번 나타나기 전의 부분 문자열을 반환합니다. count 가 양수이면, (왼쪽에서 세었을 때) 마지막 구분자의 왼쪽에 있는 모든 것을 반환합니다. count 가 음수이면, (오른쪽에서 세었을 때) 마지막 구분자의 오른쪽에 있는 모든 것을 반환합니다. SUBSTRING_INDEX()는 delim 을 검색할 때 대소문자를 구분하는 매칭을 수행합니다.

1mysql> SELECT SUBSTRING_INDEX('www.mysql.com', '.', 2);
2          -> 'www.mysql'
3mysql> SELECT SUBSTRING_INDEX('www.mysql.com', '.', -2);
4          -> 'mysql.com'

이 함수는 멀티바이트 세이프입니다.

SUBSTRING_INDEX()는 인자 중 하나라도 NULL이면 NULL을 반환합니다.

• TO_BASE64(str)

문자열 인자를 base-64 인코딩 형식으로 변환하고, 커넥션 문자 집합 및 콜레이션을 갖는 문자열로 결과를 반환합니다. 인자가 문자열이 아니면, 변환이 수행되기 전에 문자열로 변환됩니다. 인자가 NULL이면 결과는 NULL입니다. base-64 인코딩 문자열은 FROM_BASE64() 함수를 사용하여 디코딩할 수 있습니다.

1mysql> SELECT TO_BASE64('abc'), FROM_BASE64(TO_BASE64('abc'));
2          -> 'JWJj', 'abc'

서로 다른 base-64 인코딩 방식들이 존재합니다. 다음은 TO_BASE64() 및 FROM_BASE64()가 사용하는 인코딩 및 디코딩 규칙입니다:

• alphabet 값 62에 대한 인코딩은 '+'입니다.

• alphabet 값 63에 대한 인코딩은 '/'입니다.

• 인코딩된 출력은 4개의 출력 가능한 문자 그룹으로 구성됩니다. 입력 데이터의 3 바이트마다 4개의 문자로 인코딩됩니다. 마지막 그룹이 완전하지 않으면 '=' 문자로 길이가 4가 되도록 패딩됩니다.

• 인코딩된 출력이 76문자를 넘으면, 긴 출력을 여러 줄로 나누기 위해 각 76문자마다 개행이 추가됩니다.

• 디코딩 시 newline, carriage return, tab, 공백은 인식하되 무시합니다.

• TRIM([{BOTH | LEADING | TRAILING} [remstr] FROM] str), TRIM([remstr FROM] str)

문자열 str 에서 모든 remstr prefix 또는 suffix를 제거한 문자열을 반환합니다. BOTH, LEADING, TRAILING 중 어느 specifier도 주어지지 않으면 BOTH가 가정됩니다. remstr 는 선택적이며, 지정하지 않으면 공백이 제거됩니다.

1mysql> SELECT TRIM('  bar   ');
2          -> 'bar'
3mysql> SELECT TRIM(LEADING 'x' FROM 'xxxbarxxx');
4          -> 'barxxx'
5mysql> SELECT TRIM(BOTH 'x' FROM 'xxxbarxxx');
6          -> 'bar'
7mysql> SELECT TRIM(TRAILING 'xyz' FROM 'barxxyz');
8          -> 'barx'

이 함수는 멀티바이트 세이프입니다. 인자 중 하나라도 NULL이면 NULL을 반환합니다.

• UCASE(str)

UCASE()는 UPPER()의 동의어입니다.

뷰 내에서 사용된 UCASE()는 UPPER()로 다시 작성됩니다.

• UNHEX(str)

문자열 인자 str 에 대해, UNHEX(str)는 인자 안의 각 문자 쌍을 16진수 숫자로 해석하고, 그 숫자가 나타내는 바이트로 변환합니다. 반환 값은 바이너리 문자열 입니다.

1mysql> SELECT UNHEX('4D7953514C');
2          -> 'MySQL'
3mysql> SELECT X'4D7953514C';
4          -> 'MySQL'
5mysql> SELECT UNHEX(HEX('string'));
6          -> 'string'
7mysql> SELECT HEX(UNHEX('1267'));
8          -> '1267'

인자 문자열의 문자들은 유효한 16진수 숫자여야 합니다: '0' .. '9', 'A' .. 'F', 'a' .. 'f'. 인자에 비 16진수 숫자가 하나라도 포함되어 있거나 인자 자체가 NULL이면 결과는 NULL입니다:

1mysql> SELECT UNHEX('GG');
2+-------------+
3| UNHEX('GG') |
4+-------------+
5| NULL        |
6+-------------+
7
8mysql> SELECT UNHEX(NULL);
9+-------------+
10| UNHEX(NULL) |
11+-------------+
12| NULL        |
13+-------------+

UNHEX()의 인자가 BINARY 컬럼인 경우에도 NULL 결과가 발생할 수 있습니다. 이는 값이 저장될 때 0x00 바이트로 패딩되지만 검색 시 이 바이트들이 제거되지 않기 때문입니다. 예를 들어, '41' 을 CHAR(3) 컬럼에 저장하면 '41 ' 로 저장되고, 검색 시에는 끝의 패딩 공백이 제거된 '41' 로 검색되므로, 해당 컬럼 값에 대한 UNHEX()는 X'41' 을 반환합니다. 반대로 '41' 을 BINARY(3) 컬럼에 저장하면 '41\0' 로 저장되고, 검색 시에도 끝의 패딩 0x00 바이트가 제거되지 않은 '41\0' 로 검색됩니다. '\0' 은 유효한 16진수 숫자가 아니므로 해당 컬럼 값에 대한 UNHEX()는 NULL을 반환합니다.

숫자형 인자 N 에 대해서는, HEX(N)의 역연산이 UNHEX()에 의해 수행되지 않습니다. 대신 CONV(HEX(N),16,10)을 사용하십시오. HEX()의 설명을 참조하십시오.

UNHEX()가 mysql 클라이언트 내에서 호출되면, 바이너리 문자열은 --binary-as-hex의 값에 따라 16진수 표기법으로 표시됩니다. 이 옵션에 대한 자세한 내용은 Section 6.5.1, “mysql — The MySQL Command-Line Client”를 참조하십시오.

• UPPER(str)

현재 문자 집합 매핑에 따라 모든 문자를 대문자로 변환한 문자열 str 을 반환하거나, str 이 NULL이면 NULL을 반환합니다. 기본 문자 집합은 utf8mb4입니다.

1mysql> SELECT UPPER('Hej');
2          -> 'HEJ'

UPPER()에 또한 적용되는 정보는 LOWER()의 설명을 참조하십시오. 여기에는 이들 함수가 효과가 없는 바이너리 문자열 (BINARY, VARBINARY, BLOB)의 대소문자 변환을 수행하는 방법과 유니코드 문자 집합에 대한 케이스 폴딩 정보가 포함되어 있습니다.

이 함수는 멀티바이트 세이프입니다.

뷰 내에서 사용된 UCASE()는 UPPER()로 다시 작성됩니다.

• WEIGHT_STRING(str [AS {CHAR|BINARY}(N)] [flags])

이 함수는 입력 문자열에 대한 weight 문자열을 반환합니다. 반환 값은 문자열의 비교 및 정렬 값을 나타내는 바이너리 문자열이거나, 인자가 NULL이면 NULL입니다. 다음과 같은 특성을 가집니다:

• 만약 WEIGHT_STRING(str1)

  WEIGHT_STRING(str2)이면, str1 = str2 (str1 과 str2 는 동일하다고 간주됨)

• 만약 WEIGHT_STRING(str1) < WEIGHT_STRING(str2)이면, str1 < str2 (str1 이 str2 보다 먼저 정렬됨)

WEIGHT_STRING()는 내부 사용을 위한 디버깅 함수입니다. 이 함수의 동작은 MySQL 버전 사이에서 예고 없이 변경될 수 있습니다. 특히 새로운 콜레이션을 추가하는 경우, 콜레이션을 테스트하고 디버깅하는 데 사용할 수 있습니다. Section 12.14, “Adding a Collation to a Character Set”를 참조하십시오.

다음 리스트는 인자를 간단히 요약한 것입니다. 보다 자세한 내용은 리스트 뒤의 설명에서 제공합니다.

• str: 입력 문자열 표현식.

• AS 절: 선택적; 입력 문자열을 지정된 타입과 길이로 캐스트.

• flags: 선택적; 사용되지 않음.

입력 문자열인 str 은 문자열 표현식입니다. 입력이 CHAR, VARCHAR, TEXT 값과 같은 논바이너리(문자) 문자열이면, 반환 값은 문자열에 대한 콜레이션 weight를 포함합니다. 입력이 BINARY, VARBINARY, BLOB 값과 같은 바이너리(바이트) 문자열이면, 반환 값은 입력과 동일합니다(바이너리 문자열에서 각 바이트의 weight는 바이트 값입니다). 입력이 NULL이면, WEIGHT_STRING()는 NULL을 반환합니다.

예:

1mysql> SET @s = _utf8mb4 'AB' COLLATE utf8mb4_0900_ai_ci;
2mysql> SELECT @s, HEX(@s), HEX(WEIGHT_STRING(@s));
3+------+---------+------------------------+
4| @s   | HEX(@s) | HEX(WEIGHT_STRING(@s)) |
5+------+---------+------------------------+
6| AB   | 4142    | 1C471C60               |
7+------+---------+------------------------+

1mysql> SET @s = _utf8mb4 'ab' COLLATE utf8mb4_0900_ai_ci;
2mysql> SELECT @s, HEX(@s), HEX(WEIGHT_STRING(@s));
3+------+---------+------------------------+
4| @s   | HEX(@s) | HEX(WEIGHT_STRING(@s)) |
5+------+---------+------------------------+
6| ab   | 6162    | 1C471C60               |
7+------+---------+------------------------+

1mysql> SET @s = CAST('AB' AS BINARY);
2mysql> SELECT @s, HEX(@s), HEX(WEIGHT_STRING(@s));
3+------+---------+------------------------+
4| @s   | HEX(@s) | HEX(WEIGHT_STRING(@s)) |
5+------+---------+------------------------+
6| AB   | 4142    | 4142                   |
7+------+---------+------------------------+

1mysql> SET @s = CAST('ab' AS BINARY);
2mysql> SELECT @s, HEX(@s), HEX(WEIGHT_STRING(@s));
3+------+---------+------------------------+
4| @s   | HEX(@s) | HEX(WEIGHT_STRING(@s)) |
5+------+---------+------------------------+
6| ab   | 6162    | 6162                   |
7+------+---------+------------------------+

위 예제들은 WEIGHT_STRING() 결과를 표시하기 위해 HEX()를 사용합니다. 결과는 바이너리 값이므로, 결과에 인쇄 불가능한 값이 포함된 경우 이를 인쇄 가능한 형식으로 표시하는 데 HEX()가 특히 유용할 수 있습니다:

1mysql> SET @s = CONVERT(X'C39F' USING utf8mb4) COLLATE utf8mb4_czech_ci;
2mysql> SELECT HEX(WEIGHT_STRING(@s));
3+------------------------+
4| HEX(WEIGHT_STRING(@s)) |
5+------------------------+
6| 0FEA0FEA               |
7+------------------------+

NULL 이 아닌 반환 값의 데이터 타입은 길이가 VARBINARY 최대 길이 이내이면 VARBINARY이고, 그렇지 않으면 데이터 타입은 BLOB입니다.

AS 절은 입력 문자열을 논바이너리 또는 바이너리 문자열으로 캐스트하고 지정된 길이로 강제할 수 있습니다:

• AS CHAR(N) 은 문자열을 논바이너리 문자열으로 캐스트하고 오른쪽에 공백을 패딩하여 길이가 N 인 문자가 되게 합니다. N 은 최소 1이어야 합니다. N 이 입력 문자열의 길이보다 작으면 문자열은 N 개의 문자로 잘립니다. 잘림에 대한 경고는 발생하지 않습니다.

• AS BINARY(N) 은 유사하지만 문자열을 바이너리 문자열으로 캐스트하고, N 은 문자가 아니라 바이트 단위로 측정되며, 패딩에 공백 대신 0x00 바이트가 사용됩니다.

1mysql> SET NAMES 'latin1';
2mysql> SELECT HEX(WEIGHT_STRING('ab' AS CHAR(4)));
3+-------------------------------------+
4| HEX(WEIGHT_STRING('ab' AS CHAR(4))) |
5+-------------------------------------+
6| 41422020                            |
7+-------------------------------------+
8mysql> SET NAMES 'utf8mb4';
9mysql> SELECT HEX(WEIGHT_STRING('ab' AS CHAR(4)));
10+-------------------------------------+
11| HEX(WEIGHT_STRING('ab' AS CHAR(4))) |
12+-------------------------------------+
13| 1C471C60                            |
14+-------------------------------------+

1mysql> SELECT HEX(WEIGHT_STRING('ab' AS BINARY(4)));
2+---------------------------------------+
3| HEX(WEIGHT_STRING('ab' AS BINARY(4))) |
4+---------------------------------------+
5| 61620000                              |
6+---------------------------------------+

flags 절은 현재 사용되지 않습니다.

WEIGHT_STRING()가 mysql 클라이언트 내에서 호출되면, 바이너리 문자열은 --binary-as-hex의 값에 따라 16진수 표기법으로 표시됩니다. 이 옵션에 대한 자세한 내용은 Section 6.5.1, “mysql — The MySQL Command-Line Client”를 참조하십시오.