[REGEX] :: POSIX BRE Meta Character '' 7. { } ( brace ) ''

POSIX BRE( Basic Regular Expression )

1. ^
2. $
3. .
4. *
5. \
6. (
7. {
8. [

---

7. { } ( Brace, 중괄호 )

구문 ( Syntax )

<left_brace> ::= {

<right_brace> ::= }

• 사용 예

  <pattern_expr><left_brace><brace_expr><right_brace>
  
  <brace_expr> ::=
    <integer_1>
  | <integer_1><comma>
  | <integer_1><comma><integer_2>
  
  <comma> ::= ,
  
  

설명 ( Description )

• 수량자(quantifier)로, <left_brace> 앞에 있는 <pattern_expr>의 '개수, 반복 횟수'를 의미한다.

• <brace_expr>에 하나의 <integer_1> 만 명시한 경우
  • 정확히 <integer>개를 의미한다.
    • ex) a{2} => aa
    • ex) (ab){3} => ababab

• <brace_expr>에 <integer_1>와 <comma>를 명시한 경우
  • <integer>개 이상을 의미한다.
    • ex) a{3,} => aaa, aaaa, aaaaa, ...

• <brace_expr>에 <integer_1>, <comma>, <integer_2>를 명시한 경우
  • <integer_1>개 이상 <integer_2>개 이하를 의미한다.
    • ex) go{1, 3} => go, goo, gooo
  • <integer_1> ≤ <integer_2> 를 만족해야 한다. ( <integer_1> ＞ <integer_2> 인 경우 error 처리 )
    • ex) (ab){5,2} => error 처리

• 지정된 사용법이 아닌 경우
  • <integer_1>에 음수 및 소수가 있는 경우
    • ex) a{-1}
    • ex) z{1.5}
  • <comma>가 아닌 다른 문자가 있는 경우( 숫자 아닌 문자 )
    • ex) g{1~10}
  • <comma> 뒤에 <integer_2>가 아닌 다른 문자가 있는 경우
    • ex) (ab){2,s}
  • 맨 뒤에 <right_brace>가 없는 경우
    • ex) c{3,5
  • 결과
    • Oracle, MariaDB는 전체를 str (일반 문자)로 처리한다.
    • PostreSQL, MySQL은 error 처리한다.

• <integer_1> 이 0인 경우, zero-length match가 발생할 수 있다.

  • ex) c{0}
  • ex) z{0,}
  • ex) (ab){0, 5}

• <brace_expr>에 아무것도 명시하지 않은 경우
  • ex) a{}
  • 결과
    • Oracle, PostgreSQL, MariaDB : string 처리
    • MySQL : error 처리

• <pattern_expr>이 <left_brace> 앞에 명시되어있지 않은 경우
  • ex) {3}
  • 결과
    • Oracle : zero-length match
    • PostgreSQL, MySQL, MariaDB : error 처리

예제 ( Examples )

SQL> SELECT REGEXP_SUBSTR( 'aaaab', 'a{2}' ) AS RESULT FROM DUAL;

RESULT
--------------------
aa

SQL> SELECT REGEXP_SUBSTR( 'aaaab', 'a{1,}' ) AS RESULT FROM DUAL;

RESULT
--------------------
aaaa

SQL> SELECT REGEXP_SUBSTR( 'aaaab', 'a{1,3}' ) AS RESULT FROM DUAL;

RESULT
--------------------
aaa

• 지정된 사용법이 아닌 경우

  SQL> SELECT REGEXP_SUBSTR( 'aaa', 'a{-1}' ) AS RESULT FROM DUAL;
  
  RESULT
  ------------------------------
  NULL
  
  SQL> SELECT REGEXP_SUBSTR( 'a{-1}', 'a{-1}' ) AS RESULT FROM DUAL;
  
  RESULT
  ------------------------------
  a{-1}
  
  SQL> SELECT REGEXP_SUBSTR( 'aaa', 'a{1~3}' ) AS RESULT FROM DUAL;
  
  RESULT
  ------------------------------
  NULL
  
  SQL> SELECT REGEXP_SUBSTR( 'a{1~3}', 'a{1~3}' ) AS RESULT FROM DUAL;
  
  RESULT
  ------------------------------
  a{1~3}
  
  SQL> SELECT REGEXP_SUBSTR( 'aaa', 'a{1.5}' ) AS RESULT FROM DUAL;
  
  RESULT
  ------------------------------
  NULL
  
  SQL> SELECT REGEXP_SUBSTR( 'a{1.5}', 'a{1.5}' ) AS RESULT FROM DUAL;
  
  RESULT
  ------------------------------
  a{1.5}
  
  SQL> SELECT REGEXP_SUBSTR( 'zzz', 'z{1,a}' ) AS RESULT FROM DUAL;
  
  RESULT
  ------------------------------
  NULL
  
  SQL> SELECT REGEXP_SUBSTR( 'z{1,a}', 'z{1,a}' ) AS RESULT FROM DUAL;
  
  RESULT
  ------------------------------
  z{1,a}
  
  SQL> SELECT REGEXP_SUBSTR( 'zzz', 'z{1, 2}' ) AS RESULT FROM DUAL;
  
  RESULT
  ------------------------------
  NULL
  
  SQL> SELECT REGEXP_SUBSTR( 'z{1, 2}', 'z{1, 2}' ) AS RESULT FROM DUAL;
  
  RESULT
  ------------------------------
  z{1, 2}
  
  SQL> SELECT REGEXP_SUBSTR( 'aaa', 'a{1' ) AS RESULT FROM DUAL;
  
  RESULT
  ------------------------------
  NULL
  
  SQL> SELECT REGEXP_SUBSTR( 'a{1', 'a{1' ) AS RESULT FROM DUAL;
  
  RESULT
  ------------------------------
  a{1
  
  SQL> SELECT REGEXP_SUBSTR( 'zzz', 'z{1,' ) AS RESULT FROM DUAL;
  
  RESULT
  ------------------------------
  NULL
  
  SQL> SELECT REGEXP_SUBSTR( 'z{1,', 'z{1,' ) AS RESULT FROM DUAL;
  
  RESULT
  ------------------------------
  z{1,
  
  SQL> SELECT REGEXP_SUBSTR( 'zzz', 'z{1,3' ) AS RESULT FROM DUAL;
  
  RESULT
  ------------------------------
  NULL
  
  SQL> SELECT REGEXP_SUBSTR( 'z{1,3', 'z{1,3' ) AS RESULT FROM DUAL;
  
  RESULT
  ------------------------------
  z{1,3
  
  
  < MariaDB >
  MariaDB [test]> SELECT REGEXP_SUBSTR( 'a{1~3}', 'a{1~3}' ) AS RESULT FROM DUAL;
  +--------+
  | RESULT |
  +--------+
  | a{1~3} |
  +--------+
  1 row in set (0.001 sec)
  
  
  < PostgreSQL >
  postgres=# SELECT REGEXP_MATCHES( 'a{1,3', 'a{1~3}' ) AS RESULT;
  ERROR:  invalid regular expression: invalid repetition count(s)
  
  
  < MySQL >
  mysql> SELECT REGEXP_SUBSTR( 'aaa', 'a{1~3}' ) AS RESULT FROM DUAL;
  ERROR 3692 (HY000): Incorrect description of a {min,max} interval.
  
  
  ※ Oracle, MariaDB는 지정된 사용법이 아니라면 모두 string 처리하는 반면
     PostgreSQL, MySQL은 error 처리한다.
  

• <integer>, <integer_1> 이 0인 경우

  SQL> SELECT REGEXP_SUBSTR( 'abc', 'z{0}' ) AS RESULT FROM DUAL;
  
  RESULT
  ------------------------------
  NULL
  
  SQL> SELECT REGEXP_COUNT( 'abc', 'z{0}' ) AS RESULT FROM DUAL;
  
      RESULT
  ----------
           4
  
  
  SQL> SELECT REGEXP_SUBSTR( 'abc', 'z{0,}' ) AS RESULT FROM DUAL;
  
  RESULT
  ------------------------------
  NULL
  
  SQL> SELECT REGEXP_COUNT( 'abc', 'z{0,}' ) AS RESULT FROM DUAL;
  
      RESULT
  ----------
           4
  
  
  SQL> SELECT REGEXP_SUBSTR( 'abc', 'z{0,10}' ) AS RESULT FROM DUAL;
  
  RESULT
  ------------------------------
  NULL
  
  SQL> SELECT REGEXP_COUNT( 'abc', 'z{0,10}' ) AS RESULT FROM DUAL;
  
      RESULT
  ----------
           4
  
  
  SQL> SELECT REGEXP_SUBSTR( 'abc', '(abc){0}' ) AS RESULT FROM DUAL;
  
  RESULT
  ------------------------------
  NULL
  
  SQL> SELECT REGEXP_COUNT( 'abc', '(abc){0}' ) AS RESULT FROM DUAL;
  
      RESULT
  ----------
           4
  
  
  SQL> SELECT REGEXP_SUBSTR( 'abc', '(abc){0,}' ) AS RESULT FROM DUAL;
  
  RESULT
  ------------------------------
  abc
  
  SQL> SELECT REGEXP_COUNT( 'abc', '(abc){0,}' ) AS RESULT FROM DUAL;
  
      RESULT
  ----------
           2
  
  
  SQL> SELECT REGEXP_SUBSTR( 'abc', '(def){0,}' ) AS RESULT FROM DUAL;
  
  RESULT
  ------------------------------
  NULL
  
  SQL> SELECT REGEXP_COUNT( 'abc', '(def){0,}' ) AS RESULT FROM DUAL;
  
      RESULT
  ----------
           4
  

• <brace_expr>에 아무것도 명시하지 않은 경우

  < Oracle >
  SQL> SELECT REGEXP_SUBSTR( 'aaa', 'a{}' ) AS RESULT FROM DUAL;
  
  RESULT
  ------------------------------
  NULL
  
  SQL> SELECT REGEXP_SUBSTR( 'a{}', 'a{}' ) AS RESULT FROM DUAL;
  
  RESULT
  ------------------------------
  a{}
  
  
  < PostgreSQL >
  postgres=# SELECT REGEXP_MATCHES( 'aaa', 'a{}', 'g' ) AS RESULT;
   result 
  --------
  (0개 행)
  
  postgres=# SELECT REGEXP_MATCHES( 'a{}', 'a{}', 'g' ) AS RESULT;
   result  
  ---------
   {"a{}"}
  (1개 행)
  
  
  < MariaDB >
  MariaDB [test]> SELECT REGEXP_SUBSTR( 'aaa', 'a{}' ) AS RESULT;
  +--------+
  | RESULT |
  +--------+
  |        |
  +--------+
  1 row in set (0.001 sec)
  
  MariaDB [test]> SELECT REGEXP_SUBSTR( 'a{}', 'a{}' ) AS RESULT;
  +--------+
  | RESULT |
  +--------+
  | a{}    |
  +--------+
  1 row in set (0.001 sec)
  
  
  < MySQL >
  mysql> SELECT REGEXP_SUBSTR( 'aaa', 'a{}' ) AS RESULT;
  ERROR 3692 (HY000): Incorrect description of a {min,max} interval.
  
  
  ※ Oracle, PostgreSQL, MariaDB는 모두 string 처리하는 반면
     MySQL은 error 처리한다.
  

• <pattern_expr>이 <left_brace> 앞에 명시되어있지 않은 경우

  < Oracle >
  SQL> SELECT REGEXP_SUBSTR( 'aaa', '{5}' ) AS RESULT FROM DUAL;
  
  RESULT
  ------------------------------
  NULL
  
  SQL> SELECT REGEXP_COUNT( 'aaa', '{5}' ) AS RESULT FROM DUAL;
  
      RESULT
  ----------
           4
  
  
  < PostgreSQL >
  postgres=# SELECT REGEXP_MATCHES( 'aaa', '{5}', 'g' ) AS RESULT;
  ERROR:  invalid regular expression: quantifier operand invalid
  
  
  < MySQL >
  mysql> SELECT REGEXP_SUBSTR( 'aaa', '{5}' ) AS RESULT;
  ERROR 3688 (HY000): Syntax error in regular expression on line 1, character 1.
  
  
  < MariaDB >
  MariaDB [test]> SELECT REGEXP_SUBSTR( 'aaa', '{5}' ) AS RESULT;
  ERROR 1139 (42000): Got error 'nothing to repeat at offset 2' from regexp