|
| |
| |
|
출처: http://mysqlkorea.co.kr/sub.html?mcode=develop&scode=01&m_no=21703&cat1=12&cat2=353&cat3=0&lang=k
12.3. 스트링 함수
12.3.1. 스트링 비교 함수
스트링-값 함수는 그 결과 값의 길이가 max_allowed_packet 시스템 변수의 값 보다 클 경우에는, NULL을 리턴한다. Section 7.5.2, “서버 파라미터 튜닝하기”를 참조할 것.
스트링 포지션(position)에서 연산을 하는 함수의 경우, 첫 번째 포지션은 숫자 1이 된다.
ASCII(str)
스트링 str 의 맨 왼쪽 문자의 숫자 값을 리턴한다. str 이 빈 스트링(empty string)일 경우에는 0 을 리턴한다. NULL if str 이 NULL일 경우에는 NULL 을 리턴한다. ASCII()는 0 에서 255 사이의 숫자 값을 갖는 문자에 대해서 연산을 한다.
mysql> SELECT ASCII('2');
-> 50
mysql> SELECT ASCII(2);
-> 50
mysql> SELECT ASCII('dx');
-> 100
ORD() 함수를 함께 참조할 것.
BIN(N)
N의 바이너리 값에 대한 스트링 표현식을 리턴하는데, 여기에서N 은 (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 값은 무시(skipped)된다.
mysql> SELECT CHAR(77,121,83,81,'76');
-> 'MySQL'
mysql> SELECT CHAR(77,77.3,'77.3');
-> 'MMM'
MySQL 5.0.15 이후 버전에서는, 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(0x65)), CHARSET(CHAR(0x65 USING utf8));
+---------------------+--------------------------------+
| CHARSET(CHAR(0x65)) | CHARSET(CHAR(0x65 USING utf8)) |
+---------------------+--------------------------------+
| binary | utf8 |
+---------------------+--------------------------------+
만일 USING을 사용하였는데도 그 결과 스트링이 주어진 문자 셋에 대해서 유효하지 않게 되면, 경고문이 나오게 된다. 또한, 만일 스트릭트(strict) SQL 모드를 활성화 한다면, CHAR() 의 결과 값은 NULL이 된다.
MySQL 5.0.15 이전 버전에서는, CHAR()는 연결 문자 셋에 있는 스트링을 리턴하며 USING 구문은 사용할 수 없게 된다. 또한, 각각의 인수는 모듈로(modulo) 256으로 해석이 되기 때문에, CHAR(256) 및 CHAR(256*256)는 둘 다 CHAR(0)과 동일한 것이 된다.
CHAR_LENGTH(str)
스트링 str의 길이를 리턴한다. 다중 바이트 문자는 단일 문자로 계산(count) 된다. 즉, 5개의 2 바이트 문자를 갖는 스트링에 대해서, LENGTH() 는 10을 리턴 하지만, CHAR_LENGTH()는 5를 리턴 한다.
CHARACTER_LENGTH(str)
CHARACTER_LENGTH()는 CHAR_LENGTH()과 동일하다.
CONCAT(str1,str2,...)
인수를 연결한 결과로 나오는 스트링을 리턴한다. 한 개 또는 그 이상의 인수를 가질 수 있다. 만일 모든 인수가 바이너리 스트링이 아니라면, 그 결과는 바이너리가 아닌 스트링이 된다. 만일 인수에 바이너리 스트링이 포함되어 있다면, 그 결과는 바이너리 스트링이 된다. 숫자 인수는 동일한 바이너리 스트링 형태로 변환된다; 만일 이렇게 변환되는 것을 원하지 않을 경우에는, 아래의 예문과 같이 명확하게 타입 캐스트(type cast)를 사용하면 된다:
SELECT CONCAT(CAST(int_col AS CHAR), char_col);
CONCAT()는 모든 인수가 NULL이 아니면 NULL을 리턴한다.
mysql> SELECT CONCAT('My', 'S', 'QL');
-> 'MySQL'
mysql> SELECT CONCAT('My', NULL, 'QL');
-> NULL
mysql> SELECT CONCAT(14.3);
-> '14.3'
CONCAT_WS(separator,str1,str2,...)
CONCAT_WS()는 구분자를 사용하는 연결(Concatenate With Separator)을 나타내는 것이며 CONCAT()의 특수 형태이다. 첫 번째 인수는 나머지 인수들에 대한 구분자(separator)가 된다. 구분자는 연결되는 스트링 사이에 추가된다. 구분자는 스트링이 될 수 있다. 만일 구분자가 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()는 빈 스트링(empty string)을 무시(skip)하지 않는다. 하지만, 구분자 인수 다음에 나오는 모든 NULL 값은 무시를 한다.
CONV(N,from_base,to_base)
서로 다른 문자 베이스(base)간의 숫자를 변환한다. from_base 에서 베이스 to_base로 변환된 숫자 N의 스트링 표현식을 리턴한다. 인수 중의 하나가 NULL이면 NULL을 리턴한다.인수 N 은 정수로 해석되지만, 정수 또는 스트링으로 지정될 수도 있다. 최소 베이스는 2 이고 최대 베이스는 36이다. 만일 to_base 가 음수라면, N 은 부호화된 숫자로 간주된다. 그렇지 않을 경우에는, N 은 부호 없는 숫자로 취급된다. CONV()는 64-비트 정밀도를 갖는다.
mysql> SELECT CONV('a',16,2);
-> '1010'
mysql> SELECT CONV('6E',18,8);
-> '172'
mysql> SELECT CONV(-17,10,-18);
-> '-H'
mysql> SELECT CONV(10+'10'+'10'+0xa,10,10);
-> '40'
ELT(N,str1,str2,str3,...)
만일N = 1이면, str1을, N = 2이면, str2 을 리턴하는 방식. N 이 1 보다 작거나 또는인수의 숫자보다 많을 경우에는 NULL을 리턴한다. ELT()는 FIELD()의 보수(complement)이다.
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에 있는 모든 비트 셋(bit set)에 대해서는, on 스트링을, 그리고 모든 리셋 비트에 대해서는, off 스트링을 리턴한다. bits 에 있는 비트는 오른쪽에서 왼쪽으로 검사된다 (낮은 순서에서 높은 순서 비트로). 스트링은 왼쪽에서 오른쪽으로 결과에 추가되는데, separator 스트링으로 구분이 된다 (디폴트 스트링은 콤마 문자 ‘,’). 검사가 되는 비트의 숫자는 number_of_bits로 주어진다 (디폴트는 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()에 대한 모든 인수가 스트링이라면, 모든 인수는 스트링으로 비교된다. 만일 모든 인수가 숫자일 경우에는 숫자로 비교가 된다. 그렇지 않은 경우라면, 인수들은 두 번 (double) 비교가 된다.
만일 str 이 NULL이라면, 리턴 값은 0 이 되는데, 그 이유는 NULL 은 어떤 값과도 등식 비교가 되지 않기 때문이다. FIELD()는 ELT()의 보수(complement)이다.
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 if만일 인수 중의 하나가 NULL이라면, NULL을 리턴한다. 만일 첫 번째 인수가 콤마 문자를 가지고 있다면, 이 함수는 제대로 동작을 하지 않는다.
mysql> SELECT FIND_IN_SET('b','a,b,c,d');
-> 2
FORMAT(X,D)
숫자 X 의 포맷을 '#,###,###.##' 형태로 만들고, D의 소수점 뒷자리에서 절사(round)를 하고, 그 결과를 스트링으로 리턴한다. 만일 D 가 0 이면, 그 결과는 소수점 또는 분수 부분을 갖지 않는다.
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'
HEX(N_or_S)
만일N_or_S 이 숫자라면, N에 대한 16진수 값에 해당하는 스트링 표현을 리턴하는데, 여기에서 N 은 (BIGINT) 숫자가 된다. 이것은 CONV(N,10,16)과 동일하다.
만일 N_or_S 이 스트링 이라면, N_or_S 에 대한 16진수 스트링 표현식을 리턴하는데, N_or_S 에 있는 각각의 문자는 2개의 16진수 숫자로 변환된다.
mysql> SELECT HEX(255);
-> 'FF'
mysql> SELECT 0x616263;
-> 'abc'
mysql> SELECT HEX('abc');
-> 616263
INSERT(str,pos,len,newstr)
str 의 포지션 pos 에서 시작하는 서브 스트링을 len 문자 길이만큼 스트링 newstr로 변경시켜서 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 가 처음으로 나오는 포지션을 리턴한다. 이것은 LOCATE()에서 두 개의 인수를 사용하는 것과 동일한 결과를 리턴 하지만, 인수들의 순서는 반대가 된다.
mysql> SELECT INSTR('foobarbar', 'bar');
-> 4
mysql> SELECT INSTR('xbar', 'foobar');
-> 0
이 함수는 다중 바이트에서도 동작을 하며, 최소 하나의 인수가 바이너리 스트링일 경우에만 문자 크기를 구분한다.
LCASE(str)
LCASE()는 LOWER()와 동의어 이다.
LEFT(str,len)
스트링 str에서 가장 왼쪽으로부터 len 개의 문자를 리턴한다.
mysql> SELECT LEFT('foobarbar', 5);
-> 'fooba'
LENGTH(str)
str의 길이를 바이트 단위로 리턴한다. 다중 바이트 문자는 다중 바이트로 계산 (count)된다. 이것은 2 바이트 문자가 5개 있는 스트링의 경우, LENGTH() 은 10을 리턴하는 반면에, CHAR_LENGTH()는 5를 리턴한다는 것을 의미한다.
mysql> SELECT LENGTH('text');
-> 4
LOAD_FILE(file_name)
파일을 읽은 다음에 파일의 내용물을 스트링으로 리턴한다. 이 함수를 사용하기 위해서는, 파일은 반드시 서버 호스트에 있어야 하며, 그 파일에 대한 경로 이름을 전체적으로 지정해야 하며, 그리고 FILE 권한을 가져야 한다. 그 파일은 모든 사용자에게 읽힐 수 있어야 하며 파일의 크기는 max_allowed_packet 바이트 보다는 작아야 한다.
만일 파일이 존재하지 않거나 또는 위의 조건 중에 하나로 인해 파일을 읽을 수가 없게 된다면, 이 함수는 NULL을 리턴한다.
MySQL 5.0.19 이후 버전에서는, 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 가 처음으로 나오는 포지션을 리턴한다. 두 번째 신텍스는, 포지션 pos에서 시작을 해서, str 에서 서브 스트링 substr 가 처음으로 나오는 포지션을 리턴한다. substr 이 str에 존재하지 않을 경우에는, 0을 리턴한다.
mysql> SELECT LOCATE('bar', 'foobarbar');
-> 4
mysql> SELECT LOCATE('xbar', 'foobar');
-> 0
mysql> SELECT LOCATE('bar', 'foobarbar', 5);
-> 7
이 함수는 다중 바이트에서도 동작을 하며, 인수 중에서 최소 하나라도 바이너리 스트링일 경우에만 문자 크기를 구분한다.
LOWER(str)
현재 (current) 문자 셋 매핑에 따라서 스트링 str 의 모든 문자를 소문자로 변경 시켜서 리턴한다. 디폴트는 latin1 (cp1252 West European).
mysql> SELECT LOWER('QUADRATICALLY');
-> 'quadratically'
이 함수는 다중 바이트에서도 동작을 한다.
LPAD(str,len,padstr)
왼쪽에 스트링 padstr 를 집어 넣어서 문자의 길이를 len 만큼 되도록 한 스트링 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 은 (BIGINT) 번호가 된다. 이것은 CONV(N,10,8)과 같다. 만일 N 이 NULL이면, NULL을 리턴한다.
mysql> SELECT OCT(12);
-> '14'
OCTET_LENGTH(str)
OCTET_LENGTH()는 LENGTH()과 동의어 이다.
ORD(str)
만일 If the leftmost character of the string스트링 str 의 가장 왼쪽의 문자가 다중 바이트 문자라면, 그 문자에 대한 코드를 리턴하는데, 그 값은 아래의 공식을 사용해서 얻어낸다:
(1st byte code)
+ (2nd byte code × 256)
+ (3rd byte code × 2562) ...
만일 가장 왼쪽의 문자가 다중 바이트 문자가 아니라면, ORD()는 ASCII() 함수와 같은 값을 리턴한다.
mysql> SELECT ORD('2');
-> 50
POSITION(substr IN str)
POSITION(substr IN str)는 LOCATE(substr,str)과 동의어 이다.
QUOTE(str)
SQL 명령문에서 이스케이프된 데이터 값으로 사용할 수 있는 결과를 만들기 위해 스트링에 인용 부호를 준다. 만일 인수가 NULL이면, 리턴 값은 인용 부호가 없는 단어 “NULL” 이 나오게 된다.
mysql> SELECT QUOTE('Don\'t!');
-> 'Don\'t!'
mysql> SELECT QUOTE(NULL);
-> NULL
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 문자 만큼을 리턴한다.
mysql> SELECT RIGHT('foobarbar', 4);
-> 'rbar'
이 함수는 다중 바이트에서도 동작을 한다.
RPAD(str,len,padstr)
스트링 padstr 를 오른쪽에 집어 넣어서 len 문자 길이 만큼 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) 스트링을 리턴한다. 거의 같은 소리가 나는 두 개의 스트링은 고유의 사운덱스 스트링을 가져야 한다. 표준 사운덱스 스트링은 4 문자 길이가 되지만, SOUNDEX() 함수는 임의의 길이 스트링을 리턴한다. 여러분은 표준 사운덱스 스트링을 얻기 위해서 결과 값에 SUBSTRING()을 사용할 수가 있다. str에 있는 문자 중에 알파벳이 아닌 것들은 모두 무시가 된다. A-Z 범위를 벗어나는 모든 국제 문자들은 모두 모음으로 취급된다.
mysql> SELECT SOUNDEX('Hello');
-> 'H400'
mysql> SELECT SOUNDEX('Quadratically');
-> 'Q36324'
expr1 SOUNDS LIKE expr2
이것은 SOUNDEX(expr1) = SOUNDEX(expr2)과 같다.
SPACE(N)
N 개의 스페이스 문자로 구성된 스트링을 리턴한다.
mysql> SELECT SPACE(6);
-> ' '
SUBSTRING(str,pos), SUBSTRING(str FROM pos), SUBSTRING(str,pos,len), SUBSTRING(str FROM pos FOR len)
len 인수가 없는 형태는 포지션 pos에서 시작을 하는 서브 스트링을 스트링 str 에서 리턴 한다. len 인수를 가지고 있는 형태는 포지션 pos에서 시작을 해서 서브 스트링 len 문자를 리턴한다. FROM을 사용하는 형태는 표준 SQL 신텍스이다. pos의 값으로 음수를 사용하는 것도 가능하다. 음수를 사용할 경우에는, 서브 스트링의 시작점이 스트링의 처음이 아닌 끝에서부터 pos 문자 위치가 된다. 음수 값은 이 함수의 어떤 형태에서도 사용이 가능하다.
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 보다 작으면, 그 결과는 빈 스트링이 된다.
SUBSTR()은 SUBSTRING()과 동일하다.
SUBSTRING_INDEX(str,delim,count)
구분자 (delimiter) delim가 count 만큼 나오기 전에 스트링 str 에서 서브 스트링을 리턴한다. 만일 count 가 양수 (positive)라면, 마지막 구분자의 왼쪽에 있는 모든 것들이 리턴된다 (왼쪽부터 계산이 됨). 만일 count 가 음수일 경우에는, 마지막 구분자의 오른쪽에 있는 모든 것들이 리턴된다 (오른쪽부터 계산됨). SUBSTRING_INDEX()는 delim에 대한 검색을 할 때 문자의 크기를 구분한다.
mysql> SELECT SUBSTRING_INDEX('www.mysql.com', '.', 2);
-> 'www.mysql'
mysql> SELECT SUBSTRING_INDEX('www.mysql.com', '.', -2);
-> 'mysql.com'
이 함수는 다중 바이트를 지원한다.
TRIM([{BOTH | LEADING | TRAILING} [remstr] FROM] str), TRIM([remstr FROM] str)
스트링 str 를 모든 remstr 접두사 (prefixes) 또는 접미사를 제거한 상태로 리턴한다. 만일 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)
HEX(str)와는 반대 연산을 실행한다. 즉, 이 함수는 인수에 있는 각각의 16진수를 숫자로 해석을 하고 그 숫자에 대응하는 문자로 변환을 시킨다. 그 결과로 나오는 문자들은 바이너리 스트링으로 리턴된다.
mysql> SELECT UNHEX('4D7953514C');
-> 'MySQL'
mysql> SELECT 0x4D7953514C;
-> 'MySQL'
mysql> SELECT UNHEX(HEX('string'));
-> 'string'
mysql> SELECT HEX(UNHEX('1267'));
-> '1267'
UPPER(str)
Returns 스트링 str 를 현재의 (current) 문자 셋 매핑에 따라서 대문자로 변환이 된 모든 문자와 함께 리턴한다. 디폴트는 latin1 (cp1252 West European).
mysql> SELECT UPPER('Hej');
-> 'HEJ'
이 함수는 다중 바이트를 지원한다.
| |
|
|
즐겨찾기
상담 채팅: 접속자(1)