Loading...
MySQL 9.5 Reference Manual 9.5의 14.8.2 Regular Expressions의 한국어 번역본입니다.
아래의 경우에 피드백에서 신고해주신다면 반영하겠습니다.
감사합니다 :)
Table 14.14 Regular Expression Functions and Operators
| Name | Description |
|---|---|
NOT REGEXP | REGEXP의 부정 |
REGEXP | 문자열이 정규 표현식과 일치하는지 여부 |
REGEXP_INSTR() | 정규 표현식과 일치하는 부분 문자열의 시작 인덱스 |
REGEXP_LIKE() | 문자열이 정규 표현식과 일치하는지 여부 |
REGEXP_REPLACE() | 정규 표현식과 일치하는 부분 문자열을 치환 |
REGEXP_SUBSTR() | 정규 표현식과 일치하는 부분 문자열 반환 |
RLIKE | 문자열이 정규 표현식과 일치하는지 여부 |
정규 표현식은 복잡한 검색을 위한 패턴을 지정하는 강력한 방법입니다. 이 섹션에서는 정규 표현식 매칭에 사용할 수 있는 함수와 연산자를 다루고, 정규 표현식 연산에 사용할 수 있는 특수 문자와 구조 중 일부를 예제를 통해 설명합니다. Section 5.3.4.7, “Pattern Matching”도 참고하십시오.
MySQL은 International Components for Unicode (ICU)를 사용하여 정규 표현식 지원을 구현하며, 이는 전체 유니코드를 지원하고 멀티바이트 세이프입니다.
어떤 MySQL 정규 표현식 함수에서든 바이너리 문자열을 사용하는 경우 ER_CHARACTER_SET_MISMATCH 오류와 함께 거부됩니다.
이는 NOT (expr REGEXP pat)와 동일합니다.
문자열 expr 이 패턴 pat 로 지정된 정규 표현식과 일치하면 1을, 그렇지 않으면 0을 반환합니다. expr 또는 pat 이 NULL이면 반환값은 NULL입니다.
REGEXP와 RLIKE는 REGEXP_LIKE()의 동의어입니다.
매칭이 어떻게 수행되는지에 대한 추가 정보는 REGEXP_LIKE()의 설명을 참조하십시오.
1mysql> SELECT 'Michael!' REGEXP '.*'; 2+------------------------+ 3| 'Michael!' REGEXP '.*' | 4+------------------------+ 5| 1 | 6+------------------------+ 7mysql> SELECT 'new*\n*line' REGEXP 'new\\*.\\*line'; 8+---------------------------------------+ 9| 'new*\n*line' REGEXP 'new\\*.\\*line' | 10+---------------------------------------+ 11| 0 | 12+---------------------------------------+ 13mysql> SELECT 'a' REGEXP '^[a-d]'; 14+---------------------+ 15| 'a' REGEXP '^[a-d]' | 16+---------------------+ 17| 1 | 18+---------------------+
문자열 expr 에서 패턴 pat 로 지정된 정규 표현식과 일치하는 부분 문자열의 시작 인덱스를 반환하며, 일치하는 항목이 없으면 0을 반환합니다. expr 또는 pat 이 NULL이면 반환값은 NULL입니다. 문자 인덱스는 1부터 시작합니다.
REGEXP_INSTR()는 다음과 같은 선택적 인자를 사용합니다:
pos: 검색을 시작할 expr 내 위치입니다. 생략하면 기본값은 1입니다.
occurrence: 검색할 일치 항목의 발생 순서입니다. 생략하면 기본값은 1입니다.
return_option: 어떤 유형의 위치를 반환할지 지정합니다. 이 값이 0이면 REGEXP_INSTR()는 매치된 부분 문자열의 첫 번째 문자의 위치를 반환합니다. 이 값이 1이면 REGEXP_INSTR()는 매치된 부분 문자열 다음 위치를 반환합니다. 생략하면 기본값은 0입니다.
match_type: 매칭 수행 방법을 지정하는 문자열입니다. 의미는 REGEXP_LIKE()에 대해 설명한 것과 같습니다.
매칭이 어떻게 수행되는지에 대한 추가 정보는 REGEXP_LIKE()의 설명을 참조하십시오.
1mysql> SELECT REGEXP_INSTR('dog cat dog', 'dog'); 2+------------------------------------+ 3| REGEXP_INSTR('dog cat dog', 'dog') | 4+------------------------------------+ 5| 1 | 6+------------------------------------+ 7mysql> SELECT REGEXP_INSTR('dog cat dog', 'dog', 2); 8+---------------------------------------+ 9| REGEXP_INSTR('dog cat dog', 'dog', 2) | 10+---------------------------------------+ 11| 9 | 12+---------------------------------------+ 13mysql> SELECT REGEXP_INSTR('aa aaa aaaa', 'a{2}'); 14+-------------------------------------+ 15| REGEXP_INSTR('aa aaa aaaa', 'a{2}') | 16+-------------------------------------+ 17| 1 | 18+-------------------------------------+ 19mysql> SELECT REGEXP_INSTR('aa aaa aaaa', 'a{4}'); 20+-------------------------------------+ 21| REGEXP_INSTR('aa aaa aaaa', 'a{4}') | 22+-------------------------------------+ 23| 8 | 24+-------------------------------------+
문자열 expr 이 패턴 pat 로 지정된 정규 표현식과 일치하면 1을, 그렇지 않으면 0을 반환합니다. expr 또는 pat 이 NULL이면 반환값은 NULL입니다.
패턴은 확장 정규 표현식이 될 수 있으며, 그 구문은 Regular Expression Syntax에서 설명합니다. 패턴은 리터럴 문자열일 필요는 없습니다. 예를 들어, 문자열 표현식이나 테이블 열로 지정할 수 있습니다.
선택적 인자인 match_type 은 매칭 수행 방법을 지정하는 다음 문자 중 하나 이상을 포함할 수 있는 문자열입니다:
c: 대소문자 구분 매칭.
i: 대소문자 비구분 매칭.
m: 멀티라인 모드. 문자열 내의 줄 종단 문자를 인식합니다. 기본 동작은 줄 종단 문자를 문자열 표현식의 시작과 끝에서만 매칭하는 것입니다.
n: . 문자가 줄 종단 문자와 매칭됩니다. 기본값은 . 매칭이 라인의 끝에서 멈추는 것입니다.
u: 유닉스 전용 줄 끝. newline 문자만 ., ^, $ 매치 연산자에 의해 줄 끝으로 인식됩니다.
match_type 내에 상충하는 옵션을 지정하는 문자가 포함된 경우, 가장 오른쪽 문자가 우선합니다.
기본적으로 정규 표현식 연산은 expr 및 pat 인자의 문자 집합과 콜레이션을 사용하여 문자 유형을 결정하고 비교를 수행합니다. 인자가 서로 다른 문자 집합이나 콜레이션을 가지는 경우, Section 12.8.4, “Collation Coercibility in Expressions”에 설명된 대로 강제 규칙이 적용됩니다. 비교 동작을 변경하기 위해 인자에 명시적 콜레이션 지시자를 지정할 수 있습니다.
1mysql> SELECT REGEXP_LIKE('CamelCase', 'CAMELCASE'); 2+---------------------------------------+ 3| REGEXP_LIKE('CamelCase', 'CAMELCASE') | 4+---------------------------------------+ 5| 1 | 6+---------------------------------------+ 7mysql> SELECT REGEXP_LIKE('CamelCase', 'CAMELCASE' COLLATE utf8mb4_0900_as_cs); 8+------------------------------------------------------------------+ 9| REGEXP_LIKE('CamelCase', 'CAMELCASE' COLLATE utf8mb4_0900_as_cs) | 10+------------------------------------------------------------------+ 11| 0 | 12+------------------------------------------------------------------+
match_type 은 기본 대소문자 구분 여부를 재정의하기 위해 c 또는 i 문자로 지정할 수 있습니다. 예외: 어느 한 인자라도 바이너리 문자열인 경우, match_type 에 i 문자가 포함되어 있더라도 이들 인자는 바이너리 문자열로서 대소문자를 구분하여 처리됩니다.
참고
MySQL은 문자열에서 C 이스케이프 구문을 사용합니다(예: newline 문자를 표현하기 위한 \n). expr 또는 pat 인자에 리터럴 \를 포함하려면 이를 두 번 써야 합니다. (단, 이스케이프 문자를 사용하지 않는 NO_BACKSLASH_ESCAPES SQL 모드가 활성화된 경우는 예외입니다.)
1mysql> SELECT REGEXP_LIKE('Michael!', '.*'); 2+-------------------------------+ 3| REGEXP_LIKE('Michael!', '.*') | 4+-------------------------------+ 5| 1 | 6+-------------------------------+ 7mysql> SELECT REGEXP_LIKE('new*\n*line', 'new\\*.\\*line'); 8+----------------------------------------------+ 9| REGEXP_LIKE('new*\n*line', 'new\\*.\\*line') | 10+----------------------------------------------+ 11| 0 | 12+----------------------------------------------+ 13mysql> SELECT REGEXP_LIKE('a', '^[a-d]'); 14+----------------------------+ 15| REGEXP_LIKE('a', '^[a-d]') | 16+----------------------------+ 17| 1 | 18+----------------------------+
1mysql> SELECT REGEXP_LIKE('abc', 'ABC'); 2+---------------------------+ 3| REGEXP_LIKE('abc', 'ABC') | 4+---------------------------+ 5| 1 | 6+---------------------------+ 7mysql> SELECT REGEXP_LIKE('abc', 'ABC', 'c'); 8+--------------------------------+ 9| REGEXP_LIKE('abc', 'ABC', 'c') | 10+--------------------------------+ 11| 0 | 12+--------------------------------+
패턴 pat 로 지정된 정규 표현식과 일치하는 문자열 expr 내 발생 위치를 치환 문자열 repl 로 대체하고, 그 결과 문자열을 반환합니다. expr, pat, repl 중 어느 하나라도 NULL이면 반환값은 NULL입니다.
REGEXP_REPLACE()는 다음과 같은 선택적 인자를 사용합니다:
pos: 검색을 시작할 expr 내 위치입니다. 생략하면 기본값은 1입니다.
occurrence: 치환할 일치 항목의 발생 순서입니다. 생략하면 기본값은 0이며(“모든 발생 위치를 치환”을 의미합니다).
match_type: 매칭 수행 방법을 지정하는 문자열입니다. 의미는 REGEXP_LIKE()에 대해 설명한 것과 같습니다.
이 함수가 반환하는 결과는 매칭을 검색한 표현식의 문자 집합과 콜레이션을 사용합니다.
매칭이 어떻게 수행되는지에 대한 추가 정보는 REGEXP_LIKE()의 설명을 참조하십시오.
1mysql> SELECT REGEXP_REPLACE('a b c', 'b', 'X'); 2+-----------------------------------+ 3| REGEXP_REPLACE('a b c', 'b', 'X') | 4+-----------------------------------+ 5| a X c | 6+-----------------------------------+ 7mysql> SELECT REGEXP_REPLACE('abc def ghi', '[a-z]+', 'X', 1, 3); 8+----------------------------------------------------+ 9| REGEXP_REPLACE('abc def ghi', '[a-z]+', 'X', 1, 3) | 10+----------------------------------------------------+ 11| abc def X | 12+----------------------------------------------------+
문자열 expr 에서 패턴 pat 로 지정된 정규 표현식과 일치하는 부분 문자열을 반환하며, 일치하는 항목이 없으면 NULL을 반환합니다. expr 또는 pat 이 NULL이면 반환값은 NULL입니다.
REGEXP_SUBSTR()는 다음과 같은 선택적 인자를 사용합니다:
pos: 검색을 시작할 expr 내 위치입니다. 생략하면 기본값은 1입니다.
occurrence: 검색할 일치 항목의 발생 순서입니다. 생략하면 기본값은 1입니다.
match_type: 매칭 수행 방법을 지정하는 문자열입니다. 의미는 REGEXP_LIKE()에 대해 설명한 것과 같습니다.
이 함수가 반환하는 결과는 매칭을 검색한 표현식의 문자 집합과 콜레이션을 사용합니다.
매칭이 어떻게 수행되는지에 대한 추가 정보는 REGEXP_LIKE()의 설명을 참조하십시오.
1mysql> SELECT REGEXP_SUBSTR('abc def ghi', '[a-z]+'); 2+----------------------------------------+ 3| REGEXP_SUBSTR('abc def ghi', '[a-z]+') | 4+----------------------------------------+ 5| abc | 6+----------------------------------------+ 7mysql> SELECT REGEXP_SUBSTR('abc def ghi', '[a-z]+', 1, 3); 8+----------------------------------------------+ 9| REGEXP_SUBSTR('abc def ghi', '[a-z]+', 1, 3) | 10+----------------------------------------------+ 11| ghi | 12+----------------------------------------------+
정규 표현식은 문자열 집합을 기술합니다. 가장 단순한 정규 표현식은 그 안에 특수 문자가 전혀 없는 것입니다. 예를 들어, 정규 표현식 hello는 hello와 그 외 아무 것도 매칭하지 않습니다.
좀 더 복잡한 정규 표현식은 둘 이상의 문자열과 매칭될 수 있도록 특정 특수 구조를 사용합니다. 예를 들어, 정규 표현식 hello|world는 | 교대(alternation) 연산자를 포함하며 hello 또는 world 중 하나와 매칭됩니다.
좀 더 복잡한 예로, 정규 표현식 B[an]*s는 Bananas, Baaaaas, Bs 및 B로 시작해서 s로 끝나며 그 사이에 임의 개수의 a 또는 n 문자가 들어가는 다른 모든 문자열과 매칭됩니다.
다음 목록은 정규 표현식에서 사용할 수 있는 일부 기본 특수 문자와 구조를 다룹니다. 정규 표현식 지원을 구현하는 데 사용되는 ICU 라이브러리가 지원하는 전체 정규 표현식 구문에 대한 정보는 International Components for Unicode web site를 방문하십시오.
^문자열의 시작 부분과 매칭합니다.
1mysql> SELECT REGEXP_LIKE('fo\nfo', '^fo$'); -> 0 2mysql> SELECT REGEXP_LIKE('fofo', '^fo'); -> 1
$문자열의 끝 부분과 매칭합니다.
1mysql> SELECT REGEXP_LIKE('fo\no', '^fo\no$'); -> 1 2mysql> SELECT REGEXP_LIKE('fo\no', '^fo$'); -> 0
.임의의 문자(캐리지 리턴과 newline 포함)와 매칭합니다. 단, 문자열의 중간에서 이러한 문자를 매칭하려면 m (멀티라인) 매치 제어 문자 또는 패턴 내 수정자인 (?m)을 지정해야 합니다.
1mysql> SELECT REGEXP_LIKE('fofo', '^f.*$'); -> 1 2mysql> SELECT REGEXP_LIKE('fo\r\nfo', '^f.*$'); -> 0 3mysql> SELECT REGEXP_LIKE('fo\r\nfo', '^f.*$', 'm'); -> 1 4mysql> SELECT REGEXP_LIKE('fo\r\nfo', '(?m)^f.*$'); -> 1
a*0개 이상의 a 문자 시퀀스와 매칭합니다.
1mysql> SELECT REGEXP_LIKE('Ban', '^Ba*n'); -> 1 2mysql> SELECT REGEXP_LIKE('Baaan', '^Ba*n'); -> 1 3mysql> SELECT REGEXP_LIKE('Bn', '^Ba*n'); -> 1
a+1개 이상의 a 문자 시퀀스와 매칭합니다.
1mysql> SELECT REGEXP_LIKE('Ban', '^Ba+n'); -> 1 2mysql> SELECT REGEXP_LIKE('Bn', '^Ba+n'); -> 0
a?0개 또는 1개의 a 문자와 매칭합니다.
1mysql> SELECT REGEXP_LIKE('Bn', '^Ba?n'); -> 1 2mysql> SELECT REGEXP_LIKE('Ban', '^Ba?n'); -> 1 3mysql> SELECT REGEXP_LIKE('Baan', '^Ba?n'); -> 0
de|abc교대(alternation); de 또는 abc 시퀀스 중 하나와 매칭합니다.
1mysql> SELECT REGEXP_LIKE('pi', 'pi|apa'); -> 1 2mysql> SELECT REGEXP_LIKE('axe', 'pi|apa'); -> 0 3mysql> SELECT REGEXP_LIKE('apa', 'pi|apa'); -> 1 4mysql> SELECT REGEXP_LIKE('apa', '^(pi|apa)$'); -> 1 5mysql> SELECT REGEXP_LIKE('pi', '^(pi|apa)$'); -> 1 6mysql> SELECT REGEXP_LIKE('pix', '^(pi|apa)$'); -> 0
(abc)*시퀀스 abc의 0개 이상의 인스턴스와 매칭합니다.
1mysql> SELECT REGEXP_LIKE('pi', '^(pi)*$'); -> 1 2mysql> SELECT REGEXP_LIKE('pip', '^(pi)*$'); -> 0 3mysql> SELECT REGEXP_LIKE('pipi', '^(pi)*$'); -> 1
{1}, {2,3}반복; {n} 및 {m,n} 표기법은 패턴의 이전 atom(또는 “piece”)의 여러 occurrence와 매칭하는 정규 표현식을 작성하는 보다 일반적인 방법을 제공합니다. m 및 n 은 정수입니다.
a*는 a{0,}으로 쓸 수 있습니다.
a+는 a{1,}으로 쓸 수 있습니다.
a?는 a{0,1}로 쓸 수 있습니다.
좀 더 정확히 말하면, a{n}은 정확히 n 개의 a 인스턴스와 매칭합니다. a{n,}은 n 개 이상의 a 인스턴스와 매칭합니다. a{m,n}은 m 개 이상 n 개 이하(포함)의 a 인스턴스와 매칭합니다. m 과 n 이 모두 주어지면, m 은 n 이하이어야 합니다.
1mysql> SELECT REGEXP_LIKE('abcde', 'a[bcd]{2}e'); -> 0 2mysql> SELECT REGEXP_LIKE('abcde', 'a[bcd]{3}e'); -> 1 3mysql> SELECT REGEXP_LIKE('abcde', 'a[bcd]{1,10}e'); -> 1
[a-dX], [^a-dX]^가 사용되지 않은 경우 a, b, c, d 또는 X 중 하나인 문자를(또는 ^가 사용된 경우 그러한 문자가 아닌 모든 문자)를 매칭합니다. 두 문자 사이의 - 문자는 첫 번째 문자부터 두 번째 문자까지 범위를 형성하여 그 범위 내 모든 문자를 매칭합니다. 예를 들어, [0-9]는 모든 10진 숫자와 매칭됩니다. 리터럴 ] 문자를 포함하려면 이를 여는 대괄호 [ 바로 뒤에 작성해야 합니다. 리터럴 - 문자를 포함하려면 이를 가장 처음이나 마지막에 작성해야 합니다. [] 쌍 내부에서 특별한 의미가 정의되지 않은 문자는 그 문자 자체와만 매칭됩니다.
1mysql> SELECT REGEXP_LIKE('aXbc', '[a-dXYZ]'); -> 1 2mysql> SELECT REGEXP_LIKE('aXbc', '^[a-dXYZ]$'); -> 0 3mysql> SELECT REGEXP_LIKE('aXbc', '^[a-dXYZ]+$'); -> 1 4mysql> SELECT REGEXP_LIKE('aXbc', '^[^a-dXYZ]+$'); -> 0 5mysql> SELECT REGEXP_LIKE('gheis', '^[^a-dXYZ]+$'); -> 1 6mysql> SELECT REGEXP_LIKE('gheisa', '^[^a-dXYZ]+$'); -> 0
[=character_class=]대괄호 표현식(즉, [ 와 ] 으로 작성되는) 내부에서, [=character_class=]는 동등 클래스(equivalence class)를 나타냅니다. 이는 동일한 콜레이션 값을 가진 모든 문자(자기 자신 포함)와 매칭됩니다. 예를 들어, o와 (+)가 동일 동등 클래스의 멤버라면, [[=o=]], [[=(+)=]], [o(+)]는 모두 동의어입니다. 동등 클래스는 범위의 끝점으로 사용할 수 없습니다.
[:character_class:]대괄호 표현식(즉, [ 와 ] 으로 작성되는) 내부에서, [:character_class:]는 해당 클래스에 속하는 모든 문자와 매칭되는 문자 클래스(character class)를 나타냅니다. 다음 표는 표준 클래스 이름을 나열합니다. 이러한 이름은 ctype(3) 매뉴얼 페이지에 정의된 문자 클래스를 의미합니다. 특정 로케일은 다른 클래스 이름을 제공할 수 있습니다. 문자 클래스는 범위의 끝점으로 사용할 수 없습니다.
| Character Class Name | Meaning |
|---|---|
alnum | Alphanumeric characters |
alpha | Alphabetic characters |
blank | Whitespace characters |
cntrl | Control characters |
digit | Digit characters |
graph | Graphic characters |
lower | Lowercase alphabetic characters |
print | Graphic or space characters |
punct | Punctuation characters |
space | Space, tab, newline, and carriage return |
upper | Uppercase alphabetic characters |
xdigit | Hexadecimal digit characters |
| Character Class Name | Meaning |
|---|
1mysql> SELECT REGEXP_LIKE('justalnums', '[[:alnum:]]+'); -> 1 2mysql> SELECT REGEXP_LIKE('!!', '[[:alnum:]]+'); -> 0
정규 표현식에서 특수 문자의 리터럴 인스턴스를 사용하려면, 그 앞에 백슬래시(\) 두 개를 붙입니다. MySQL 파서는 백슬래시 중 하나를 해석하고, 정규 표현식 라이브러리는 나머지 하나를 해석합니다. 예를 들어, 특수 문자 +를 포함하는 문자열 1+2와 매칭하려면, 다음 정규 표현식 중 마지막 것만이 올바른 표현입니다:
1mysql> SELECT REGEXP_LIKE('1+2', '1+2'); -> 0 2mysql> SELECT REGEXP_LIKE('1+2', '1\+2'); -> 0 3mysql> SELECT REGEXP_LIKE('1+2', '1\\+2'); -> 1
REGEXP_LIKE() 및 유사한 함수는 시스템 변수를 설정하여 제어할 수 있는 리소스를 사용합니다:
매치 엔진은 내부 스택을 위해 메모리를 사용합니다. 스택에 사용할 수 있는 최대 메모리(바이트 단위)를 제어하려면 regexp_stack_limit 시스템 변수를 설정하십시오.
매치 엔진은 여러 단계로 동작합니다. 엔진이 수행하는 최대 단계 수(따라서 간접적으로 실행 시간)를 제어하려면 regexp_time_limit 시스템 변수를 설정하십시오. 이 제한은 단계 수로 표현되므로 실행 시간에 간접적으로만 영향을 미칩니다. 일반적으로 밀리초 단위 수준입니다.
14.8.1 String Comparison Functions and Operators
14.8.3 Character Set and Collation of Function Results