MySQL5.6 문자열 함수

12.5 문자열 함수

12.5.1 문자열 비교 함수
12.5.2 정규 표현식

표 12.7 문자열 연산자

이름	설명
`ASCII ()`	왼쪽 문자의 숫자를 반환합니다
`BIN ()`	숫자 이진 표현을 포함한 캐릭터 라인을 돌려줍니다
`BIT_LENGTH ()`	비트 단위로 인수의 길이를 돌려줍니다
`CHAR_LENGTH ()`	인수의 문자 수를 반환합니다
`CHAR ()`	전달 된 각 정수의 문자를 반환합니다
`CHARACTER_LENGTH ()`	CHAR_LENGTH ()의 동의어입니다
`CONCAT_WS ()`	연결된 것을 분리기 함께 반환합니다
`CONCAT ()`	연결된 문자열을 반환합니다
`ELT ()`	인덱스 위치의 문자열을 반환합니다
`EXPORT_SET ()`	값 bits의 각 비트가 설정되어 있으면 on 문자열을 검색하고 각 비트가 설정되어 있지 않은 경우에는 off 문자열을 검색하도록 문자열을 반환합니다
`FIELD ()`	후속 인수에서 제 1 인수의 인덱스 (위치)를 돌려줍니다
`FIND_IN_SET ()`	제 2 인자에서 1 인자의 인덱스를 돌려줍니다
`FORMAT ()`	지정된 소수 자릿수로 서식이 지정된 숫자를 반환합니다
`FROM_BASE64 ()`	base 64 문자열로 디코딩하고 결과를 반환합니다
`HEX ()`	10 진수 또는 문자열 값의 16 진수 표현을 돌려줍니다
`INSERT ()`	부분 문자열을 지정된 위치에 지정된 문자 수만큼 삽입합니다
`INSTR ()`	부분 캐릭터 라인이 최초로 출현하는 위치의 인덱스를 돌려줍니다
`LCASE ()`	LOWER ()의 동의어입니다
`LEFT ()`	왼쪽부터 지정된 수의 문자를 반환합니다
`LENGTH ()`	문자열의 길이를 바이트 단위로 돌려줍니다
`LIKE`	단순한 패턴 일치
`LOAD_FILE ()`	지정된 파일을로드합니다
`LOCATE ()`	부분 문자열이 처음 나타나는 위치를 반환합니다
`LOWER ()`	인수를 소문자로 돌려줍니다
`LPAD ()`	지정된 문자열에서 왼쪽에서 패딩 문자열 인수를 돌려줍니다
`LTRIM ()`	선행 공백을 제거합니다
`MAKE_SET ()`	bits 셋에 대응하는 비트를 가지는 쉼표로 구분 된 문자열의 집합을 반환합니다
`MATCH`	전체 텍스트 검색을 실행합니다
`MID ()`	지정된 위치에서 시작하는 부분 문자열을 반환합니다
`NOT LIKE`	단순한 패턴 일치의 부정
`NOT REGEXP`	REGEXP의 부정
`OCT ()`	숫자의 8 진수 표현을 포함한 캐릭터 라인을 돌려줍니다
`OCTET_LENGTH ()`	LENGTH ()의 동의어입니다
`ORD ()`	인수의 가장 왼쪽 문자의 문자 코드를 반환합니다
`POSITION ()`	LOCATE ()의 동의어입니다
`QUOTE ()`	SQL 문에서 사용하기 위해 인수를 탈출
`REGEXP`	정규식을 사용하여 패턴 일치
`REPEAT ()`	문자열을 지정된 횟수만큼 반복합니다
`REPLACE ()`	지정된 문자열 런스를 바꿉니다
`REVERSE ()`	문자열의 문자를 역순으로 정렬합니다
`RIGHT ()`	오른쪽에서 지정된 수의 문자를 반환합니다
`RLIKE`	REGEXP의 동의어입니다
`RPAD ()`	지정된 횟수만큼 문자열을 추가합니다
`RTRIM ()`	후행 공백을 제거합니다
`SOUNDEX ()`	soundex 문자열을 반환합니다
`SOUNDS LIKE`	음성을 비교합니다
`SPACE ()`	지정된 수의 공백으로 구성된 문자열을 반환합니다
`STRCMP ()`	2 개의 문자열을 비교합니다
`SUBSTR ()`	지정된 부분 캐릭터 라인을 돌려줍니다
`SUBSTRING_INDEX ()`	문자열에서 구분자가 지정된 횟수 출현하기 전의 부분 캐릭터 라인을 돌려줍니다
`SUBSTRING ()`	지정된 부분 캐릭터 라인을 돌려줍니다
`TO_BASE64 ()`	base 64 문자열로 변환 된 인수를 돌려줍니다
`TRIM ()`	선행 및 후행 공백을 제거합니다
`UCASE ()`	UPPER ()의 동의어입니다
`UNHEX ()`	숫자의 16 진수 표현을 포함한 캐릭터 라인을 돌려줍니다
`UPPER ()`	대문자로 변환합니다
`WEIGHT_STRING ()`	문자열의 무게 문자열을 반환합니다

문자열 값 함수는 결과의 길이가 max_allowed_packet 시스템 변수의 값보다 길어지면 NULL 을 반환합니다. 섹션 8.11.2 "서버 파라미터의 튜닝」 을 참조하십시오.

문자열의 위치를 조작하는 함수는 첫 번째 위치에 숫자 1이 지정됩니다.

길이 인수를 취하는 함수는 정수가 아닌 인수는 가장 가까운 정수로 반올림됩니다.

ASCII ( str )

문자열 str 의 가장 왼쪽 문자의 숫자를 반환합니다. str 이 빈 문자열 인 경우 0 을 반환합니다. str 이 NULL 이면 NULL 을 반환합니다. ASCII() 는 8 비트 문자의 경우에 작동합니다.
```
 mysql> SELECT ASCII('2');
         -> 50
 mysql> SELECT ASCII(2);
         -> 50
 mysql> SELECT ASCII('dx');
         -> 100
```
ORD() 함수를 참조하십시오.
BIN ( N )

N 의 바이너리 값의 문자열 표현을 반환합니다. N 은 longlong ( BIGINT ) 숫자입니다. 이것은 CONV( N ,10,2) 과 동일합니다. N 이 NULL 이면 NULL 을 반환합니다.
```
 mysql> SELECT BIN(12);
         -> '1100'
```
BIT_LENGTH ( str )

문자열 str 의 길이를 비트 단위로 돌려줍니다.
```
 mysql> SELECT BIT_LENGTH('text');
         -> 32
```

CHAR ( N ... [USING charset_name )

CHAR() 는 각 N 인수를 정수로 해석하고 이러한 정수의 코드 값에 지정된 문자를 구성하는 문자열을 반환합니다. NULL 값은 생략됩니다.

 mysql> SELECT CHAR(77,121,83,81,'76');
         -> 'MySQL'
 mysql> SELECT CHAR(77,77.3,'77.3');
         -> 'MMM'

255보다 큰 CHAR() 인수는 여러 개의 결과 바이트로 변환됩니다. 예를 들어, CHAR(256) 는 CHAR(1,0) 에 동등하고, CHAR(256*256) 은 CHAR(1,0,0) 에 해당합니다.

mysql> SELECT HEX(CHAR(1,0)), HEX(CHAR(256));
+----------------+----------------+
| HEX(CHAR(1,0)) | HEX(CHAR(256)) |
+----------------+----------------+
| 0100           | 0100           |
+----------------+----------------+
mysql> SELECT HEX(CHAR(1,0,0)), HEX(CHAR(256*256));
+------------------+--------------------+
| HEX(CHAR(1,0,0)) | HEX(CHAR(256*256)) |
+------------------+--------------------+
| 010000           | 010000             |
+------------------+--------------------+

기본적으로 CHAR() 는 이진 문자열을 반환합니다. 지정된 문자 세트로 문자열을 생성하려면 옵션 USING 절을 사용합니다.

mysql> SELECT CHARSET(CHAR(X'65')), CHARSET(CHAR(X'65' USING utf8));
+----------------------+---------------------------------+
| CHARSET(CHAR(X'65')) | CHARSET(CHAR(X'65' USING utf8)) |
+----------------------+---------------------------------+
| binary               | utf8                            |
+----------------------+---------------------------------+

USING 이 지정된 결과 문자열이 지정된 문자 세트에 부정한 경우 경고가 발행됩니다. 또한 엄격한 SQL 모드가 활성화되어있는 경우, CHAR() 의 결과는 NULL 이됩니다.

CHAR_LENGTH ( str )

문자로 측정 된 문자열 str 의 길이를 반환합니다. 멀티 바이트 문자는 단일 문자로 계산됩니다. 즉, 5 개의 2 바이트 문자가 포함 된 문자열은 LENGTH() 은 10 을 반환 CHAR_LENGTH() 는 5 를 반환합니다.
CHARACTER_LENGTH ( str )

CHARACTER_LENGTH() 는 CHAR_LENGTH() 의 동의어입니다.
CONCAT ( str1 , str2 , ...)

인수를 연결하여 생성 된 문자열을 반환합니다. 하나 이상의 인수를 가지는 경우가 있습니다. 모든 인수가 아닌 바이너리 문자열의 경우, 결과도 비 바이너리 문자열입니다. 인수에 이진 문자열이 포함 된 경우 결과는 이진 문자열입니다. 숫자 인수는 동일한 비 이진 문자열 형식으로 변환됩니다.

인수 중 하나 하나가 NULL 인 경우, CONCAT() 는 NULL 을 반환합니다.
```
 mysql> SELECT CONCAT('My', 'S', 'QL');
         -> 'MySQL'
 mysql> SELECT CONCAT('My', NULL, 'QL');
         -> NULL
 mysql> SELECT CONCAT(14.3);
         -> '14 .3 '
```
따옴표로 둘러싸인 문자열에서 문자열을 나란히 배치하여 연결이 실행됩니다.
```
 mysql> SELECT 'My' 'S' 'QL';
         -> 'MySQL'
```
CONCAT_WS ( separator , str1 , str2 , ...)

CONCAT_WS() 는 Concatenate With Separator (분리 문자를 사용하여 연결)를 나타내며, CONCAT() 의 특수한 형식입니다. 첫 번째 인수는 나머지 인수 구분자입니다. 구분자는 연결되는 스트링 사이에 추가됩니다. 구분 문자는 나머지 인수와 마찬가지로 문자열 수 있습니다. 단락 문자가 NULL 의 경우, 결과도 NULL 입니다.
```
 mysql> SELECT CONCAT_WS(',','First name','Second name','Last Name');
         -> 'First name, Second name, Last Name'
 mysql> SELECT CONCAT_WS(',','First name',NULL,'Last Name');
         -> 'First name, Last Name'
```
CONCAT_WS() 는 빈 문자열이 생략되지 않습니다. 그러나 구분자 인수 뒤의 NULL 값은 모두 무시됩니다.
ELT ( N , str1 , str2 , str3 , ...)

ELT() 는 문자열 목록의 N 번째 요소를 반환합니다. N = 1 의 경우 str1 , N = 2 의 경우는 str2 처럼 돌려줍니다. N 이 1 보다 작거나 인수 개수보다 큰 경우는 NULL 를 돌려줍니다. ELT() 는 FIELD() 의 보수입니다.
```
 mysql> SELECT ELT(1, 'ej', 'Heja', 'hej', 'foo');
         -> 'ej'
 mysql> SELECT ELT(4, 'ej', 'Heja', 'hej', 'foo');
         -> 'foo'
```
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과 동일합니다.
```
 mysql> SELECT EXPORT_SET(5,'Y','N',',',4);
         -> 'Y, N, Y, N'
 mysql> SELECT EXPORT_SET(6,'1','0',',',10);
         -> '0,1,1,0,0,0,0,0,0,0'
```
FIELD ( str , str1 , str2 , str3 , ...)

str1 , str2 , str3 , ... 리스트에서 str 의 인덱스 (위치)를 돌려줍니다. str 을 찾을 수없는 경우에는 0 을 반환합니다.

FIELD() 에 대한 모든 인수가 문자열의 경우 모든 인수가 문자열로 비교됩니다. 모든 인수가 숫자이면 숫자로 비교됩니다. 그렇지 않으면 인수가 배정 밀도로 비교됩니다.

NULL 은 어떤 값과 같음에도 실패하고 str 이 NULL 이면 반환 값이 0 입니다. FIELD() 는 ELT() 의 보수입니다.
```
 mysql> SELECT FIELD('ej', 'Hej', 'ej', 'Heja', 'hej', 'foo');
         -> 2
 mysql> SELECT FIELD('fo', 'Hej', 'ej', 'Heja', 'hej', 'foo');
         -> 0
```
FIND_IN_SET ( str , strlist )

문자열 str 이 N 부분 문자열로 구성된 문자열 목록 strlist 에있는 경우는 1부터 N 까지의 범위에서 값을 반환합니다. 문자열 목록은 " , "문자로 구분 된 부분 문자열로 구성된 문자열입니다. 첫 번째 인수는 상수 문자열에서 두 번째가 SET 형태의 컬럼의 경우, FIND_IN_SET() 함수는 비트 연산을 사용하는 데 최적화되어 있습니다. str 이 strlist 에 없거나 strlist 가 빈 문자열 인 경우 0 을 반환합니다. 인수 중 하나가 NULL 인 경우 NULL 을 반환합니다. 첫 번째 인수에 쉼표 ( " , ") 문자가 포함 된 경우이 함수가 제대로 작동하지 않습니다.
```
 mysql> SELECT FIND_IN_SET('b','a,b,c,d');
         -> 2
```
FORMAT ( X , D [, locale )

숫자 X 를 '#,###,###.##' 과 같은 형식으로 변환하고 소수점 D 정도 반올림하여 그 결과를 문자열로 반환합니다. D 가 0 의 경우 결과에 소수점 또는 소수 부분이 포함되지 않습니다.

세번째 매개 변수를 사용하면 결과 수의 소수점 3 자리 구분 기호 및 구분 기호 사이의 그룹화에 사용되는 로케일을 지정할 수 있습니다. 허용되는 로케일 값은 lc_time_names 시스템 변수의 유효한 값과 같습니다 ( 섹션 10.7 "MySQL Server의 로케일 지원" 을 참조하십시오). 로케일이 지정되지 않은 경우 기본값은 'en_US' 입니다.
```
 mysql> SELECT FORMAT(12332.123456, 4);
         -> '12, 332.1235 '
 mysql> SELECT FORMAT(12332.1,4);
         -> '12, 332.1000 '
 mysql> SELECT FORMAT(12332.2,0);
         -> '12, 332 '
 mysql> SELECT FORMAT(12332.2,2,'de_DE');
         -> '12 .332,20 '
```
FROM_BASE64 ( str )

TO_BASE64() 에서 사용되는 base-64로 인코딩 된 규칙으로 인코딩 된 문자열이 지정된 디코딩 된 결과를 바이너리 문자열로 반환합니다. 인수가 NULL 의 경우 또는 유효한 base-64 문자열이 아닌 경우는 결과가 NULL 입니다. 규칙 인코딩 및 디코딩에 대한 자세한 내용은 TO_BASE64() 의 설명을 참조하십시오.

이 함수는 MySQL 5.6.1에서 추가되었습니다.
```
 mysql> SELECT TO_BASE64('abc'), FROM_BASE64(TO_BASE64('abc'));
         -> 'JWJj', 'abc'
```
HEX( str ) , HEX( N )

캐릭터 라인의 인수 str 에서 HEX() 는 str 의 16 진수 문자열 표현을 반환합니다. str 내의 각 문자의 각 바이트는 2 개의 16 진수로 변환됩니다. (따라서, 멀티 바이트 문자는 2 자리보다 커집니다.)이 연산 역은 UNHEX() 함수에서 실행됩니다.

수치 인수 N 은 HEX() 는 longlong ( BIGINT ) 숫자로 처리되는 N 의 16 진수 문자열 표현을 반환합니다. 이것은 CONV( N ,10.16) 와 동등합니다. 이 연산의 반대는 CONV(HEX( N ),16,10) 에서 실행됩니다.
```
 mysql> SELECT 0x616263, HEX('abc'), UNHEX(HEX('abc'));
         -> 'abc'616263 'abc'
 mysql> SELECT HEX(255), CONV(HEX(255),16,10);
         -> 'FF'255
```
INSERT ( str , pos , len , newstr )

위치 pos 로 시작하는 부분 문자열과 문자열 newstr 로 치환 된 len 문자 길이 함께 문자열 str 을 반환합니다. pos 가 문자열의 길이에 맞지 않으면 원래의 문자열을 반환합니다. len 가 나머지 문자열의 길이에 맞지 않는 경우는 위치 pos 에서 나머지 문자열을 대체합니다. 인수 중 하나가 NULL 인 경우 NULL 을 반환합니다.
```
 mysql> SELECT INSERT('Quadratic', 3, 4, 'What');
         -> 'QuWhattic'
 mysql> SELECT INSERT('Quadratic', -1, 4, 'What');
         -> 'Quadratic'
 mysql> SELECT INSERT('Quadratic', 3, 100, 'What');
         -> 'QuWhat'
```
이 함수는 다중 바이트로부터 안전합니다.
INSTR ( str , substr )

문자열 str 에서 서브 스트링 substr 가 처음 나타나는 위치를 반환합니다. 이것은 인수의 순서가 반대로되는 점을 제외하고 2 개의 인수 형식 LOCATE() 와 동일합니다.
```
 mysql> SELECT INSTR('foobarbar', 'bar');
         -> 4
 mysql> SELECT INSTR('xbar', 'foobar');
         -> 0
```
이 함수는 다중 바이트로부터 안전하며 하나 이상의 인수가 바이너리 문자열 인 경우에만 대소 문자를 구분합니다.
LCASE ( str )

LCASE() 는 LOWER() 의 동의어입니다.
LEFT ( str , len )

문자열 str 에서 왼쪽의 len 문자를 리턴 인수가 NULL 이면 NULL 을 반환합니다.
```
 mysql> SELECT LEFT('foobarbar', 5);
         -> 'fooba'
```
이 함수는 다중 바이트로부터 안전합니다.
LENGTH ( str )

바이트로 측정 된 문자열 str 의 길이를 반환합니다. 멀티 바이트 문자는 여러 바이트로 계산됩니다. 즉, 5 개의 2 바이트 문자가 포함 된 문자열은 LENGTH() 은 10 을 반환 CHAR_LENGTH() 는 5 를 반환합니다.
```
 mysql> SELECT LENGTH('text');
         -> 4
```
참고
Length() OpenGIS 공간 함수는 MySQL에서 GLength() 라는 이름입니다.
LOAD_FILE ( file_name )

파일을 읽고 파일의 내용을 문자열로 반환합니다. 이 함수를 사용하려면 파일이 서버 호스트에 배치되어 있어야 파일의 전체 경로 이름을 지정하고 FILE 권한을 가지고 있어야합니다. 파일은 모든 사용자에게 읽기 권한, max_allowed_packet 바이트보다 작은 크기 일 필요가 있습니다. secure_file_priv 시스템 변수가 비어 있지 않은 디렉토리 이름에 설정되어있는 경우는 그 디렉토리에로드 할 파일이 배치되어 있어야합니다.

파일이 존재하지 않거나 위의 조건이 충족되지 않기 때문에 파일을 읽을 수없는 경우,이 함수는 NULL 을 반환합니다.

character_set_filesystem 시스템 변수는 리터럴 문자열로 지정되는 파일 이름의 해석이 제어됩니다.
```
 mysql> UPDATE t
           SET blob_col = LOAD_FILE ( '/ tmp / picture')
          
 WHERE id = 1; 
```
LOCATE( substr , str ) , LOCATE( substr , str , pos )

첫 번째 구문은 문자열 str 에서 서브 스트링 substr 가 처음 나타나는 위치를 반환합니다. 두 번째 구문은 문자열 str 내의 위치 pos 이후에서 부분 문자열 substr 가 처음 나타나는 위치를 반환합니다. str 에서 substr 이없는 경우는 0 을 돌려줍니다.
```
 mysql> SELECT LOCATE('bar', 'foobarbar');
         -> 4
 mysql> SELECT LOCATE('xbar', 'foobar');
         -> 0
 mysql> SELECT LOCATE('bar', 'foobarbar', 5);
         -> 7
```
이 함수는 다중 바이트로부터 안전하며 하나 이상의 인수가 바이너리 문자열 인 경우에만 대소 문자를 구분합니다.
LOWER ( str )

현재 문자 집합 매핑에 따라 모든 문자를 소문자로 변경된 문자열 str 을 반환합니다. 디폴트는 latin1 (cp1252 서유럽)입니다.
```
 mysql> SELECT LOWER('QUADRATICALLY');
         -> 'quadratically'
```
LOWER() (와 UPPER() )를 바이너리 문자열 ( BINARY , VARBINARY , BLOB )에 적용해도 아무런 효과가 없습니다. 대 / 소문자 변환을 실행하려면 이진 문자열을 비 이진 문자열로 변환합니다.
```
 mysql> SET @str = BINARY 'New York';
 mysql> SELECT LOWER(@str), LOWER(CONVERT(@str USING latin1));
 + ------------- + ----------------------------------- +
 | LOWER (@str) | LOWER (CONVERT (@str USING latin1)) |
 + ------------- + ----------------------------------- +
 | New York | new york |
 + ------------- + ----------------------------------- +
```
Unicode 캐릭터 세트의 경우, xxx _unicode_520_ci 데이터 정렬 및 그에서 파생 된 언어 별 데이터 정렬은 LOWER() 및 UPPER() 는 Unicode 데이터 정렬 알고리즘 (UCA) 5.2.0에 따라 작동합니다. 기타 Unicode 조합은 LOWER() 및 UPPER() 는 Unicode 매칭 알고리즘 (UCA) 4.0.0에 따라 작동합니다. 섹션 10.1.14.1 "Unicode 캐릭터 세트」 를 참조하십시오.

이 함수는 다중 바이트로부터 안전합니다.
LPAD ( str , len , padstr )

len 문자의 길이가되도록 문자열 padstr 에서 왼쪽으로 패딩 된 문자열 str 을 반환합니다. str 이 len 보다 긴 경우 반환 값은 len 문자로 단축됩니다.
```
 mysql> SELECT LPAD('hi',4,'??');
         -> '?? hi'
 mysql> SELECT LPAD('hi',1,'??');
         -> 'h'
```
LTRIM ( str )

맨 앞의 공백이 제거 된 문자열 str 을 반환합니다.
```
 mysql> SELECT LTRIM(' barbar');
         -> 'barbar'
```
이 함수는 다중 바이트로부터 안전합니다.
MAKE_SET ( bits , str1 , str2 , ...)

bits 셋에 대응하는 비트를 가지는 문자열로 구성된 세트 값 ( " , "문자로 구분 된 문자열을 포함한 문자열)을 반환합니다. str1 은 비트 0에 대응 해, str2 는 비트 1에 해당하는 등입니다. str1 , str2 , ... 에있는 NULL 값은 결과에 추가되지 않습니다.
```
 mysql> SELECT MAKE_SET(1,'a','b','c');
         -> 'a'
 mysql> SELECT MAKE_SET(1 | 4,'hello','nice','world');
         -> 'hello, world'
 mysql> SELECT MAKE_SET(1 | 4,'hello','nice',NULL,'world');
         -> 'hello'
 mysql> SELECT MAKE_SET(0,'a','b','c');
         -> ''
```
MID ( str , pos , len )

MID( str , pos , len ) 은 SUBSTRING( str , pos , len ) 의 동의어입니다.
OCT ( N )

N 의 8 진수 문자열 표현을 반환합니다. N 은 longlong ( BIGINT ) 숫자입니다. 이것은 CONV( N ,10.8) 와 동등합니다. N 이 NULL 이면 NULL 을 반환합니다.
```
 mysql> SELECT OCT(12);
         -> '14'
```
OCTET_LENGTH ( str )

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

문자열 str 의 좌단의 문자가 멀티 바이트 문자 인 경우, 문자 코드를 반환합니다. 코드는 다음 계산식을 사용하여 그 구성 요소의 수치에서 계산됩니다.
```
   (1st byte code)
 + (2nd byte code * 256)
 + (3rd byte code * 256 ²⁾ ...
```
왼쪽의 문자를 멀티 바이트 문자가 아닌 경우는 ORD() 는 ASCII() 함수와 같은 값을 반환합니다.
```
 mysql> SELECT ORD('2');
         -> 50
```
POSITION ( substr IN str )

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

SQL 문에서 올바르게 이스케이프 된 데이터 값으로 사용할 수있는 결과를 생성하는 문자열을 따옴표로 묶습니다. 작은 따옴표로 둘러싸여 백 슬래시 뒤에 백 슬래시 ( " \ "), 작은 따옴표 ( ' ' '), ASCII NUL 및 Control-Z의 각 인스턴스가 계속 문자열이 반환됩니다. 인수가 NULL 의 경우 반환 값은 작은 따옴표로 묶여 있지 않은 단어 "NULL"입니다.
```
 mysql> SELECT QUOTE('Don\'t!');
         -> 'Don \'t! '
 mysql> SELECT QUOTE(NULL);
         -> NULL
```
비교하기 위해 섹션 9.1.1 "문자열 리터럴" 및 섹션 23.8.7.54 "mysql_real_escape_string ()" 에서 리터럴 문자열에 대한 인용 규칙과 C API의 인용 규칙을 참조하십시오.
REPEAT ( str , count )

count 회 반복 한 문자열 str 로 구성된 문자열을 반환합니다. count 가 1보다 작은 경우 빈 문자열을 반환합니다. str 또는 count 가 NULL 이면 NULL 을 반환합니다.
```
 mysql> SELECT REPEAT('MySQL', 3);
         -> 'MySQLMySQLMySQL'
```
REPLACE ( str , from_str , to_str )

문자열 from_str 의 모든 런스가 문자열 to_str 로 치환 된 문자열 str 을 반환합니다. REPLACE() 은 from_str 를 검색 할 때 대소 문자를 구별 일치를 수행합니다.
```
 mysql> SELECT REPLACE('www.mysql.com', 'w', 'Ww');
         -> 'WwWwWw.mysql.com'
```
이 함수는 다중 바이트로부터 안전합니다.
REVERSE ( str )

문자의 순서가 거꾸로 된 문자열 str 을 반환합니다.
```
 mysql> SELECT REVERSE('abc');
         -> 'cba'
```
이 함수는 다중 바이트로부터 안전합니다.
RIGHT ( str , len )

문자열 str 에서 오른쪽 len 문자를 리턴 인수가 NULL 이면 NULL 을 반환합니다.
```
 mysql> SELECT RIGHT('foobarbar', 4);
         -> 'rbar'
```
이 함수는 다중 바이트로부터 안전합니다.
RPAD ( str , len , padstr )

len 문자의 길이가되도록 문자열 padstr 에서 오른쪽으로 패딩 된 문자열 str 을 반환합니다. str 이 len 보다 긴 경우 반환 값은 len 문자로 단축됩니다.
```
 mysql> SELECT RPAD('hi',5,'?');
         -> 'hi ???'
 mysql> SELECT RPAD('hi',1,'?');
         -> 'h'
```
이 함수는 다중 바이트로부터 안전합니다.
RTRIM ( str )

말미의 공백이 제거 된 문자열 str 을 반환합니다.
```
 mysql> SELECT RTRIM('barbar ');
         -> 'barbar'
```
이 함수는 다중 바이트로부터 안전합니다.
SOUNDEX ( str )

str 에서 soundex 문자열을 반환합니다. 비슷한 발음의 두 문자열은 같은 soundex 캐릭터 라인을 가지는 것입니다. 표준의 soundex 문자열의 길이는 4 자이지만, SOUNDEX() 함수는 임의의 길이의 문자열을 반환합니다. 결과에서 SUBSTRING() 를 사용하면 표준 soundex 문자열을 얻을 수 있습니다. str 의 알파벳 이외의 문자는 모두 무시됩니다. A에서 Z까지의 범위를 벗어난 국제 알파벳 문자는 모두 모음으로 처리됩니다.
중요
SOUNDEX() 를 사용할 때 다음 제한 사항에 유의하십시오.
- 현재 구현되고있는이 함수는 문자열의 언어가 영어 인 경우에만 작동하도록 설계되어 있습니다. 다른 언어의 문자열은 신뢰할 수있는 결과가 생성되지 않을 수 있습니다.
- 이 함수는 문자열에서 멀티 바이트 문자 집합 ( utf-8 등)가 사용되는 경우, 일관된 결과가 생성되는 것을 보장하지 않습니다.
  
  향후 릴리스에서는 이러한 제한이 해제되기를 기대하고 있습니다. 자세한 내용은 Bug # 22638를 참조하십시오.
```
 mysql> SELECT SOUNDEX('Hello');
         -> 'H400'
 mysql> SELECT SOUNDEX('Quadratically');
         -> 'Q36324'
```
참고
이 함수는 원래의 Soundex 알고리즘이 구현되어 있습니다. 더 인기있는 확장 버전은 없습니다 (이 작성자도 D. Knuth입니다). 차이점으로는 원래의 버전에서는 우선 모음이 삭제 된 후 복제가 파괴되지만 확장 버전에서는 먼저 복제가 파기되고 나서 모음이 삭제됩니다.
expr1 SOUNDS LIKE expr2

이것은 SOUNDEX( expr1 ) = SOUNDEX( expr2 ) 와 동일합니다.
SPACE ( N )

N 공백 문자로 구성된 문자열을 반환합니다.
```
 mysql> SELECT SPACE(6);
         -> ''
```
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 인수없이 형식은 위치 pos 로 시작하는 문자열 str 에서 부분 문자열이 반환됩니다. len 인수를 붙인 형식은 위치 pos 로 시작하는 문자열 str 에서 서브 스트링 len 문자 길이가 반환됩니다. FROM 을 사용하는 형태는 표준 SQL 구문입니다. 또한 pos 에 음수 값을 사용할 수도 있습니다. 그 경우 부분 문자열의 시작은 문자열의 시작이 아니라 문자열의 끝에서 pos 문자입니다. 이 함수의 어떤 형태로도 pos 에 음수 값을 사용할 수 있습니다.

모든 형식의 SUBSTRING() 에서 부분 문자열 추출이 시작되는 문자열의 첫 번째 문자의 위치가 1 로 간주됩니다.
```
 mysql> SELECT SUBSTRING('Quadratically',5);
         -> 'ratically'
 mysql> SELECT SUBSTRING('foobarbar' FROM 4);
         -> 'barbar'
 mysql> SELECT SUBSTRING('Quadratically',5,6);
         -> 'ratica'
 mysql> SELECT SUBSTRING('Sakila', -3);
         -> 'ila'
 mysql> SELECT SUBSTRING('Sakila', -5, 3);
         -> 'aki'
 mysql> SELECT SUBSTRING('Sakila' FROM -4 FOR 2);
         -> 'ki'
```
이 함수는 다중 바이트로부터 안전합니다.

len 이 1보다 작 으면 결과가 빈 문자열입니다.
SUBSTRING_INDEX ( str , delim , count )

문자열 str 에서 구분 문자 delim 가 count 회 출현하기 전에 부분 문자열을 반환합니다. count 가 양수의 경우에는 (왼쪽부터 계산) 마지막 구분자의 왼쪽에있는 모두가 반환됩니다. count 가 음수 인 경우 (오른쪽부터 계산) 마지막 구분자의 오른쪽에있는이 반환됩니다. SUBSTRING_INDEX() 는 delim 를 검색 할 때 대소 문자를 구별 일치를 수행합니다.
```
 mysql> SELECT SUBSTRING_INDEX('www.mysql.com', '.', 2);
         -> 'www.mysql'
 mysql> SELECT SUBSTRING_INDEX('www.mysql.com', '.', -2);
         -> 'mysql.com'
```
이 함수는 다중 바이트로부터 안전합니다.
TO_BASE64 ( str )

캐릭터 라인의 인수를 base-64로 인코딩 된 형식으로 변환하고 그 결과를 연결 문자 셋과 콜레 션이 포함 된 문자열로 반환합니다. 인수가 문자열이 아닌 경우는 변환이 실행되기 전에 문자열로 변환됩니다. 인수가 NULL 이면 결과도 NULL 입니다. FROM_BASE64() 함수를 사용하면 base-64로 인코딩 된 문자열을 디코딩 할 수 있습니다.

이 함수는 MySQL 5.6.1에서 추가되었습니다.
```
 mysql> SELECT TO_BASE64('abc'), FROM_BASE64(TO_BASE64('abc'));
         -> 'JWJj', 'abc'
```
다양한 base-64 인코딩 방법이 존재합니다. 이들은 TO_BASE64() 및 FROM_BASE64() 에서 사용되는 인코딩 및 디코딩 규칙입니다.
- 알파벳 값 62 인코딩 '+' 입니다.
- 알파벳 값 63 인코딩은 '/' 입니다.
- 인코딩 된 출력은 출력 가능한 4 문자의 그룹으로 구성됩니다. 입력 데이터의 각 3 바이트는 4 문자를 사용하여 인코딩됩니다. 마지막 그룹이 불완전한 경우는 길이가 4가 될 때까지 '=' 문자로 패딩됩니다.
- 긴 출력을 여러 행으로 분할하기 위해 인코딩 된 출력의 각 76 자 뒤에 줄 바꿈이 추가됩니다.
- 디코딩에서는 줄 바꿈, 캐리지 리턴, 탭 및 공백이 인식 및 무시됩니다.
TRIM([{BOTH | LEADING | TRAILING} [ remstr ] FROM] str ) , TRIM([ remstr FROM] str )

모든 remstr 프리픽스 또는 접미사가 삭제 된 문자열 str 을 반환합니다. BOTH , LEADING , TRAILING 중 지정자도 지정되지 않는 경우는 BOTH 가 지정된 것으로 간주됩니다. remstr 는 선택 사항이며 지정되지 않은 경우에는 공백 문자가 삭제됩니다.
```
 mysql> SELECT TRIM(' bar ');
         -> 'bar'
 mysql> SELECT TRIM(LEADING 'x' FROM 'xxxbarxxx');
         -> 'barxxx'
 mysql> SELECT TRIM(BOTH 'x' FROM 'xxxbarxxx');
         -> 'bar'
 mysql> SELECT TRIM(TRAILING 'xyz' FROM 'barxxyz');
         -> 'barx'
```
이 함수는 다중 바이트로부터 안전합니다.
UCASE ( str )

UCASE() 은 UPPER() 의 동의어입니다.
UNHEX ( str )

캐릭터 라인의 인수 str 에서 UNHEX( str ) 는 인수의 각 문자 쌍을 16 진수로 해석하고 그 숫자로 표현 된 바이트로 변환합니다. 반환 값은 이진 문자열입니다.
```
 mysql> SELECT UNHEX('4D7953514C');
         -> 'MySQL'
 mysql> SELECT 0x4D7953514C;
         -> 'MySQL'
 mysql> SELECT UNHEX(HEX('string'));
         -> 'string'
 mysql> SELECT HEX(UNHEX('1267'));
         -> '1267'
```
인수 문자열의 문자는 정당한 16 진수이어야합니다 : '0' .. '9' , 'A' .. 'F' , 'a' .. 'f' . 인수에 16 진수 이외의 숫자가 포함되어있는 경우에는 결과가 NULL 입니다.
```
 mysql> SELECT UNHEX('GG');
 + ------------- +
 | UNHEX ( 'GG') |
 + ------------- +
 | NULL |
 + ------------- +
```
UNHEX() 에 인수가 BINARY 컬럼 인 경우 저장시 값으로 0x00 바이트가 패딩됩니다 만, 그 바이트는 취득시에 제거되지 않기 때문에, 결과가 NULL 이 될 수 있습니다. 예를 들어, '41' 은 '41 ' 로 CHAR(3) 컬럼에 저장되며 (끝에 패딩 된 공백이 제거 된) '41' 로 검색되므로 컬럼 값에 대한 UNHEX() 는 'A' 이 반환됩니다. 반대로, '41' 은 '41\0' 으로 BINARY(3) 컬럼에 저장되며 (끝에 패딩 된 0x00 바이트가 삭제되지 않음) '41\0' 으로 검색됩니다. '\0' 잘못된 16 진수이기 때문에 컬럼 값에 대한 UNHEX() 는 NULL 이 반환됩니다.

수치 인수 N 의 경우 HEX( N ) 의 반대는 UNHEX() 에서 실행되지 않습니다. 대신 CONV(HEX( N ),16,10) 를 사용하십시오. HEX() 의 설명을 참조하십시오.
UPPER ( str )

현재 문자 집합 매핑에 따라 모든 문자를 대문자로 변경된 문자열 str 을 반환합니다. 디폴트는 latin1 (cp1252 서유럽)입니다.
```
 mysql> SELECT UPPER('Hej');
         -> 'HEJ'
```
UPPER() 에도 적용되는 정보는 LOWER() 의 설명을 참조하십시오. 여기에는 현재는 기능이 비활성화되어있는 이진 문자열 ( BINARY , VARBINARY , BLOB )의 대소 문자 변환을 수행하는 방법에 대한 정보 및 Unicode 캐릭터 세트의 대소 문자 변환에 대한 정보가 포함 되어있었습니다.

이 함수는 다중 바이트로부터 안전합니다.
WEIGHT_STRING ( str [AS {CHAR | BINARY} ( N )] [LEVEL levels ] [ flags ])

levels : N [ASC | DESC | REVERSE] [, N [ASC | DESC | REVERSE] ...

이 함수는 입력 문자열의 무게 문자열을 반환합니다. 반환 값은 문자열의 정렬 및 비교 값을 나타내는 이진 문자열입니다. 이러한 특성이 있습니다.
- WEIGHT_STRING( str1 ) = WEIGHT_STRING( str2 ) 의 경우 str1 = str2 입니다 ( str1 과 str2 는 동일한 것으로 간주됩니다).
- WEIGHT_STRING( str1 ) < WEIGHT_STRING( str2 ) 의 경우 str1 < str2 입니다 ( str1 이 str2 앞에 정렬됩니다).
WEIGHT_STRING() 는 데이터 정렬 테스트 및 디버깅을 할 때 특히 새로운 데이터 정렬을 추가하는 경우에 사용할 수 있습니다. 섹션 10.4 "문자 집합에 대한 데이터 정렬 추가" 를 참조하십시오.

입력 문자열 str 은 문자열 식입니다. 입력이 아닌 이진 (문자) 문자열 ( CHAR , VARCHAR , TEXT 값 등) 인 경우는 반환 값에 문자열 데이터 정렬 가중치가 포함됩니다. 입력이 바이너리 (바이트) 문자열 ( BINARY , VARBINARY , BLOB 값 등) 인 경우, 반환 값은 입력과 같습니다 (이진 문자열의 바이트 당 무게는 바이트입니다). 입력이 NULL 인 경우는 WEIGHT_STRING() 는 NULL 을 반환합니다.

예 :
```
 mysql> SET @s = _latin1 'AB' COLLATE latin1_swedish_ci;
 mysql> SELECT @s, HEX(@s), HEX(WEIGHT_STRING(@s));
 + ------ + --------- + ------------------------ +
 | @s | HEX (@s) | HEX (WEIGHT_STRING (@s)) |
 + ------ + --------- + ------------------------ +
 | AB | 4142 | 4142 |
 + ------ + --------- + ------------------------ +
```
```
 mysql> SET @s = _latin1 'ab' COLLATE latin1_swedish_ci;
 mysql> SELECT @s, HEX(@s), HEX(WEIGHT_STRING(@s));
 + ------ + --------- + ------------------------ +
 | @s | HEX (@s) | HEX (WEIGHT_STRING (@s)) |
 + ------ + --------- + ------------------------ +
 | ab | 6162 | 4142 |
 + ------ + --------- + ------------------------ +
```
```
 mysql> SET @s = CAST('AB' AS BINARY);
 mysql> SELECT @s, HEX(@s), HEX(WEIGHT_STRING(@s));
 + ------ + --------- + ------------------------ +
 | @s | HEX (@s) | HEX (WEIGHT_STRING (@s)) |
 + ------ + --------- + ------------------------ +
 | AB | 4142 | 4142 |
 + ------ + --------- + ------------------------ +
```
```
 mysql> SET @s = CAST('ab' AS BINARY);
 mysql> SELECT @s, HEX(@s), HEX(WEIGHT_STRING(@s));
 + ------ + --------- + ------------------------ +
 | @s | HEX (@s) | HEX (WEIGHT_STRING (@s)) |
 + ------ + --------- + ------------------------ +
 | ab | 6162 | 6162 |
 + ------ + --------- + ------------------------ +
```
위의 예에서는 HEX() 를 사용하여 WEIGHT_STRING() 의 결과를 표시하고 있습니다. 결과는 바이너리 값이기 때문에 결과로 출력되지 않는 값이 포함될 때 출력 가능한 형식으로 볼 때, HEX() 가 특히 유용합니다.
```
 mysql> SET @s = CONVERT(0xC39F USING utf8) COLLATE utf8_czech_ci;
 mysql> SELECT HEX(WEIGHT_STRING(@s));
 + ------------------------ +
 | HEX (WEIGHT_STRING (@s)) |
 + ------------------------ +
 | 0FEA0FEA |
 + ------------------------ +
```
비 NULL 의 반환 값은 길이가 VARBINARY 의 최대 길이 내에있는 경우는 값의 데이터 형이 VARBINARY 이며, 기타의 경우 데이터 유형은 BLOB 입니다.

입력 문자열을 비 바이너리 또는 바이너리 문자열로 변환하여 강제로 지정한 길이가되도록, AS 절이 지정되는 경우가 있습니다.
- AS CHAR( N ) 은 문자열을 비 이진 문자열로 변환하고 N 문자의 길이가되도록 공백 문자로 오른쪽을 채 웁니다. N 은 적어도 1해야합니다. N 이 입력 문자열의 길이보다 작은 경우는 문자열이 N 자까지 자릅니다. 잘린 경고가 발생하지 않습니다.
- AS BINARY( N ) 은 문자열이 바이너리 문자열로 변환되고, N 이 (문자 단위가 아니라) 바이트 단위로 측정되어 패딩으로 (공백 문자 같은없이) 0x00 바이트가 사용된다는 점을 제외하고 마찬가지입니다.
```
 mysql> SELECT HEX(WEIGHT_STRING('ab' AS CHAR(4)));
 + ------------------------------------- +
 | HEX (WEIGHT_STRING ( 'ab'AS CHAR (4))) |
 + ------------------------------------- +
 | 41422020 |
 + ------------------------------------- +
```
```
 mysql> SELECT HEX(WEIGHT_STRING('ab' AS BINARY(4)));
 + --------------------------------------- +
 | HEX (WEIGHT_STRING ( 'ab'AS BINARY (4))) |
 + --------------------------------------- +
 | 61620000 |
 + --------------------------------------- +
```
반환 값에 특정 데이터 정렬 수준에 맞는 가중치를 포함하도록 지정하기 위해 LEVEL 절이 될 수 있습니다.

쉼표로 구분 된 하나 이상의 정수 목록으로 또는 대시로 구분 된 두 개의 정수 범위로 LEVEL 키워드 뒤에 levels 지정자가 지정 될 수 있습니다. 구두점의 전후의 공백의 유무는 영향을주지 않습니다.

예 :
```
 LEVEL 1
LEVEL 2, 3, 5
LEVEL 1-3
```
1보다 낮은 레벨 1로 처리됩니다. 입력 문자열 데이터 정렬의 최대 값보다 높은 수준의 데이터 정렬 최대 값으로 처리됩니다. 최대 값은 데이터 정렬마다 다르지만 6보다 큰 값이되지 않습니다.

수준 목록에서 수준을 오름차순으로 지정해야합니다. 레벨 범위에서는 두 번째 숫자가 1 번째보다 작은 경우에는 첫 번째 숫자로 처리됩니다 (예를 들어, 4-2는 4-4과 동일합니다).

LEVEL 절이 생략 된 경우, MySQL 그럼 LEVEL 1 - max 로 간주됩니다. 여기에서 max 는 조합 순서의 최대 수준입니다.

LEVEL 이 (범위 구문이 아닌) 목록 구문을 사용하여 지정되는 경우, 레벨 숫자 다음에 다음 한정자를 지정할 수 있습니다.
- ASC : 변경없이 무게를 돌려줍니다. 이것은 기본입니다.
- DESC : 비트 반전 된 가중치를 반환합니다 (예를 들어, 0x78f0 DESC = 0x870f 입니다).
- REVERSE : 역순으로 가중치 (즉, 첫 번째 문자를 마지막으로, 마지막 문자를 마지막에와 반대로 늘어 놓은 캐릭터 라인의 무게)을 반환합니다.
예 :
```
mysql> SELECT HEX (WEIGHT_STRING (0x007fff LEVEL 1));
+ -------------------------------------- +
| HEX (WEIGHT_STRING (0x007fff LEVEL 1)) |
+ -------------------------------------- +
| 007FFF |
+ -------------------------------------- +
```
```
mysql> SELECT HEX (WEIGHT_STRING (0x007fff LEVEL 1 DESC));
 + ------------------------------------------- +
| HEX (WEIGHT_STRING (0x007fff LEVEL 1 DESC)) |
 + ------------------------------------------- +
| FF8000 |
 + ------------------------------------------- +
```
```
mysql> SELECT HEX (WEIGHT_STRING (0x007fff LEVEL 1 REVERSE));
+ ---------------------------------------------- +
| HEX (WEIGHT_STRING (0x007fff LEVEL 1 REVERSE)) |
+ ---------------------------------------------- +
| FF7F00 |
+ ---------------------------------------------- +
```
```
mysql> SELECT HEX (WEIGHT_STRING (0x007fff LEVEL 1 DESC REVERSE));
 + ------------------------------------------------- - +
| HEX (WEIGHT_STRING (0x007fff LEVEL 1 DESC REVERSE)) |
 + ------------------------------------------------- - +
| 0080FF |
 + ------------------------------------------------- - +
```
현재 flags 절은 사용되지 않습니다.