Spracherkennung für: .out vermutete Sprache: Unknown {[0] [0] [0]} [Methode: Schwerpunktbildung, einfache Gewichte, sechs Dimensionen]
-- This file is based on tests/reg.test from the Tcl distribution,
-- which is marked
-- # Copyright (c)
1998,
1999 Henry Spencer. All rights reserved.
-- The full copyright notice can be found in src/backend/regex/COPYRIGHT.
-- Most commented lines below are copied from reg.test. Each
-- test case is followed by an equivalent test using test_regex().
create extension test_regex;
set standard_conforming_strings = on;
-- # support functions and preliminary misc.
-- # This is sensitive to changes in message wording, but we really have to
-- # test the code->message expansion at least once.
-- ::tcltest::test reg-
0.
1 "regexp error reporting" {
-- list [catch {regexp (*) ign} msg] $msg
-- } {
1 {couldn't compile regular expression pattern: quantifier operand invalid}}
select * from test_regex('(*)', '', '');
ERROR: invalid regular expression: quantifier operand invalid
-- doing
1 "basic sanity checks"
-- expectMatch
1.
1 & abc abc abc
select * from test_regex('abc', 'abc', '');
test_regex
------------
{
0}
{abc}
(
2 rows)
select * from test_regex('abc', 'abc', 'b');
test_regex
------------
{
0}
{abc}
(
2 rows)
-- expectNomatch
1.
2 & abc def
select * from test_regex('abc', 'def', '');
test_regex
------------
{
0}
(
1 row)
select * from test_regex('abc', 'def', 'b');
test_regex
------------
{
0}
(
1 row)
-- expectMatch
1.
3 & abc xyabxabce abc
select * from test_regex('abc', 'xyabxabce', '');
test_regex
------------
{
0}
{abc}
(
2 rows)
select * from test_regex('abc', 'xyabxabce', 'b');
test_regex
------------
{
0}
{abc}
(
2 rows)
-- doing
2 "invalid option combinations"
-- expectError
2.
1 qe a INVARG
select * from test_regex('a', '', 'qe');
ERROR: invalid regular expression: invalid argument to regex function
-- expectError
2.
2 qa a INVARG
select * from test_regex('a', '', 'qa');
ERROR: invalid regular expression: invalid argument to regex function
-- expectError
2.
3 qx a INVARG
select * from test_regex('a', '', 'qx');
ERROR: invalid regular expression: invalid argument to regex function
-- expectError
2.
4 qn a INVARG
select * from test_regex('a', '', 'qn');
ERROR: invalid regular expression: invalid argument to regex function
-- expectError
2.
5 ba a INVARG
select * from test_regex('a', '', 'ba');
ERROR: invalid regular expression: invalid argument to regex function
-- doing
3 "basic syntax"
-- expectIndices
3.
1 &NS "" a {
0 -
1}
select * from test_regex('', 'a', '
0NS');
test_regex
---------------------------------
{
0,REG_UUNSPEC,REG_UEMPTYMATCH}
{"
0 -
1"}
(
2 rows)
select * from test_regex('', 'a', '
0NSb');
test_regex
---------------------------------
{
0,REG_UUNSPEC,REG_UEMPTYMATCH}
{"
0 -
1"}
(
2 rows)
-- expectMatch
3.
2 NS a| a a
select * from test_regex('a|', 'a', 'NS');
test_regex
---------------------------------
{
0,REG_UUNSPEC,REG_UEMPTYMATCH}
{a}
(
2 rows)
-- expectMatch
3.
3 - a|b a a
select * from test_regex('a|b', 'a', '-');
test_regex
------------
{
0}
{a}
(
2 rows)
-- expectMatch
3.
4 - a|b b b
select * from test_regex('a|b', 'b', '-');
test_regex
------------
{
0}
{b}
(
2 rows)
-- expectMatch
3.
5 NS a||b b b
select * from test_regex('a||b', 'b', 'NS');
test_regex
---------------------------------
{
0,REG_UUNSPEC,REG_UEMPTYMATCH}
{b}
(
2 rows)
-- expectMatch
3.
6 & ab ab ab
select * from test_regex('ab', 'ab', '');
test_regex
------------
{
0}
{ab}
(
2 rows)
select * from test_regex('ab', 'ab', 'b');
test_regex
------------
{
0}
{ab}
(
2 rows)
-- doing
4 "parentheses"
-- expectMatch
4.
1 - (a)e ae ae a
select * from test_regex('(a)e', 'ae', '-');
test_regex
------------
{
1}
{ae,a}
(
2 rows)
-- expectMatch
4.
2 oPR (.)\
1e abeaae aae {}
select * from test_regex('(.)\
1e', 'abeaae', 'oPR');
test_regex
--------------------------------
{
1,REG_UBACKREF,REG_UNONPOSIX}
{aae,NULL}
(
2 rows)
-- expectMatch
4.
3 b {\(a\)b} ab ab a
select * from test_regex('\(a\)b', 'ab', 'b');
test_regex
------------
{
1}
{ab,a}
(
2 rows)
-- expectMatch
4.
4 - a((b)c) abc abc bc b
select * from test_regex('a((b)c)', 'abc', '-');
test_regex
------------
{
2}
{abc,bc,b}
(
2 rows)
-- expectMatch
4.
5 - a(b)(c) abc abc b c
select * from test_regex('a(b)(c)', 'abc', '-');
test_regex
------------
{
2}
{abc,b,c}
(
2 rows)
-- expectError
4.
6 - a(b EPAREN
select * from test_regex('a(b', '', '-');
ERROR: invalid regular expression: parentheses () not balanced
-- expectError
4.
7 b {a\(b} EPAREN
select * from test_regex('a\(b', '', 'b');
ERROR: invalid regular expression: parentheses () not balanced
-- # sigh, we blew it on the specs here... someday this will be fixed in POSIX,
-- # but meanwhile, it's fixed in AREs
-- expectMatch
4.
8 eU a)b a)b a)b
select * from test_regex('a)b', 'a)b', 'eU');
test_regex
-----------------
{
0,REG_UPBOTCH}
{a)b}
(
2 rows)
-- expectError
4.
9 - a)b EPAREN
select * from test_regex('a)b', '', '-');
ERROR: invalid regular expression: parentheses () not balanced
-- expectError
4.
10 b {a\)b} EPAREN
select * from test_regex('a\)b', '', 'b');
ERROR: invalid regular expression: parentheses () not balanced
-- expectMatch
4.
11 P a(?:b)c abc abc
select * from test_regex('a(?:b)c', 'abc', 'P');
test_regex
-------------------
{
0,REG_UNONPOSIX}
{abc}
(
2 rows)
-- expectError
4.
12 e a(?:b)c BADRPT
select * from test_regex('a(?:b)c', '', 'e');
ERROR: invalid regular expression: quantifier operand invalid
-- expectIndices
4.
13 S a()b ab {
0 1} {
1 0}
select * from test_regex('a()b', 'ab', '
0S');
test_regex
-----------------
{
1,REG_UUNSPEC}
{"
0 1","
1 0"}
(
2 rows)
-- expectMatch
4.
14 SP a(?:)b ab ab
select * from test_regex('a(?:)b', 'ab', 'SP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_UUNSPEC}
{ab}
(
2 rows)
-- expectIndices
4.
15 S a(|b)c ac {
0 1} {
1 0}
select * from test_regex('a(|b)c', 'ac', '
0S');
test_regex
-----------------
{
1,REG_UUNSPEC}
{"
0 1","
1 0"}
(
2 rows)
-- expectMatch
4.
16 S a(b|)c abc abc b
select * from test_regex('a(b|)c', 'abc', 'S');
test_regex
-----------------
{
1,REG_UUNSPEC}
{abc,b}
(
2 rows)
-- doing
5 "simple one-char matching"
-- # general case of brackets done later
-- expectMatch
5.
1 & a.b axb axb
select * from test_regex('a.b', 'axb', '');
test_regex
------------
{
0}
{axb}
(
2 rows)
select * from test_regex('a.b', 'axb', 'b');
test_regex
------------
{
0}
{axb}
(
2 rows)
-- expectNomatch
5.
2 &n "a.b" "a\nb"
select * from test_regex('a.b', E'a\nb', 'n');
test_regex
------------
{
0}
(
1 row)
select * from test_regex('a.b', E'a\nb', 'nb');
test_regex
------------
{
0}
(
1 row)
-- expectMatch
5.
3 & {a[bc]d} abd abd
select * from test_regex('a[bc]d', 'abd', '');
test_regex
------------
{
0}
{abd}
(
2 rows)
select * from test_regex('a[bc]d', 'abd', 'b');
test_regex
------------
{
0}
{abd}
(
2 rows)
-- expectMatch
5.
4 & {a[bc]d} acd acd
select * from test_regex('a[bc]d', 'acd', '');
test_regex
------------
{
0}
{acd}
(
2 rows)
select * from test_regex('a[bc]d', 'acd', 'b');
test_regex
------------
{
0}
{acd}
(
2 rows)
-- expectNomatch
5.
5 & {a[bc]d} aed
select * from test_regex('a[bc]d', 'aed', '');
test_regex
------------
{
0}
(
1 row)
select * from test_regex('a[bc]d', 'aed', 'b');
test_regex
------------
{
0}
(
1 row)
-- expectNomatch
5.
6 & {a[^bc]d} abd
select * from test_regex('a[^bc]d', 'abd', '');
test_regex
------------
{
0}
(
1 row)
select * from test_regex('a[^bc]d', 'abd', 'b');
test_regex
------------
{
0}
(
1 row)
-- expectMatch
5.
7 & {a[^bc]d} aed aed
select * from test_regex('a[^bc]d', 'aed', '');
test_regex
------------
{
0}
{aed}
(
2 rows)
select * from test_regex('a[^bc]d', 'aed', 'b');
test_regex
------------
{
0}
{aed}
(
2 rows)
-- expectNomatch
5.
8 &p "a\[^bc]d" "a\nd"
select * from test_regex('a[^bc]d', E'a\nd', 'p');
test_regex
------------
{
0}
(
1 row)
select * from test_regex('a[^bc]d', E'a\nd', 'pb');
test_regex
------------
{
0}
(
1 row)
-- doing
6 "context-dependent syntax"
-- # plus odds and ends
-- expectError
6.
1 - * BADRPT
select * from test_regex('*', '', '-');
ERROR: invalid regular expression: quantifier operand invalid
-- expectMatch
6.
2 b * * *
select * from test_regex('*', '*', 'b');
test_regex
------------
{
0}
{*}
(
2 rows)
-- expectMatch
6.
3 b {\(*\)} * * *
select * from test_regex('\(*\)', '*', 'b');
test_regex
------------
{
1}
{*,*}
(
2 rows)
-- expectError
6.
4 - (*) BADRPT
select * from test_regex('(*)', '', '-');
ERROR: invalid regular expression: quantifier operand invalid
-- expectMatch
6.
5 b ^* * *
select * from test_regex('^*', '*', 'b');
test_regex
------------
{
0}
{*}
(
2 rows)
-- expectError
6.
6 - ^* BADRPT
select * from test_regex('^*', '', '-');
ERROR: invalid regular expression: quantifier operand invalid
-- expectNomatch
6.
7 & ^b ^b
select * from test_regex('^b', '^b', '');
test_regex
------------
{
0}
(
1 row)
select * from test_regex('^b', '^b', 'b');
test_regex
------------
{
0}
(
1 row)
-- expectMatch
6.
8 b x^ x^ x^
select * from test_regex('x^', 'x^', 'b');
test_regex
------------
{
0}
{x^}
(
2 rows)
-- expectNomatch
6.
9 I x^ x
select * from test_regex('x^', 'x', 'I');
test_regex
---------------------
{
0,REG_UIMPOSSIBLE}
(
1 row)
-- expectMatch
6.
10 n "\n^" "x\nb" "\n"
select * from test_regex(E'\n^', E'x\nb', 'n');
test_regex
------------
{
0}
{" +
"}
(
2 rows)
-- expectNomatch
6.
11 bS {\(^b\)} ^b
select * from test_regex('\(^b\)', '^b', 'bS');
test_regex
-----------------
{
1,REG_UUNSPEC}
(
1 row)
-- expectMatch
6.
12 - (^b) b b b
select * from test_regex('(^b)', 'b', '-');
test_regex
------------
{
1}
{b,b}
(
2 rows)
-- expectMatch
6.
13 & {x$} x x
select * from test_regex('x$', 'x', '');
test_regex
------------
{
0}
{x}
(
2 rows)
select * from test_regex('x$', 'x', 'b');
test_regex
------------
{
0}
{x}
(
2 rows)
-- expectMatch
6.
14 bS {\(x$\)} x x x
select * from test_regex('\(x$\)', 'x', 'bS');
test_regex
-----------------
{
1,REG_UUNSPEC}
{x,x}
(
2 rows)
-- expectMatch
6.
15 - {(x$)} x x x
select * from test_regex('(x$)', 'x', '-');
test_regex
------------
{
1}
{x,x}
(
2 rows)
-- expectMatch
6.
16 b {x$y} "x\$y" "x\$y"
select * from test_regex('x$y', 'x$y', 'b');
test_regex
------------
{
0}
{x$y}
(
2 rows)
-- expectNomatch
6.
17 I {x$y} xy
select * from test_regex('x$y', 'xy', 'I');
test_regex
---------------------
{
0,REG_UIMPOSSIBLE}
(
1 row)
-- expectMatch
6.
18 n "x\$\n" "x\n" "x\n"
select * from test_regex(E'x$\n', E'x\n', 'n');
test_regex
------------
{
0}
{"x +
"}
(
2 rows)
-- expectError
6.
19 - + BADRPT
select * from test_regex('+', '', '-');
ERROR: invalid regular expression: quantifier operand invalid
-- expectError
6.
20 - ? BADRPT
select * from test_regex('?', '', '-');
ERROR: invalid regular expression: quantifier operand invalid
-- These two are not yet incorporated in Tcl, cf
--
https://core.tcl-lang.org/tcl/tktview?name=5ea71fdcd3291c38
-- expectError
6.
21 - {x(\w)(?=(\
1))} ESUBREG
select * from test_regex('x(\w)(?=(\
1))', '', '-');
ERROR: invalid regular expression: invalid backreference number
-- expectMatch
6.
22 HP {x(?=((foo)))} xfoo x
select * from test_regex('x(?=((foo)))', 'xfoo', 'HP');
test_regex
-----------------------------------
{
0,REG_ULOOKAROUND,REG_UNONPOSIX}
{x}
(
2 rows)
-- doing
7 "simple quantifiers"
-- expectMatch
7.
1 &N a* aa aa
select * from test_regex('a*', 'aa', 'N');
test_regex
---------------------
{
0,REG_UEMPTYMATCH}
{aa}
(
2 rows)
select * from test_regex('a*', 'aa', 'Nb');
test_regex
---------------------
{
0,REG_UEMPTYMATCH}
{aa}
(
2 rows)
-- expectIndices
7.
2 &N a* b {
0 -
1}
select * from test_regex('a*', 'b', '
0N');
test_regex
---------------------
{
0,REG_UEMPTYMATCH}
{"
0 -
1"}
(
2 rows)
select * from test_regex('a*', 'b', '
0Nb');
test_regex
---------------------
{
0,REG_UEMPTYMATCH}
{"
0 -
1"}
(
2 rows)
-- expectMatch
7.
3 - a+ aa aa
select * from test_regex('a+', 'aa', '-');
test_regex
------------
{
0}
{aa}
(
2 rows)
-- expectMatch
7.
4 - a?b ab ab
select * from test_regex('a?b', 'ab', '-');
test_regex
------------
{
0}
{ab}
(
2 rows)
-- expectMatch
7.
5 - a?b b b
select * from test_regex('a?b', 'b', '-');
test_regex
------------
{
0}
{b}
(
2 rows)
-- expectError
7.
6 - ** BADRPT
select * from test_regex('**', '', '-');
ERROR: invalid regular expression: quantifier operand invalid
-- expectMatch
7.
7 bN ** *** ***
select * from test_regex('**', '***', 'bN');
test_regex
---------------------
{
0,REG_UEMPTYMATCH}
{***}
(
2 rows)
-- expectError
7.
8 & a** BADRPT
select * from test_regex('a**', '', '');
ERROR: invalid regular expression: quantifier operand invalid
select * from test_regex('a**', '', 'b');
ERROR: invalid regular expression: quantifier operand invalid
-- expectError
7.
9 & a**b BADRPT
select * from test_regex('a**b', '', '');
ERROR: invalid regular expression: quantifier operand invalid
select * from test_regex('a**b', '', 'b');
ERROR: invalid regular expression: quantifier operand invalid
-- expectError
7.
10 & *** BADRPT
select * from test_regex('***', '', '');
ERROR: invalid regular expression: quantifier operand invalid
select * from test_regex('***', '', 'b');
ERROR: invalid regular expression: quantifier operand invalid
-- expectError
7.
11 - a++ BADRPT
select * from test_regex('a++', '', '-');
ERROR: invalid regular expression: quantifier operand invalid
-- expectError
7.
12 - a?+ BADRPT
select * from test_regex('a?+', '', '-');
ERROR: invalid regular expression: quantifier operand invalid
-- expectError
7.
13 - a?* BADRPT
select * from test_regex('a?*', '', '-');
ERROR: invalid regular expression: quantifier operand invalid
-- expectError
7.
14 - a+* BADRPT
select * from test_regex('a+*', '', '-');
ERROR: invalid regular expression: quantifier operand invalid
-- expectError
7.
15 - a*+ BADRPT
select * from test_regex('a*+', '', '-');
ERROR: invalid regular expression: quantifier operand invalid
-- tests for ancient brenext() bugs; not currently in Tcl
select * from test_regex('.*b', 'aaabbb', 'b');
test_regex
------------
{
0}
{aaabbb}
(
2 rows)
select * from test_regex('.\{
1,
10\}', 'abcdef', 'bQ');
test_regex
-----------------
{
0,REG_UBOUNDS}
{abcdef}
(
2 rows)
-- doing
8 "braces"
-- expectMatch
8.
1 NQ "a{
0,
1}" "" ""
select * from test_regex('a{
0,
1}', '', 'NQ');
test_regex
---------------------------------
{
0,REG_UBOUNDS,REG_UEMPTYMATCH}
{""}
(
2 rows)
-- expectMatch
8.
2 NQ "a{
0,
1}" ac a
select * from test_regex('a{
0,
1}', 'ac', 'NQ');
test_regex
---------------------------------
{
0,REG_UBOUNDS,REG_UEMPTYMATCH}
{a}
(
2 rows)
-- expectError
8.
3 - "a{
1,
0}" BADBR
select * from test_regex('a{
1,
0}', '', '-');
ERROR: invalid regular expression: invalid repetition count(s)
-- expectError
8.
4 - "a{
1,
2,
3}" BADBR
select * from test_regex('a{
1,
2,
3}', '', '-');
ERROR: invalid regular expression: invalid repetition count(s)
-- expectError
8.
5 - "a{
257}" BADBR
select * from test_regex('a{
257}', '', '-');
ERROR: invalid regular expression: invalid repetition count(s)
-- expectError
8.
6 - "a{
1000}" BADBR
select * from test_regex('a{
1000}', '', '-');
ERROR: invalid regular expression: invalid repetition count(s)
-- expectError
8.
7 - "a{
1" EBRACE
select * from test_regex('a{
1', '', '-');
ERROR: invalid regular expression: braces {} not balanced
-- expectError
8.
8 - "a{
1n}" BADBR
select * from test_regex('a{
1n}', '', '-');
ERROR: invalid regular expression: invalid repetition count(s)
-- expectMatch
8.
9 BS "a{b" "a\{b" "a\{b"
select * from test_regex('a{b', 'a{b', 'BS');
test_regex
-----------------------------
{
0,REG_UBRACES,REG_UUNSPEC}
{"a{b"}
(
2 rows)
-- expectMatch
8.
10 BS "a{" "a\{" "a\{"
select * from test_regex('a{', 'a{', 'BS');
test_regex
-----------------------------
{
0,REG_UBRACES,REG_UUNSPEC}
{"a{"}
(
2 rows)
-- expectMatch
8.
11 bQ "a\\{
0,
1\\}b" cb b
select * from test_regex('a\{
0,
1\}b', 'cb', 'bQ');
test_regex
-----------------
{
0,REG_UBOUNDS}
{b}
(
2 rows)
-- expectError
8.
12 b "a\\{
0,
1" EBRACE
select * from test_regex('a\{
0,
1', '', 'b');
ERROR: invalid regular expression: braces {} not balanced
-- expectError
8.
13 - "a{
0,
1\\" BADBR
select * from test_regex('a{
0,
1\', '', '-');
ERROR: invalid regular expression: invalid repetition count(s)
-- expectMatch
8.
14 Q "a{
0}b" ab b
select * from test_regex('a{
0}b', 'ab', 'Q');
test_regex
-----------------
{
0,REG_UBOUNDS}
{b}
(
2 rows)
-- expectMatch
8.
15 Q "a{
0,
0}b" ab b
select * from test_regex('a{
0,
0}b', 'ab', 'Q');
test_regex
-----------------
{
0,REG_UBOUNDS}
{b}
(
2 rows)
-- expectMatch
8.
16 Q "a{
0,
1}b" ab ab
select * from test_regex('a{
0,
1}b', 'ab', 'Q');
test_regex
-----------------
{
0,REG_UBOUNDS}
{ab}
(
2 rows)
-- expectMatch
8.
17 Q "a{
0,
2}b" b b
select * from test_regex('a{
0,
2}b', 'b', 'Q');
test_regex
-----------------
{
0,REG_UBOUNDS}
{b}
(
2 rows)
-- expectMatch
8.
18 Q "a{
0,
2}b" aab aab
select * from test_regex('a{
0,
2}b', 'aab', 'Q');
test_regex
-----------------
{
0,REG_UBOUNDS}
{aab}
(
2 rows)
-- expectMatch
8.
19 Q "a{
0,}b" aab aab
select * from test_regex('a{
0,}b', 'aab', 'Q');
test_regex
-----------------
{
0,REG_UBOUNDS}
{aab}
(
2 rows)
-- expectMatch
8.
20 Q "a{
1,
1}b" aab ab
select * from test_regex('a{
1,
1}b', 'aab', 'Q');
test_regex
-----------------
{
0,REG_UBOUNDS}
{ab}
(
2 rows)
-- expectMatch
8.
21 Q "a{
1,
3}b" aaaab aaab
select * from test_regex('a{
1,
3}b', 'aaaab', 'Q');
test_regex
-----------------
{
0,REG_UBOUNDS}
{aaab}
(
2 rows)
-- expectNomatch
8.
22 Q "a{
1,
3}b" b
select * from test_regex('a{
1,
3}b', 'b', 'Q');
test_regex
-----------------
{
0,REG_UBOUNDS}
(
1 row)
-- expectMatch
8.
23 Q "a{
1,}b" aab aab
select * from test_regex('a{
1,}b', 'aab', 'Q');
test_regex
-----------------
{
0,REG_UBOUNDS}
{aab}
(
2 rows)
-- expectNomatch
8.
24 Q "a{
2,
3}b" ab
select * from test_regex('a{
2,
3}b', 'ab', 'Q');
test_regex
-----------------
{
0,REG_UBOUNDS}
(
1 row)
-- expectMatch
8.
25 Q "a{
2,
3}b" aaaab aaab
select * from test_regex('a{
2,
3}b', 'aaaab', 'Q');
test_regex
-----------------
{
0,REG_UBOUNDS}
{aaab}
(
2 rows)
-- expectNomatch
8.
26 Q "a{
2,}b" ab
select * from test_regex('a{
2,}b', 'ab', 'Q');
test_regex
-----------------
{
0,REG_UBOUNDS}
(
1 row)
-- expectMatch
8.
27 Q "a{
2,}b" aaaab aaaab
select * from test_regex('a{
2,}b', 'aaaab', 'Q');
test_regex
-----------------
{
0,REG_UBOUNDS}
{aaaab}
(
2 rows)
-- doing
9 "brackets"
-- expectMatch
9.
1 & {a[bc]} ac ac
select * from test_regex('a[bc]', 'ac', '');
test_regex
------------
{
0}
{ac}
(
2 rows)
select * from test_regex('a[bc]', 'ac', 'b');
test_regex
------------
{
0}
{ac}
(
2 rows)
-- expectMatch
9.
2 & {a[-]} a- a-
select * from test_regex('a[-]', 'a-', '');
test_regex
------------
{
0}
{a-}
(
2 rows)
select * from test_regex('a[-]', 'a-', 'b');
test_regex
------------
{
0}
{a-}
(
2 rows)
-- expectMatch
9.
3 & {a[[.-.]]} a- a-
select * from test_regex('a[[.-.]]', 'a-', '');
test_regex
------------
{
0}
{a-}
(
2 rows)
select * from test_regex('a[[.-.]]', 'a-', 'b');
test_regex
------------
{
0}
{a-}
(
2 rows)
-- expectMatch
9.
4 &L {a[[.zero.]]} a0 a0
select * from test_regex('a[[.zero.]]', 'a0', 'L');
test_regex
-----------------
{
0,REG_ULOCALE}
{a0}
(
2 rows)
select * from test_regex('a[[.zero.]]', 'a0', 'Lb');
test_regex
-----------------
{
0,REG_ULOCALE}
{a0}
(
2 rows)
-- expectMatch
9.
5 &LM {a[[.zero.]-
9]} a2 a2
select * from test_regex('a[[.zero.]-
9]', 'a2', 'LM');
test_regex
-----------------------------
{
0,REG_UUNPORT,REG_ULOCALE}
{a2}
(
2 rows)
select * from test_regex('a[[.zero.]-
9]', 'a2', 'LMb');
test_regex
-----------------------------
{
0,REG_UUNPORT,REG_ULOCALE}
{a2}
(
2 rows)
-- expectMatch
9.
6 &M {a[
0-[.
9.]]} a2 a2
select * from test_regex('a[
0-[.
9.]]', 'a2', 'M');
test_regex
-----------------
{
0,REG_UUNPORT}
{a2}
(
2 rows)
select * from test_regex('a[
0-[.
9.]]', 'a2', 'Mb');
test_regex
-----------------
{
0,REG_UUNPORT}
{a2}
(
2 rows)
-- expectMatch
9.
7 &+L {a[[=x=]]} ax ax
select * from test_regex('a[[=x=]]', 'ax', '+L');
test_regex
-----------------
{
0,REG_ULOCALE}
{ax}
(
2 rows)
select * from test_regex('a[[=x=]]', 'ax', '+Lb');
test_regex
-----------------
{
0,REG_ULOCALE}
{ax}
(
2 rows)
-- expectMatch
9.
8 &+L {a[[=x=]]} ay ay
select * from test_regex('a[[=x=]]', 'ay', '+L');
test_regex
-----------------
{
0,REG_ULOCALE}
{ay}
(
2 rows)
select * from test_regex('a[[=x=]]', 'ay', '+Lb');
test_regex
-----------------
{
0,REG_ULOCALE}
{ay}
(
2 rows)
-- expectNomatch
9.
9 &+L {a[[=x=]]} az
select * from test_regex('a[[=x=]]', 'az', '+L');
test_regex
-----------------
{
0,REG_ULOCALE}
(
1 row)
select * from test_regex('a[[=x=]]', 'az', '+Lb');
test_regex
-----------------
{
0,REG_ULOCALE}
(
1 row)
-- expectMatch
9.
9b &iL {a[[=Y=]]} ay ay
select * from test_regex('a[[=Y=]]', 'ay', 'iL');
test_regex
-----------------
{
0,REG_ULOCALE}
{ay}
(
2 rows)
select * from test_regex('a[[=Y=]]', 'ay', 'iLb');
test_regex
-----------------
{
0,REG_ULOCALE}
{ay}
(
2 rows)
-- expectNomatch
9.
9c &L {a[[=Y=]]} ay
select * from test_regex('a[[=Y=]]', 'ay', 'L');
test_regex
-----------------
{
0,REG_ULOCALE}
(
1 row)
select * from test_regex('a[[=Y=]]', 'ay', 'Lb');
test_regex
-----------------
{
0,REG_ULOCALE}
(
1 row)
-- expectError
9.
10 & {a[
0-[=x=]]} ERANGE
select * from test_regex('a[
0-[=x=]]', '', '');
ERROR: invalid regular expression: invalid character range
select * from test_regex('a[
0-[=x=]]', '', 'b');
ERROR: invalid regular expression: invalid character range
-- expectMatch
9.
11 &L {a[[:digit:]]} a0 a0
select * from test_regex('a[[:digit:]]', 'a0', 'L');
test_regex
-----------------
{
0,REG_ULOCALE}
{a0}
(
2 rows)
select * from test_regex('a[[:digit:]]', 'a0', 'Lb');
test_regex
-----------------
{
0,REG_ULOCALE}
{a0}
(
2 rows)
-- expectError
9.
12 & {a[[:woopsie:]]} ECTYPE
select * from test_regex('a[[:woopsie:]]', '', '');
ERROR: invalid regular expression: invalid character class
select * from test_regex('a[[:woopsie:]]', '', 'b');
ERROR: invalid regular expression: invalid character class
-- expectNomatch
9.
13 &L {a[[:digit:]]} ab
select * from test_regex('a[[:digit:]]', 'ab', 'L');
test_regex
-----------------
{
0,REG_ULOCALE}
(
1 row)
select * from test_regex('a[[:digit:]]', 'ab', 'Lb');
test_regex
-----------------
{
0,REG_ULOCALE}
(
1 row)
-- expectError
9.
14 & {a[
0-[:digit:]]} ERANGE
select * from test_regex('a[
0-[:digit:]]', '', '');
ERROR: invalid regular expression: invalid character range
select * from test_regex('a[
0-[:digit:]]', '', 'b');
ERROR: invalid regular expression: invalid character range
-- expectMatch
9.
15 &LP {[[:<:]]a} a a
select * from test_regex('[[:<:]]a', 'a', 'LP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
{a}
(
2 rows)
select * from test_regex('[[:<:]]a', 'a', 'LPb');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
{a}
(
2 rows)
-- expectMatch
9.
16 &LP {a[[:>:]]} a a
select * from test_regex('a[[:>:]]', 'a', 'LP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
{a}
(
2 rows)
select * from test_regex('a[[:>:]]', 'a', 'LPb');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
{a}
(
2 rows)
-- expectError
9.
17 & {a[[..]]b} ECOLLATE
select * from test_regex('a[[..]]b', '', '');
ERROR: invalid regular expression: invalid collating element
select * from test_regex('a[[..]]b', '', 'b');
ERROR: invalid regular expression: invalid collating element
-- expectError
9.
18 & {a[[==]]b} ECOLLATE
select * from test_regex('a[[==]]b', '', '');
ERROR: invalid regular expression: invalid collating element
select * from test_regex('a[[==]]b', '', 'b');
ERROR: invalid regular expression: invalid collating element
-- expectError
9.
19 & {a[[::]]b} ECTYPE
select * from test_regex('a[[::]]b', '', '');
ERROR: invalid regular expression: invalid character class
select * from test_regex('a[[::]]b', '', 'b');
ERROR: invalid regular expression: invalid character class
-- expectError
9.
20 & {a[[.a} EBRACK
select * from test_regex('a[[.a', '', '');
ERROR: invalid regular expression: brackets [] not balanced
select * from test_regex('a[[.a', '', 'b');
ERROR: invalid regular expression: brackets [] not balanced
-- expectError
9.
21 & {a[[=a} EBRACK
select * from test_regex('a[[=a', '', '');
ERROR: invalid regular expression: brackets [] not balanced
select * from test_regex('a[[=a', '', 'b');
ERROR: invalid regular expression: brackets [] not balanced
-- expectError
9.
22 & {a[[:a} EBRACK
select * from test_regex('a[[:a', '', '');
ERROR: invalid regular expression: brackets [] not balanced
select * from test_regex('a[[:a', '', 'b');
ERROR: invalid regular expression: brackets [] not balanced
-- expectError
9.
23 & {a[} EBRACK
select * from test_regex('a[', '', '');
ERROR: invalid regular expression: brackets [] not balanced
select * from test_regex('a[', '', 'b');
ERROR: invalid regular expression: brackets [] not balanced
-- expectError
9.
24 & {a[b} EBRACK
select * from test_regex('a[b', '', '');
ERROR: invalid regular expression: brackets [] not balanced
select * from test_regex('a[b', '', 'b');
ERROR: invalid regular expression: brackets [] not balanced
-- expectError
9.
25 & {a[b-} EBRACK
select * from test_regex('a[b-', '', '');
ERROR: invalid regular expression: brackets [] not balanced
select * from test_regex('a[b-', '', 'b');
ERROR: invalid regular expression: brackets [] not balanced
-- expectError
9.
26 & {a[b-c} EBRACK
select * from test_regex('a[b-c', '', '');
ERROR: invalid regular expression: brackets [] not balanced
select * from test_regex('a[b-c', '', 'b');
ERROR: invalid regular expression: brackets [] not balanced
-- expectMatch
9.
27 &M {a[b-c]} ab ab
select * from test_regex('a[b-c]', 'ab', 'M');
test_regex
-----------------
{
0,REG_UUNPORT}
{ab}
(
2 rows)
select * from test_regex('a[b-c]', 'ab', 'Mb');
test_regex
-----------------
{
0,REG_UUNPORT}
{ab}
(
2 rows)
-- expectMatch
9.
28 & {a[b-b]} ab ab
select * from test_regex('a[b-b]', 'ab', '');
test_regex
------------
{
0}
{ab}
(
2 rows)
select * from test_regex('a[b-b]', 'ab', 'b');
test_regex
------------
{
0}
{ab}
(
2 rows)
-- expectMatch
9.
29 &M {a[
1-
2]} a2 a2
select * from test_regex('a[
1-
2]', 'a2', 'M');
test_regex
-----------------
{
0,REG_UUNPORT}
{a2}
(
2 rows)
select * from test_regex('a[
1-
2]', 'a2', 'Mb');
test_regex
-----------------
{
0,REG_UUNPORT}
{a2}
(
2 rows)
-- expectError
9.
30 & {a[c-b]} ERANGE
select * from test_regex('a[c-b]', '', '');
ERROR: invalid regular expression: invalid character range
select * from test_regex('a[c-b]', '', 'b');
ERROR: invalid regular expression: invalid character range
-- expectError
9.
31 & {a[a-b-c]} ERANGE
select * from test_regex('a[a-b-c]', '', '');
ERROR: invalid regular expression: invalid character range
select * from test_regex('a[a-b-c]', '', 'b');
ERROR: invalid regular expression: invalid character range
-- expectMatch
9.
32 &M {a[--?]b} a?b a?b
select * from test_regex('a[--?]b', 'a?b', 'M');
test_regex
-----------------
{
0,REG_UUNPORT}
{a?b}
(
2 rows)
select * from test_regex('a[--?]b', 'a?b', 'Mb');
test_regex
-----------------
{
0,REG_UUNPORT}
{a?b}
(
2 rows)
-- expectMatch
9.
33 & {a[---]b} a-b a-b
select * from test_regex('a[---]b', 'a-b', '');
test_regex
------------
{
0}
{a-b}
(
2 rows)
select * from test_regex('a[---]b', 'a-b', 'b');
test_regex
------------
{
0}
{a-b}
(
2 rows)
-- expectMatch
9.
34 & {a[]b]c} a]c a]c
select * from test_regex('a[]b]c', 'a]c', '');
test_regex
------------
{
0}
{a]c}
(
2 rows)
select * from test_regex('a[]b]c', 'a]c', 'b');
test_regex
------------
{
0}
{a]c}
(
2 rows)
-- expectMatch
9.
35 EP {a[\]]b} a]b a]b
select * from test_regex('a[\]]b', 'a]b', 'EP');
test_regex
----------------------------
{
0,REG_UBBS,REG_UNONPOSIX}
{a]b}
(
2 rows)
-- expectNomatch
9.
36 bE {a[\]]b} a]b
select * from test_regex('a[\]]b', 'a]b', 'bE');
test_regex
--------------
{
0,REG_UBBS}
(
1 row)
-- expectMatch
9.
37 bE {a[\]]b} "a\\]b" "a\\]b"
select * from test_regex('a[\]]b', 'a\]b', 'bE');
test_regex
--------------
{
0,REG_UBBS}
{"a\\]b"}
(
2 rows)
-- expectMatch
9.
38 eE {a[\]]b} "a\\]b" "a\\]b"
select * from test_regex('a[\]]b', 'a\]b', 'eE');
test_regex
--------------
{
0,REG_UBBS}
{"a\\]b"}
(
2 rows)
-- expectMatch
9.
39 EP {a[\\]b} "a\\b" "a\\b"
select * from test_regex('a[\\]b', 'a\b', 'EP');
test_regex
----------------------------
{
0,REG_UBBS,REG_UNONPOSIX}
{"a\\b"}
(
2 rows)
-- expectMatch
9.
40 eE {a[\\]b} "a\\b" "a\\b"
select * from test_regex('a[\\]b', 'a\b', 'eE');
test_regex
--------------
{
0,REG_UBBS}
{"a\\b"}
(
2 rows)
-- expectMatch
9.
41 bE {a[\\]b} "a\\b" "a\\b"
select * from test_regex('a[\\]b', 'a\b', 'bE');
test_regex
--------------
{
0,REG_UBBS}
{"a\\b"}
(
2 rows)
-- expectError
9.
42 - {a[\Z]b} EESCAPE
select * from test_regex('a[\Z]b', '', '-');
ERROR: invalid regular expression: invalid escape \ sequence
-- expectMatch
9.
43 & {a[[b]c} "a\[c" "a\[c"
select * from test_regex('a[[b]c', 'a[c', '');
test_regex
------------
{
0}
{a[c}
(
2 rows)
select * from test_regex('a[[b]c', 'a[c', 'b');
test_regex
------------
{
0}
{a[c}
(
2 rows)
-- This only works in UTF8 encoding, so it's moved to test_regex_utf8.sql:
-- expectMatch
9.
44 EMP* {a[\u00fe-\u0507][\u00ff-\u0300]b} \
-- "a\u0102\u02ffb" "a\u0102\u02ffb"
-- doing
10 "anchors and newlines"
-- expectMatch
10.
1 & ^a a a
select * from test_regex('^a', 'a', '');
test_regex
------------
{
0}
{a}
(
2 rows)
select * from test_regex('^a', 'a', 'b');
test_regex
------------
{
0}
{a}
(
2 rows)
-- expectNomatch
10.
2 &^ ^a a
select * from test_regex('^a', 'a', '^');
test_regex
------------
{
0}
(
1 row)
select * from test_regex('^a', 'a', '^b');
test_regex
------------
{
0}
(
1 row)
-- expectIndices
10.
3 &N ^ a {
0 -
1}
select * from test_regex('^', 'a', '
0N');
test_regex
---------------------
{
0,REG_UEMPTYMATCH}
{"
0 -
1"}
(
2 rows)
select * from test_regex('^', 'a', '
0Nb');
test_regex
---------------------
{
0,REG_UEMPTYMATCH}
{"
0 -
1"}
(
2 rows)
-- expectIndices
10.
4 & {a$} aba {
2 2}
select * from test_regex('a$', 'aba', '
0');
test_regex
------------
{
0}
{"
2 2"}
(
2 rows)
select * from test_regex('a$', 'aba', '
0b');
test_regex
------------
{
0}
{"
2 2"}
(
2 rows)
-- expectNomatch
10.
5 {&$} {a$} a
select * from test_regex('a$', 'a', '$');
test_regex
------------
{
0}
(
1 row)
select * from test_regex('a$', 'a', '$b');
test_regex
------------
{
0}
(
1 row)
-- expectIndices
10.
6 &N {$} ab {
2 1}
select * from test_regex('$', 'ab', '
0N');
test_regex
---------------------
{
0,REG_UEMPTYMATCH}
{"
2 1"}
(
2 rows)
select * from test_regex('$', 'ab', '
0Nb');
test_regex
---------------------
{
0,REG_UEMPTYMATCH}
{"
2 1"}
(
2 rows)
-- expectMatch
10.
7 &n ^a a a
select * from test_regex('^a', 'a', 'n');
test_regex
------------
{
0}
{a}
(
2 rows)
select * from test_regex('^a', 'a', 'nb');
test_regex
------------
{
0}
{a}
(
2 rows)
-- expectMatch
10.
8 &n "^a" "b\na" "a"
select * from test_regex('^a', E'b\na', 'n');
test_regex
------------
{
0}
{a}
(
2 rows)
select * from test_regex('^a', E'b\na', 'nb');
test_regex
------------
{
0}
{a}
(
2 rows)
-- expectIndices
10.
9 &w "^a" "a\na" {
0 0}
select * from test_regex('^a', E'a\na', '
0w');
test_regex
------------
{
0}
{"
0 0"}
(
2 rows)
select * from test_regex('^a', E'a\na', '
0wb');
test_regex
------------
{
0}
{"
0 0"}
(
2 rows)
-- expectIndices
10.
10 &n^ "^a" "a\na" {
2 2}
select * from test_regex('^a', E'a\na', '
0n^');
test_regex
------------
{
0}
{"
2 2"}
(
2 rows)
select * from test_regex('^a', E'a\na', '
0n^b');
test_regex
------------
{
0}
{"
2 2"}
(
2 rows)
-- expectMatch
10.
11 &n {a$} a a
select * from test_regex('a$', 'a', 'n');
test_regex
------------
{
0}
{a}
(
2 rows)
select * from test_regex('a$', 'a', 'nb');
test_regex
------------
{
0}
{a}
(
2 rows)
-- expectMatch
10.
12 &n "a\$" "a\nb" "a"
select * from test_regex('a$', E'a\nb', 'n');
test_regex
------------
{
0}
{a}
(
2 rows)
select * from test_regex('a$', E'a\nb', 'nb');
test_regex
------------
{
0}
{a}
(
2 rows)
-- expectIndices
10.
13 &n "a\$" "a\na" {
0 0}
select * from test_regex('a$', E'a\na', '
0n');
test_regex
------------
{
0}
{"
0 0"}
(
2 rows)
select * from test_regex('a$', E'a\na', '
0nb');
test_regex
------------
{
0}
{"
0 0"}
(
2 rows)
-- expectIndices
10.
14 N ^^ a {
0 -
1}
select * from test_regex('^^', 'a', '
0N');
test_regex
---------------------
{
0,REG_UEMPTYMATCH}
{"
0 -
1"}
(
2 rows)
-- expectMatch
10.
15 b ^^ ^ ^
select * from test_regex('^^', '^', 'b');
test_regex
------------
{
0}
{^}
(
2 rows)
-- expectIndices
10.
16 N {$$} a {
1 0}
select * from test_regex('$$', 'a', '
0N');
test_regex
---------------------
{
0,REG_UEMPTYMATCH}
{"
1 0"}
(
2 rows)
-- expectMatch
10.
17 b {$$} "\$" "\$"
select * from test_regex('$$', '$', 'b');
test_regex
------------
{
0}
{$}
(
2 rows)
-- expectMatch
10.
18 &N {^$} "" ""
select * from test_regex('^$', '', 'N');
test_regex
---------------------
{
0,REG_UEMPTYMATCH}
{""}
(
2 rows)
select * from test_regex('^$', '', 'Nb');
test_regex
---------------------
{
0,REG_UEMPTYMATCH}
{""}
(
2 rows)
-- expectNomatch
10.
19 &N {^$} a
select * from test_regex('^$', 'a', 'N');
test_regex
---------------------
{
0,REG_UEMPTYMATCH}
(
1 row)
select * from test_regex('^$', 'a', 'Nb');
test_regex
---------------------
{
0,REG_UEMPTYMATCH}
(
1 row)
-- expectIndices
10.
20 &nN "^\$" a\n\nb {
2 1}
select * from test_regex('^$', E'a\n\nb', '
0nN');
test_regex
---------------------
{
0,REG_UEMPTYMATCH}
{"
2 1"}
(
2 rows)
select * from test_regex('^$', E'a\n\nb', '
0nNb');
test_regex
---------------------
{
0,REG_UEMPTYMATCH}
{"
2 1"}
(
2 rows)
-- expectMatch
10.
21 N {$^} "" ""
select * from test_regex('$^', '', 'N');
test_regex
---------------------
{
0,REG_UEMPTYMATCH}
{""}
(
2 rows)
-- expectMatch
10.
22 b {$^} "\$^" "\$^"
select * from test_regex('$^', '$^', 'b');
test_regex
------------
{
0}
{$^}
(
2 rows)
-- expectMatch
10.
23 P {\Aa} a a
select * from test_regex('\Aa', 'a', 'P');
test_regex
-------------------
{
0,REG_UNONPOSIX}
{a}
(
2 rows)
-- expectMatch
10.
24 ^P {\Aa} a a
select * from test_regex('\Aa', 'a', '^P');
test_regex
-------------------
{
0,REG_UNONPOSIX}
{a}
(
2 rows)
-- expectNomatch
10.
25 ^nP {\Aa} "b\na"
select * from test_regex('\Aa', E'b\na', '^nP');
test_regex
-------------------
{
0,REG_UNONPOSIX}
(
1 row)
-- expectMatch
10.
26 P {a\Z} a a
select * from test_regex('a\Z', 'a', 'P');
test_regex
-------------------
{
0,REG_UNONPOSIX}
{a}
(
2 rows)
-- expectMatch
10.
27 \$P {a\Z} a a
select * from test_regex('a\Z', 'a', '$P');
test_regex
-------------------
{
0,REG_UNONPOSIX}
{a}
(
2 rows)
-- expectNomatch
10.
28 \$nP {a\Z} "a\nb"
select * from test_regex('a\Z', E'a\nb', '$nP');
test_regex
-------------------
{
0,REG_UNONPOSIX}
(
1 row)
-- expectError
10.
29 - ^* BADRPT
select * from test_regex('^*', '', '-');
ERROR: invalid regular expression: quantifier operand invalid
-- expectError
10.
30 - {$*} BADRPT
select * from test_regex('$*', '', '-');
ERROR: invalid regular expression: quantifier operand invalid
-- expectError
10.
31 - {\A*} BADRPT
select * from test_regex('\A*', '', '-');
ERROR: invalid regular expression: quantifier operand invalid
-- expectError
10.
32 - {\Z*} BADRPT
select * from test_regex('\Z*', '', '-');
ERROR: invalid regular expression: quantifier operand invalid
-- doing
11 "boundary constraints"
-- expectMatch
11.
1 &LP {[[:<:]]a} a a
select * from test_regex('[[:<:]]a', 'a', 'LP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
{a}
(
2 rows)
select * from test_regex('[[:<:]]a', 'a', 'LPb');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
{a}
(
2 rows)
-- expectMatch
11.
2 &LP {[[:<:]]a} -a a
select * from test_regex('[[:<:]]a', '-a', 'LP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
{a}
(
2 rows)
select * from test_regex('[[:<:]]a', '-a', 'LPb');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
{a}
(
2 rows)
-- expectNomatch
11.
3 &LP {[[:<:]]a} ba
select * from test_regex('[[:<:]]a', 'ba', 'LP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
(
1 row)
select * from test_regex('[[:<:]]a', 'ba', 'LPb');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
(
1 row)
-- expectMatch
11.
4 &LP {a[[:>:]]} a a
select * from test_regex('a[[:>:]]', 'a', 'LP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
{a}
(
2 rows)
select * from test_regex('a[[:>:]]', 'a', 'LPb');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
{a}
(
2 rows)
-- expectMatch
11.
5 &LP {a[[:>:]]} a- a
select * from test_regex('a[[:>:]]', 'a-', 'LP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
{a}
(
2 rows)
select * from test_regex('a[[:>:]]', 'a-', 'LPb');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
{a}
(
2 rows)
-- expectNomatch
11.
6 &LP {a[[:>:]]} ab
select * from test_regex('a[[:>:]]', 'ab', 'LP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
(
1 row)
select * from test_regex('a[[:>:]]', 'ab', 'LPb');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
(
1 row)
-- expectMatch
11.
7 bLP {\<a} a a
select * from test_regex('\<a', 'a', 'bLP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
{a}
(
2 rows)
-- expectNomatch
11.
8 bLP {\<a} ba
select * from test_regex('\<a', 'ba', 'bLP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
(
1 row)
-- expectMatch
11.
9 bLP {a\>} a a
select * from test_regex('a\>', 'a', 'bLP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
{a}
(
2 rows)
-- expectNomatch
11.
10 bLP {a\>} ab
select * from test_regex('a\>', 'ab', 'bLP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
(
1 row)
-- expectMatch
11.
11 LP {\ya} a a
select * from test_regex('\ya', 'a', 'LP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
{a}
(
2 rows)
-- expectNomatch
11.
12 LP {\ya} ba
select * from test_regex('\ya', 'ba', 'LP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
(
1 row)
-- expectMatch
11.
13 LP {a\y} a a
select * from test_regex('a\y', 'a', 'LP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
{a}
(
2 rows)
-- expectNomatch
11.
14 LP {a\y} ab
select * from test_regex('a\y', 'ab', 'LP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
(
1 row)
-- expectMatch
11.
15 LP {a\Y} ab a
select * from test_regex('a\Y', 'ab', 'LP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
{a}
(
2 rows)
-- expectNomatch
11.
16 LP {a\Y} a-
select * from test_regex('a\Y', 'a-', 'LP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
(
1 row)
-- expectNomatch
11.
17 LP {a\Y} a
select * from test_regex('a\Y', 'a', 'LP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
(
1 row)
-- expectNomatch
11.
18 LP {-\Y} -a
select * from test_regex('-\Y', '-a', 'LP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
(
1 row)
-- expectMatch
11.
19 LP {-\Y} -% -
select * from test_regex('-\Y', '-%', 'LP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
{-}
(
2 rows)
-- expectNomatch
11.
20 LP {\Y-} a-
select * from test_regex('\Y-', 'a-', 'LP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
(
1 row)
-- expectError
11.
21 - {[[:<:]]*} BADRPT
select * from test_regex('[[:<:]]*', '', '-');
ERROR: invalid regular expression: quantifier operand invalid
-- expectError
11.
22 - {[[:>:]]*} BADRPT
select * from test_regex('[[:>:]]*', '', '-');
ERROR: invalid regular expression: quantifier operand invalid
-- expectError
11.
23 b {\<*} BADRPT
select * from test_regex('\<*', '', 'b');
ERROR: invalid regular expression: quantifier operand invalid
-- expectError
11.
24 b {\>*} BADRPT
select * from test_regex('\>*', '', 'b');
ERROR: invalid regular expression: quantifier operand invalid
-- expectError
11.
25 - {\y*} BADRPT
select * from test_regex('\y*', '', '-');
ERROR: invalid regular expression: quantifier operand invalid
-- expectError
11.
26 - {\Y*} BADRPT
select * from test_regex('\Y*', '', '-');
ERROR: invalid regular expression: quantifier operand invalid
-- expectMatch
11.
27 LP {\ma} a a
select * from test_regex('\ma', 'a', 'LP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
{a}
(
2 rows)
-- expectNomatch
11.
28 LP {\ma} ba
select * from test_regex('\ma', 'ba', 'LP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
(
1 row)
-- expectMatch
11.
29 LP {a\M} a a
select * from test_regex('a\M', 'a', 'LP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
{a}
(
2 rows)
-- expectNomatch
11.
30 LP {a\M} ab
select * from test_regex('a\M', 'ab', 'LP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
(
1 row)
-- expectNomatch
11.
31 ILP {\Ma} a
select * from test_regex('\Ma', 'a', 'ILP');
test_regex
-----------------------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE,REG_UIMPOSSIBLE}
(
1 row)
-- expectNomatch
11.
32 ILP {a\m} a
select * from test_regex('a\m', 'a', 'ILP');
test_regex
-----------------------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE,REG_UIMPOSSIBLE}
(
1 row)
-- doing
12 "character classes"
-- expectMatch
12.
1 LP {a\db} a0b a0b
select * from test_regex('a\db', 'a0b', 'LP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
{a0b}
(
2 rows)
-- expectNomatch
12.
2 LP {a\db} axb
select * from test_regex('a\db', 'axb', 'LP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
(
1 row)
-- expectNomatch
12.
3 LP {a\Db} a0b
select * from test_regex('a\Db', 'a0b', 'LP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
(
1 row)
-- expectMatch
12.
4 LP {a\Db} axb axb
select * from test_regex('a\Db', 'axb', 'LP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
{axb}
(
2 rows)
-- expectMatch
12.
5 LP "a\\sb" "a b" "a b"
select * from test_regex('a\sb', 'a b', 'LP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
{"a b"}
(
2 rows)
-- expectMatch
12.
6 LP "a\\sb" "a\tb" "a\tb"
select * from test_regex('a\sb', E'a\tb', 'LP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
{"a b"}
(
2 rows)
-- expectMatch
12.
7 LP "a\\sb" "a\nb" "a\nb"
select * from test_regex('a\sb', E'a\nb', 'LP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
{"a +
b"}
(
2 rows)
-- expectNomatch
12.
8 LP {a\sb} axb
select * from test_regex('a\sb', 'axb', 'LP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
(
1 row)
-- expectMatch
12.
9 LP {a\Sb} axb axb
select * from test_regex('a\Sb', 'axb', 'LP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
{axb}
(
2 rows)
-- expectNomatch
12.
10 LP "a\\Sb" "a b"
select * from test_regex('a\Sb', 'a b', 'LP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
(
1 row)
-- expectMatch
12.
11 LP {a\wb} axb axb
select * from test_regex('a\wb', 'axb', 'LP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
{axb}
(
2 rows)
-- expectNomatch
12.
12 LP {a\wb} a-b
select * from test_regex('a\wb', 'a-b', 'LP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
(
1 row)
-- expectNomatch
12.
13 LP {a\Wb} axb
select * from test_regex('a\Wb', 'axb', 'LP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
(
1 row)
-- expectMatch
12.
14 LP {a\Wb} a-b a-b
select * from test_regex('a\Wb', 'a-b', 'LP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
{a-b}
(
2 rows)
-- expectMatch
12.
15 LP {\y\w+z\y} adze-guz guz
select * from test_regex('\y\w+z\y', 'adze-guz', 'LP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
{guz}
(
2 rows)
-- expectMatch
12.
16 LPE {a[\d]b} a1b a1b
select * from test_regex('a[\d]b', 'a1b', 'LPE');
test_regex
----------------------------------------
{
0,REG_UBBS,REG_UNONPOSIX,REG_ULOCALE}
{a1b}
(
2 rows)
-- expectMatch
12.
17 LPE "a\[\\s]b" "a b" "a b"
select * from test_regex('a[\s]b', 'a b', 'LPE');
test_regex
----------------------------------------
{
0,REG_UBBS,REG_UNONPOSIX,REG_ULOCALE}
{"a b"}
(
2 rows)
-- expectMatch
12.
18 LPE {a[\w]b} axb axb
select * from test_regex('a[\w]b', 'axb', 'LPE');
test_regex
----------------------------------------
{
0,REG_UBBS,REG_UNONPOSIX,REG_ULOCALE}
{axb}
(
2 rows)
-- these should be invalid
select * from test_regex('[\w-~]*', 'ab01_~-`**', 'LNPSE');
ERROR: invalid regular expression: invalid character range
select * from test_regex('[~-\w]*', 'ab01_~-`**', 'LNPSE');
ERROR: invalid regular expression: invalid character range
select * from test_regex('[[:alnum:]-~]*', 'ab01~-`**', 'LNS');
ERROR: invalid regular expression: invalid character range
select * from test_regex('[~-[:alnum:]]*', 'ab01~-`**', 'LNS');
ERROR: invalid regular expression: invalid character range
-- test complemented char classes within brackets
select * from test_regex('[\D]', '
0123456789abc*', 'LPE');
test_regex
----------------------------------------
{
0,REG_UBBS,REG_UNONPOSIX,REG_ULOCALE}
{a}
(
2 rows)
select * from test_regex('[^\D]', 'abc0123456789*', 'LPE');
test_regex
----------------------------------------
{
0,REG_UBBS,REG_UNONPOSIX,REG_ULOCALE}
{
0}
(
2 rows)
select * from test_regex('[
1\D7]', '
0123456789abc*', 'LPE');
test_regex
----------------------------------------
{
0,REG_UBBS,REG_UNONPOSIX,REG_ULOCALE}
{
1}
(
2 rows)
select * from test_regex('[
7\D1]', '
0123456789abc*', 'LPE');
test_regex
----------------------------------------
{
0,REG_UBBS,REG_UNONPOSIX,REG_ULOCALE}
{
1}
(
2 rows)
select * from test_regex('[^
0\D1]', 'abc0123456789*', 'LPE');
test_regex
----------------------------------------
{
0,REG_UBBS,REG_UNONPOSIX,REG_ULOCALE}
{
2}
(
2 rows)
select * from test_regex('[^
1\D0]', 'abc0123456789*', 'LPE');
test_regex
----------------------------------------
{
0,REG_UBBS,REG_UNONPOSIX,REG_ULOCALE}
{
2}
(
2 rows)
select * from test_regex('\W', '
0123456789abc_*', 'LP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
{*}
(
2 rows)
select * from test_regex('[\W]', '
0123456789abc_*', 'LPE');
test_regex
----------------------------------------
{
0,REG_UBBS,REG_UNONPOSIX,REG_ULOCALE}
{*}
(
2 rows)
select * from test_regex('[\s\S]*', '
012 3456789abc_*', 'LNPE');
test_regex
--------------------------------------------------------
{
0,REG_UBBS,REG_UNONPOSIX,REG_ULOCALE,REG_UEMPTYMATCH}
{"
012 3456789abc_*"}
(
2 rows)
-- bug #
18708:
select * from test_regex('(?:[^\d\D]){
0}', '
0123456789abc*', 'LNPQE');
test_regex
--------------------------------------------------------------------
{
0,REG_UBOUNDS,REG_UBBS,REG_UNONPOSIX,REG_ULOCALE,REG_UEMPTYMATCH}
{""}
(
2 rows)
select * from test_regex('[^\d\D]', '
0123456789abc*', 'ILPE');
test_regex
--------------------------------------------------------
{
0,REG_UBBS,REG_UNONPOSIX,REG_ULOCALE,REG_UIMPOSSIBLE}
(
1 row)
-- check char classes' handling of newlines
select * from test_regex('\s+', E'abc \n def', 'LP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
{" +
"}
(
2 rows)
select * from test_regex('\s+', E'abc \n def', 'nLP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
{" +
"}
(
2 rows)
select * from test_regex('[\s]+', E'abc \n def', 'LPE');
test_regex
----------------------------------------
{
0,REG_UBBS,REG_UNONPOSIX,REG_ULOCALE}
{" +
"}
(
2 rows)
select * from test_regex('[\s]+', E'abc \n def', 'nLPE');
test_regex
----------------------------------------
{
0,REG_UBBS,REG_UNONPOSIX,REG_ULOCALE}
{" +
"}
(
2 rows)
select * from test_regex('\S+', E'abc\ndef', 'LP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
{abc}
(
2 rows)
select * from test_regex('\S+', E'abc\ndef', 'nLP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
{abc}
(
2 rows)
select * from test_regex('[\S]+', E'abc\ndef', 'LPE');
test_regex
----------------------------------------
{
0,REG_UBBS,REG_UNONPOSIX,REG_ULOCALE}
{abc}
(
2 rows)
select * from test_regex('[\S]+', E'abc\ndef', 'nLPE');
test_regex
----------------------------------------
{
0,REG_UBBS,REG_UNONPOSIX,REG_ULOCALE}
{abc}
(
2 rows)
select * from test_regex('\d+', E'
012\n345', 'LP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
{
012}
(
2 rows)
select * from test_regex('\d+', E'
012\n345', 'nLP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
{
012}
(
2 rows)
select * from test_regex('[\d]+', E'
012\n345', 'LPE');
test_regex
----------------------------------------
{
0,REG_UBBS,REG_UNONPOSIX,REG_ULOCALE}
{
012}
(
2 rows)
select * from test_regex('[\d]+', E'
012\n345', 'nLPE');
test_regex
----------------------------------------
{
0,REG_UBBS,REG_UNONPOSIX,REG_ULOCALE}
{
012}
(
2 rows)
select * from test_regex('\D+', E'abc\ndef345', 'LP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
{"abc +
def"}
(
2 rows)
select * from test_regex('\D+', E'abc\ndef345', 'nLP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
{"abc +
def"}
(
2 rows)
select * from test_regex('[\D]+', E'abc\ndef345', 'LPE');
test_regex
----------------------------------------
{
0,REG_UBBS,REG_UNONPOSIX,REG_ULOCALE}
{"abc +
def"}
(
2 rows)
select * from test_regex('[\D]+', E'abc\ndef345', 'nLPE');
test_regex
----------------------------------------
{
0,REG_UBBS,REG_UNONPOSIX,REG_ULOCALE}
{"abc +
def"}
(
2 rows)
select * from test_regex('\w+', E'abc_012\ndef', 'LP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
{abc_012}
(
2 rows)
select * from test_regex('\w+', E'abc_012\ndef', 'nLP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
{abc_012}
(
2 rows)
select * from test_regex('[\w]+', E'abc_012\ndef', 'LPE');
test_regex
----------------------------------------
{
0,REG_UBBS,REG_UNONPOSIX,REG_ULOCALE}
{abc_012}
(
2 rows)
select * from test_regex('[\w]+', E'abc_012\ndef', 'nLPE');
test_regex
----------------------------------------
{
0,REG_UBBS,REG_UNONPOSIX,REG_ULOCALE}
{abc_012}
(
2 rows)
select * from test_regex('\W+', E'***\n@@@___', 'LP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
{"*** +
@@@"}
(
2 rows)
select * from test_regex('\W+', E'***\n@@@___', 'nLP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
{"*** +
@@@"}
(
2 rows)
select * from test_regex('[\W]+', E'***\n@@@___', 'LPE');
test_regex
----------------------------------------
{
0,REG_UBBS,REG_UNONPOSIX,REG_ULOCALE}
{"*** +
@@@"}
(
2 rows)
select * from test_regex('[\W]+', E'***\n@@@___', 'nLPE');
test_regex
----------------------------------------
{
0,REG_UBBS,REG_UNONPOSIX,REG_ULOCALE}
{"*** +
@@@"}
(
2 rows)
-- doing
13 "escapes"
-- expectError
13.
1 & "a\\" EESCAPE
select * from test_regex('a\', '', '');
ERROR: invalid regular expression: invalid escape \ sequence
select * from test_regex('a\', '', 'b');
ERROR: invalid regular expression: invalid escape \ sequence
-- expectMatch
13.
2 - {a\<b} a<b a<b
select * from test_regex('a\<b', 'a<b', '-');
test_regex
------------
{
0}
{a<b}
(
2 rows)
-- expectMatch
13.
3 e {a\<b} a<b a<b
select * from test_regex('a\<b', 'a<b', 'e');
test_regex
------------
{
0}
{a<b}
(
2 rows)
-- expectMatch
13.
4 bAS {a\wb} awb awb
select * from test_regex('a\wb', 'awb', 'bAS');
test_regex
------------------------------
{
0,REG_UBSALNUM,REG_UUNSPEC}
{awb}
(
2 rows)
-- expectMatch
13.
5 eAS {a\wb} awb awb
select * from test_regex('a\wb', 'awb', 'eAS');
test_regex
------------------------------
{
0,REG_UBSALNUM,REG_UUNSPEC}
{awb}
(
2 rows)
-- expectMatch
13.
6 PL "a\\ab" "a\
007b" "a\
007b"
select * from test_regex('a\ab', E'a\
007b', 'PL');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_ULOCALE}
{a\x07b}
(
2 rows)
-- expectMatch
13.
7 P "a\\bb" "a\bb" "a\bb"
select * from test_regex('a\bb', E'a\bb', 'P');
test_regex
-------------------
{
0,REG_UNONPOSIX}
{a\x08b}
(
2 rows)
-- expectMatch
13.
8 P {a\Bb} "a\\b" "a\\b"
select * from test_regex('a\Bb', 'a\b', 'P');
test_regex
-------------------
{
0,REG_UNONPOSIX}
{"a\\b"}
(
2 rows)
-- expectMatch
13.
9 MP "a\\chb" "a\bb" "a\bb"
select * from test_regex('a\chb', E'a\bb', 'MP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_UUNPORT}
{a\x08b}
(
2 rows)
-- expectMatch
13.
10 MP "a\\cHb" "a\bb" "a\bb"
select * from test_regex('a\cHb', E'a\bb', 'MP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_UUNPORT}
{a\x08b}
(
2 rows)
-- expectMatch
13.
11 LMP "a\\e" "a\
033" "a\
033"
select * from test_regex('a\e', E'a\
033', 'LMP');
test_regex
-------------------------------------------
{
0,REG_UNONPOSIX,REG_UUNPORT,REG_ULOCALE}
{a\x1B}
(
2 rows)
-- expectMatch
13.
12 P "a\\fb" "a\fb" "a\fb"
select * from test_regex('a\fb', E'a\fb', 'P');
test_regex
-------------------
{
0,REG_UNONPOSIX}
{"a\x0Cb"}
(
2 rows)
-- expectMatch
13.
13 P "a\\nb" "a\nb" "a\nb"
select * from test_regex('a\nb', E'a\nb', 'P');
test_regex
-------------------
{
0,REG_UNONPOSIX}
{"a +
b"}
(
2 rows)
-- expectMatch
13.
14 P "a\\rb" "a\rb" "a\rb"
select * from test_regex('a\rb', E'a\rb', 'P');
test_regex
-------------------
{
0,REG_UNONPOSIX}
{"a\rb"}
(
2 rows)
-- expectMatch
13.
15 P "a\\tb" "a\tb" "a\tb"
select * from test_regex('a\tb', E'a\tb', 'P');
test_regex
-------------------
{
0,REG_UNONPOSIX}
{"a b"}
(
2 rows)
-- expectMatch
13.
16 P "a\\u0008x" "a\bx" "a\bx"
select * from test_regex('a\u0008x', E'a\bx', 'P');
test_regex
-------------------
{
0,REG_UNONPOSIX}
{a\x08x}
(
2 rows)
-- expectMatch
13.
17 P {a\u008x} "a\bx" "a\bx"
-- Tcl has relaxed their code to allow
1-
4 hex digits, but Postgres hasn't
select * from test_regex('a\u008x', E'a\bx', 'P');
ERROR: invalid regular expression: invalid escape \ sequence
-- expectMatch
13.
18 P "a\\u00088x" "a\b8x" "a\b8x"
select * from test_regex('a\u00088x', E'a\b8x', 'P');
test_regex
-------------------
{
0,REG_UNONPOSIX}
{a\x088x}
(
2 rows)
-- expectMatch
13.
19 P "a\\U00000008x" "a\bx" "a\bx"
select * from test_regex('a\U00000008x', E'a\bx', 'P');
test_regex
-------------------
{
0,REG_UNONPOSIX}
{a\x08x}
(
2 rows)
-- expectMatch
13.
20 P {a\U0000008x} "a\bx" "a\bx"
-- Tcl has relaxed their code to allow
1-
8 hex digits, but Postgres hasn't
select * from test_regex('a\U0000008x', E'a\bx', 'P');
ERROR: invalid regular expression: invalid escape \ sequence
-- expectMatch
13.
21 P "a\\vb" "a\vb" "a\vb"
select * from test_regex('a\vb', E'a\
013b', 'P');
test_regex
-------------------
{
0,REG_UNONPOSIX}
{"a\x0Bb"}
(
2 rows)
-- expectMatch
13.
22 MP "a\\x08x" "a\bx" "a\bx"
select * from test_regex('a\x08x', E'a\bx', 'MP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_UUNPORT}
{a\x08x}
(
2 rows)
-- expectError
13.
23 - {a\xq} EESCAPE
select * from test_regex('a\xq', '', '-');
ERROR: invalid regular expression: invalid escape \ sequence
-- expectMatch
13.
24 MP "a\\x08x" "a\bx" "a\bx"
select * from test_regex('a\x08x', E'a\bx', 'MP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_UUNPORT}
{a\x08x}
(
2 rows)
-- expectError
13.
25 - {a\z} EESCAPE
select * from test_regex('a\z', '', '-');
ERROR: invalid regular expression: invalid escape \ sequence
-- expectMatch
13.
26 MP "a\\
010b" "a\bb" "a\bb"
select * from test_regex('a\
010b', E'a\bb', 'MP');
test_regex
-------------------------------
{
0,REG_UNONPOSIX,REG_UUNPORT}
{a\x08b}
(
2 rows)
-- These only work in UTF8 encoding, so they're moved to test_regex_utf8.sql:
-- expectMatch
13.
27 P "a\\U00001234x" "a\u1234x" "a\u1234x"
-- expectMatch
13.
28 P {a\U00001234x} "a\u1234x" "a\u1234x"
-- expectMatch
13.
29 P "a\\U0001234x" "a\u1234x" "a\u1234x"
-- expectMatch
13.
30 P {a\U0001234x} "a\u1234x" "a\u1234x"
-- expectMatch
13.
31 P "a\\U000012345x" "a\u12345x" "a\u12345x"
-- expectMatch
13.
32 P {a\U000012345x} "a\u12345x" "a\u12345x"
-- expectMatch
13.
33 P "a\\U1000000x" "a\ufffd0x" "a\ufffd0x"
-- expectMatch
13.
34 P {a\U1000000x} "a\ufffd0x" "a\ufffd0x"
-- doing
14 "back references"
-- # ugh
-- expectMatch
14.
1 RP {a(b*)c\
1} abbcbb abbcbb bb
select * from test_regex('a(b*)c\
1', 'abbcbb', 'RP');
test_regex
--------------------------------
{
1,REG_UBACKREF,REG_UNONPOSIX}
{abbcbb,bb}
(
2 rows)
-- expectMatch
14.
2 RP {a(b*)c\
1} ac ac ""
select * from test_regex('a(b*)c\
1', 'ac', 'RP');
test_regex
--------------------------------
{
1,REG_UBACKREF,REG_UNONPOSIX}
{ac,""}
(
2 rows)
-- expectNomatch
14.
3 RP {a(b*)c\
1} abbcb
select * from test_regex('a(b*)c\
1', 'abbcb', 'RP');
test_regex
--------------------------------
{
1,REG_UBACKREF,REG_UNONPOSIX}
(
1 row)
-- expectMatch
14.
4 RP {a(b*)\
1} abbcbb abb b
select * from test_regex('a(b*)\
1', 'abbcbb', 'RP');
test_regex
--------------------------------
{
1,REG_UBACKREF,REG_UNONPOSIX}
{abb,b}
(
2 rows)
-- expectMatch
14.
5 RP {a(b|bb)\
1} abbcbb abb b
select * from test_regex('a(b|bb)\
1', 'abbcbb', 'RP');
test_regex
--------------------------------
{
1,REG_UBACKREF,REG_UNONPOSIX}
{abb,b}
(
2 rows)
-- expectMatch
14.
6 RP {a([bc])\
1} abb abb b
select * from test_regex('a([bc])\
1', 'abb', 'RP');
test_regex
--------------------------------
{
1,REG_UBACKREF,REG_UNONPOSIX}
{abb,b}
(
2 rows)
-- expectNomatch
14.
7 RP {a([bc])\
1} abc
select * from test_regex('a([bc])\
1', 'abc', 'RP');
test_regex
--------------------------------
{
1,REG_UBACKREF,REG_UNONPOSIX}
(
1 row)
-- expectMatch
14.
8 RP {a([bc])\
1} abcabb abb b
select * from test_regex('a([bc])\
1', 'abcabb', 'RP');
test_regex
--------------------------------
{
1,REG_UBACKREF,REG_UNONPOSIX}
{abb,b}
(
2 rows)
-- expectNomatch
14.
9 RP {a([bc])*\
1} abc
select * from test_regex('a([bc])*\
1', 'abc', 'RP');
test_regex
--------------------------------
{
1,REG_UBACKREF,REG_UNONPOSIX}
(
1 row)
-- expectNomatch
14.
10 RP {a([bc])\
1} abB
select * from test_regex('a([bc])\
1', 'abB', 'RP');
test_regex
--------------------------------
{
1,REG_UBACKREF,REG_UNONPOSIX}
(
1 row)
-- expectMatch
14.
11 iRP {a([bc])\
1} abB abB b
select * from test_regex('a([bc])\
1', 'abB', 'iRP');
test_regex
--------------------------------
{
1,REG_UBACKREF,REG_UNONPOSIX}
{abB,b}
(
2 rows)
-- expectMatch
14.
12 RP {a([bc])\
1+} abbb abbb b
select * from test_regex('a([bc])\
1+', 'abbb', 'RP');
test_regex
--------------------------------
{
1,REG_UBACKREF,REG_UNONPOSIX}
{abbb,b}
(
2 rows)
-- expectMatch
14.
13 QRP "a(\[bc])\\
1{
3,
4}" abbbb abbbb b
select * from test_regex('a([bc])\
1{
3,
4}', 'abbbb', 'QRP');
test_regex
--------------------------------------------
{
1,REG_UBACKREF,REG_UBOUNDS,REG_UNONPOSIX}
{abbbb,b}
(
2 rows)
-- expectNomatch
14.
14 QRP "a(\[bc])\\
1{
3,
4}" abbb
select * from test_regex('a([bc])\
1{
3,
4}', 'abbb', 'QRP');
test_regex
--------------------------------------------
{
1,REG_UBACKREF,REG_UBOUNDS,REG_UNONPOSIX}
(
1 row)
-- expectMatch
14.
15 RP {a([bc])\
1*} abbb abbb b
select * from test_regex('a([bc])\
1*', 'abbb', 'RP');
test_regex
--------------------------------
{
1,REG_UBACKREF,REG_UNONPOSIX}
{abbb,b}
(
2 rows)
-- expectMatch
14.
16 RP {a([bc])\
1*} ab ab b
select * from test_regex('a([bc])\
1*', 'ab', 'RP');
test_regex
--------------------------------
{
1,REG_UBACKREF,REG_UNONPOSIX}
{ab,b}
(
2 rows)
-- expectMatch
14.
17 RP {a([bc])(\
1*)} ab ab b ""
select * from test_regex('a([bc])(\
1*)', 'ab', 'RP');
test_regex
--------------------------------
{
2,REG_UBACKREF,REG_UNONPOSIX}
{ab,b,""}
(
2 rows)
-- expectError
14.
18 - {a((b)\
1)} ESUBREG
select * from test_regex('a((b)\
1)', '', '-');
ERROR: invalid regular expression: invalid backreference number
-- expectError
14.
19 - {a(b)c\
2} ESUBREG
select * from test_regex('a(b)c\
2', '', '-');
ERROR: invalid regular expression: invalid backreference number
-- expectMatch
14.
20 bR {a\(b*\)c\
1} abbcbb abbcbb bb
select * from test_regex('a\(b*\)c\
1', 'abbcbb', 'bR');
test_regex
------------------
{
1,REG_UBACKREF}
{abbcbb,bb}
(
2 rows)
-- expectMatch
14.
21 RP {^([bc])\
1*$} bbb bbb b
select * from test_regex('^([bc])\
1*$', 'bbb', 'RP');
test_regex
--------------------------------
{
1,REG_UBACKREF,REG_UNONPOSIX}
{bbb,b}
(
2 rows)
-- expectMatch
14.
22 RP {^([bc])\
1*$} ccc ccc c
select * from test_regex('^([bc])\
1*$', 'ccc', 'RP');
test_regex
--------------------------------
{
1,REG_UBACKREF,REG_UNONPOSIX}
{ccc,c}
(
2 rows)
-- expectNomatch
14.
23 RP {^([bc])\
1*$} bcb
select * from test_regex('^([bc])\
1*$', 'bcb', 'RP');
test_regex
--------------------------------
{
1,REG_UBACKREF,REG_UNONPOSIX}
(
1 row)
-- expectMatch
14.
24 LRP {^(\w+)( \
1)+$} {abc abc abc} {abc abc abc} abc { abc}
select * from test_regex('^(\w+)( \
1)+$', 'abc abc abc', 'LRP');
test_regex
--------------------------------------------
{
2,REG_UBACKREF,REG_UNONPOSIX,REG_ULOCALE}
{"abc abc abc",abc," abc"}
(
2 rows)
-- expectNomatch
14.
25 LRP {^(\w+)( \
1)+$} {abc abd abc}
select * from test_regex('^(\w+)( \
1)+$', 'abc abd abc', 'LRP');
test_regex
--------------------------------------------
{
2,REG_UBACKREF,REG_UNONPOSIX,REG_ULOCALE}
(
1 row)
-- expectNomatch
14.
26 LRP {^(\w+)( \
1)+$} {abc abc abd}
select * from test_regex('^(\w+)( \
1)+$', 'abc abc abd', 'LRP');
test_regex
--------------------------------------------
{
2,REG_UBACKREF,REG_UNONPOSIX,REG_ULOCALE}
(
1 row)
-- expectMatch
14.
27 RP {^(.+)( \
1)+$} {abc abc abc} {abc abc abc} abc { abc}
select * from test_regex('^(.+)( \
1)+$', 'abc abc abc', 'RP');
test_regex
--------------------------------
{
2,REG_UBACKREF,REG_UNONPOSIX}
{"abc abc abc",abc," abc"}
(
2 rows)
-- expectNomatch
14.
28 RP {^(.+)( \
1)+$} {abc abd abc}
select * from test_regex('^(.+)( \
1)+$', 'abc abd abc', 'RP');
test_regex
--------------------------------
{
2,REG_UBACKREF,REG_UNONPOSIX}
(
1 row)
-- expectNomatch
14.
29 RP {^(.+)( \
1)+$} {abc abc abd}
select * from test_regex('^(.+)( \
1)+$', 'abc abc abd', 'RP');
test_regex
--------------------------------
{
2,REG_UBACKREF,REG_UNONPOSIX}
(
1 row)
-- expectNomatch
14.
30 RP {^(.)\
1|\
1.} {abcdef}
select * from test_regex('^(.)\
1|\
1.', 'abcdef', 'RP');
test_regex
--------------------------------
{
1,REG_UBACKREF,REG_UNONPOSIX}
(
1 row)
-- expectNomatch
14.
31 RP {^((.)\
2|..)\
2} {abadef}
select * from test_regex('^((.)\
2|..)\
2', 'abadef', 'RP');
test_regex
--------------------------------
{
2,REG_UBACKREF,REG_UNONPOSIX}
(
1 row)
-- back reference only matches the string, not any constraints
select * from test_regex('(^\w+).*\
1', 'abc abc abc', 'LRP');
test_regex
--------------------------------------------
{
1,REG_UBACKREF,REG_UNONPOSIX,REG_ULOCALE}
{"abc abc abc",abc}
(
2 rows)
select * from test_regex('(^\w+\M).*\
1', 'abc abcd abd', 'LRP');
test_regex
--------------------------------------------
{
1,REG_UBACKREF,REG_UNONPOSIX,REG_ULOCALE}
{"abc abc",abc}
(
2 rows)
select * from test_regex('(\w+(?= )).*\
1', 'abc abcd abd', 'HLRP');
test_regex
------------------------------------------------------------
{
1,REG_UBACKREF,REG_ULOOKAROUND,REG_UNONPOSIX,REG_ULOCALE}
{"abc abc",abc}
(
2 rows)
-- exercise oversize-regmatch_t-array paths in regexec()
-- (that case is not reachable via test_regex, sadly)
select substring('fffoooooooooooooooooooooooooooooooo', '^(.)\
1(.)(.)(.)(.)(.)(.)(
.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)');
substring
-----------
f
(1 row)
select regexp_split_to_array('abcxxxdefyyyghi', '((.))(\1\2)');
regexp_split_to_array
-----------------------
{abc,def,ghi}
(1 row)
-- doing 15 "octal escapes vs back references"
-- # initial zero is always octal
-- expectMatch 15.1 MP "a\\010b" "a\bb" "a\bb"
select * from test_regex('a\010b', E'a\bb', 'MP');
test_regex
-------------------------------
{0,REG_UNONPOSIX,REG_UUNPORT}
{a\x08b}
(2 rows)
-- expectMatch 15.2 MP "a\\0070b" "a\0070b" "a\0070b"
select * from test_regex('a\0070b', E'a\0070b', 'MP');
test_regex
-------------------------------
{0,REG_UNONPOSIX,REG_UUNPORT}
{a\x070b}
(2 rows)
-- expectMatch 15.3 MP "a\\07b" "a\007b" "a\007b"
select * from test_regex('a\07b', E'a\007b', 'MP');
test_regex
-------------------------------
{0,REG_UNONPOSIX,REG_UUNPORT}
{a\x07b}
(2 rows)
-- expectMatch 15.4 MP "a(b)(b)(b)(b)(b)(b)(b)(b)(b)(b)\\07c" \
-- "abbbbbbbbbb\007c" abbbbbbbbbb\007c b b b b b b b b b b
select * from test_regex('a(b)(b)(b)(b)(b)(b)(b)(b)(b)(b)\07c', E'abbbbbbbbbb\007c', 'MP');
test_regex
----------------------------------------
{10,REG_UNONPOSIX,REG_UUNPORT}
{abbbbbbbbbb\x07c,b,b,b,b,b,b,b,b,b,b}
(2 rows)
-- # a single digit is always a backref
-- expectError 15.5 - {a\7b} ESUBREG
select * from test_regex('a\7b', '', '-');
ERROR: invalid regular expression: invalid backreference number
-- # otherwise it's a backref only if within range (barf!)
-- expectMatch 15.6 MP "a\\10b" "a\bb" "a\bb"
select * from test_regex('a\10b', E'a\bb', 'MP');
test_regex
-------------------------------
{0,REG_UNONPOSIX,REG_UUNPORT}
{a\x08b}
(2 rows)
-- expectMatch 15.7 MP {a\101b} aAb aAb
select * from test_regex('a\101b', 'aAb', 'MP');
test_regex
-------------------------------
{0,REG_UNONPOSIX,REG_UUNPORT}
{aAb}
(2 rows)
-- expectMatch 15.8 RP {a(b)(b)(b)(b)(b)(b)(b)(b)(b)(b)\10c} \
-- "abbbbbbbbbbbc" abbbbbbbbbbbc b b b b b b b b b b
select * from test_regex('a(b)(b)(b)(b)(b)(b)(b)(b)(b)(b)\10c', 'abbbbbbbbbbbc', 'RP');
test_regex
-------------------------------------
{10,REG_UBACKREF,REG_UNONPOSIX}
{abbbbbbbbbbbc,b,b,b,b,b,b,b,b,b,b}
(2 rows)
-- # but we're fussy about border cases -- guys who want octal should use the zero
-- expectError 15.9 - {a((((((((((b\10))))))))))c} ESUBREG
select * from test_regex('a((((((((((b\10))))))))))c', '', '-');
ERROR: invalid regular expression: invalid backreference number
-- # BREs don't have octal, EREs don't have backrefs
-- expectMatch 15.10 MP "a\\12b" "a\nb" "a\nb"
select * from test_regex('a\12b', E'a\nb', 'MP');
test_regex
-------------------------------
{0,REG_UNONPOSIX,REG_UUNPORT}
{"a +
b"}
(2 rows)
-- expectError 15.11 b {a\12b} ESUBREG
select * from test_regex('a\12b', '', 'b');
ERROR: invalid regular expression: invalid backreference number
-- expectMatch 15.12 eAS {a\12b} a12b a12b
select * from test_regex('a\12b', 'a12b', 'eAS');
test_regex
------------------------------
{0,REG_UBSALNUM,REG_UUNSPEC}
{a12b}
(2 rows)
-- expectMatch 15.13 MP {a\701b} a\u00381b a\u00381b
select * from test_regex('a\701b', 'a81b', 'MP');
test_regex
-------------------------------
{0,REG_UNONPOSIX,REG_UUNPORT}
{a81b}
(2 rows)
-- doing 16 "expanded syntax"
-- expectMatch 16.1 xP "a b c" "abc" "abc"
select * from test_regex('a b c', 'abc', 'xP');
test_regex
-------------------
{0,REG_UNONPOSIX}
{abc}
(2 rows)
-- expectMatch 16.2 xP "a b #oops\nc\td" "abcd" "abcd"
select * from test_regex(E'a b #oops\nc\td', 'abcd', 'xP');
test_regex
-------------------
{0,REG_UNONPOSIX}
{abcd}
(2 rows)
-- expectMatch 16.3 x "a\\ b\\\tc" "a b\tc" "a b\tc"
select * from test_regex(E'a\\ b\\\tc', E'a b\tc', 'x');
test_regex
-------------
{0}
{"a b c"}
(2 rows)
-- expectMatch 16.4 xP "a b\\#c" "ab#c" "ab#c"
select * from test_regex('a b\#c', 'ab#c', 'xP');
test_regex
-------------------
{0,REG_UNONPOSIX}
{ab#c}
(2 rows)
-- expectMatch 16.5 xP "a b\[c d]e" "ab e" "ab e"
select * from test_regex('a b[c d]e', 'ab e', 'xP');
test_regex
-------------------
{0,REG_UNONPOSIX}
{"ab e"}
(2 rows)
-- expectMatch 16.6 xP "a b\[c#d]e" "ab#e" "ab#e"
select * from test_regex('a b[c#d]e', 'ab#e', 'xP');
test_regex
-------------------
{0,REG_UNONPOSIX}
{ab#e}
(2 rows)
-- expectMatch 16.7 xP "a b\[c#d]e" "abde" "abde"
select * from test_regex('a b[c#d]e', 'abde', 'xP');
test_regex
-------------------
{0,REG_UNONPOSIX}
{abde}
(2 rows)
-- expectMatch 16.8 xSPB "ab{ d" "ab\{d" "ab\{d"
select * from test_regex('ab{ d', 'ab{d', 'xSPB');
test_regex
-------------------------------------------
{0,REG_UBRACES,REG_UNONPOSIX,REG_UUNSPEC}
{"ab{d"}
(2 rows)
-- expectMatch 16.9 xPQ "ab{ 1 , 2 }c" "abc" "abc"
select * from test_regex('ab{ 1 , 2 }c', 'abc', 'xPQ');
test_regex
-------------------------------
{0,REG_UBOUNDS,REG_UNONPOSIX}
{abc}
(2 rows)
-- doing 17 "misc syntax"
-- expectMatch 17.1 P a(?#comment)b ab ab
select * from test_regex('a(?#comment)b', 'ab', 'P');
test_regex
-------------------
{0,REG_UNONPOSIX}
{ab}
(2 rows)
-- doing 18 "unmatchable REs"
-- expectNomatch 18.1 I a^b ab
select * from test_regex('a^b', 'ab', 'I');
test_regex
---------------------
{0,REG_UIMPOSSIBLE}
(1 row)
-- doing 19 "case independence"
-- expectMatch 19.1 &i ab Ab Ab
select * from test_regex('ab', 'Ab', 'i');
test_regex
------------
{0}
{Ab}
(2 rows)
select * from test_regex('ab', 'Ab', 'ib');
test_regex
------------
{0}
{Ab}
(2 rows)
-- expectMatch 19.2 &i {a[bc]} aC aC
select * from test_regex('a[bc]', 'aC', 'i');
test_regex
------------
{0}
{aC}
(2 rows)
select * from test_regex('a[bc]', 'aC', 'ib');
test_regex
------------
{0}
{aC}
(2 rows)
-- expectNomatch 19.3 &i {a[^bc]} aB
select * from test_regex('a[^bc]', 'aB', 'i');
test_regex
------------
{0}
(1 row)
select * from test_regex('a[^bc]', 'aB', 'ib');
test_regex
------------
{0}
(1 row)
-- expectMatch 19.4 &iM {a[b-d]} aC aC
select * from test_regex('a[b-d]', 'aC', 'iM');
test_regex
-----------------
{0,REG_UUNPORT}
{aC}
(2 rows)
select * from test_regex('a[b-d]', 'aC', 'iMb');
test_regex
-----------------
{0,REG_UUNPORT}
{aC}
(2 rows)
-- expectNomatch 19.5 &iM {a[^b-d]} aC
select * from test_regex('a[^b-d]', 'aC', 'iM');
test_regex
-----------------
{0,REG_UUNPORT}
(1 row)
select * from test_regex('a[^b-d]', 'aC', 'iMb');
test_regex
-----------------
{0,REG_UUNPORT}
(1 row)
-- expectMatch 19.6 &iM {a[B-Z]} aC aC
select * from test_regex('a[B-Z]', 'aC', 'iM');
test_regex
-----------------
{0,REG_UUNPORT}
{aC}
(2 rows)
select * from test_regex('a[B-Z]', 'aC', 'iMb');
test_regex
-----------------
{0,REG_UUNPORT}
{aC}
(2 rows)
-- expectNomatch 19.7 &iM {a[^B-Z]} aC
select * from test_regex('a[^B-Z]', 'aC', 'iM');
test_regex
-----------------
{0,REG_UUNPORT}
(1 row)
select * from test_regex('a[^B-Z]', 'aC', 'iMb');
test_regex
-----------------
{0,REG_UUNPORT}
(1 row)
-- doing 20 "directors and embedded options"
-- expectError 20.1 & ***? BADPAT
select * from test_regex('***?', '', '');
ERROR: invalid regular expression: invalid regexp (reg version 0.8)
select * from test_regex('***?', '', 'b');
ERROR: invalid regular expression: invalid regexp (reg version 0.8)
-- expectMatch 20.2 q ***? ***? ***?
select * from test_regex('***?', '***?', 'q');
test_regex
------------
{0}
{***?}
(2 rows)
-- expectMatch 20.3 &P ***=a*b a*b a*b
select * from test_regex('***=a*b', 'a*b', 'P');
test_regex
-------------------
{0,REG_UNONPOSIX}
{a*b}
(2 rows)
select * from test_regex('***=a*b', 'a*b', 'Pb');
test_regex
-------------------
{0,REG_UNONPOSIX}
{a*b}
(2 rows)
-- expectMatch 20.4 q ***=a*b ***=a*b ***=a*b
select * from test_regex('***=a*b', '***=a*b', 'q');
test_regex
------------
{0}
{***=a*b}
(2 rows)
-- expectMatch 20.5 bLP {***:\w+} ab ab
select * from test_regex('***:\w+', 'ab', 'bLP');
test_regex
-------------------------------
{0,REG_UNONPOSIX,REG_ULOCALE}
{ab}
(2 rows)
-- expectMatch 20.6 eLP {***:\w+} ab ab
select * from test_regex('***:\w+', 'ab', 'eLP');
test_regex
-------------------------------
{0,REG_UNONPOSIX,REG_ULOCALE}
{ab}
(2 rows)
-- expectError 20.7 & ***:***=a*b BADRPT
select * from test_regex('***:***=a*b', '', '');
ERROR: invalid regular expression: quantifier operand invalid
select * from test_regex('***:***=a*b', '', 'b');
ERROR: invalid regular expression: quantifier operand invalid
-- expectMatch 20.8 &P ***:(?b)a+b a+b a+b
select * from test_regex('***:(?b)a+b', 'a+b', 'P');
test_regex
-------------------
{0,REG_UNONPOSIX}
{a+b}
(2 rows)
select * from test_regex('***:(?b)a+b', 'a+b', 'Pb');
test_regex
-------------------
{0,REG_UNONPOSIX}
{a+b}
(2 rows)
-- expectMatch 20.9 P (?b)a+b a+b a+b
select * from test_regex('(?b)a+b', 'a+b', 'P');
test_regex
-------------------
{0,REG_UNONPOSIX}
{a+b}
(2 rows)
-- expectError 20.10 e {(?b)\w+} BADRPT
select * from test_regex('(?b)\w+', '', 'e');
ERROR: invalid regular expression: quantifier operand invalid
-- expectMatch 20.11 bAS {(?b)\w+} (?b)w+ (?b)w+
select * from test_regex('(?b)\w+', '(?b)w+', 'bAS');
test_regex
------------------------------
{0,REG_UBSALNUM,REG_UUNSPEC}
{(?b)w+}
(2 rows)
-- expectMatch 20.12 iP (?c)a a a
select * from test_regex('(?c)a', 'a', 'iP');
test_regex
-------------------
{0,REG_UNONPOSIX}
{a}
(2 rows)
-- expectNomatch 20.13 iP (?c)a A
select * from test_regex('(?c)a', 'A', 'iP');
test_regex
-------------------
{0,REG_UNONPOSIX}
(1 row)
-- expectMatch 20.14 APS {(?e)\W+} WW WW
select * from test_regex('(?e)\W+', 'WW', 'APS');
test_regex
--------------------------------------------
{0,REG_UBSALNUM,REG_UNONPOSIX,REG_UUNSPEC}
{WW}
(2 rows)
-- expectMatch 20.15 P (?i)a+ Aa Aa
select * from test_regex('(?i)a+', 'Aa', 'P');
test_regex
-------------------
{0,REG_UNONPOSIX}
{Aa}
(2 rows)
-- expectNomatch 20.16 P "(?m)a.b" "a\nb"
select * from test_regex('(?m)a.b', E'a\nb', 'P');
test_regex
-------------------
{0,REG_UNONPOSIX}
(1 row)
-- expectMatch 20.17 P "(?m)^b" "a\nb" "b"
select * from test_regex('(?m)^b', E'a\nb', 'P');
test_regex
-------------------
{0,REG_UNONPOSIX}
{b}
(2 rows)
-- expectNomatch 20.18 P "(?n)a.b" "a\nb"
select * from test_regex('(?n)a.b', E'a\nb', 'P');
test_regex
-------------------
{0,REG_UNONPOSIX}
(1 row)
-- expectMatch 20.19 P "(?n)^b" "a\nb" "b"
select * from test_regex('(?n)^b', E'a\nb', 'P');
test_regex
-------------------
{0,REG_UNONPOSIX}
{b}
(2 rows)
-- expectNomatch 20.20 P "(?p)a.b" "a\nb"
select * from test_regex('(?p)a.b', E'a\nb', 'P');
test_regex
-------------------
{0,REG_UNONPOSIX}
(1 row)
-- expectNomatch 20.21 P "(?p)^b" "a\nb"
select * from test_regex('(?p)^b', E'a\nb', 'P');
test_regex
-------------------
{0,REG_UNONPOSIX}
(1 row)
-- expectMatch 20.22 P (?q)a+b a+b a+b
select * from test_regex('(?q)a+b', 'a+b', 'P');
test_regex
-------------------
{0,REG_UNONPOSIX}
{a+b}
(2 rows)
-- expectMatch 20.23 nP "(?s)a.b" "a\nb" "a\nb"
select * from test_regex('(?s)a.b', E'a\nb', 'nP');
test_regex
-------------------
{0,REG_UNONPOSIX}
{"a +
b"}
(2 rows)
-- expectMatch 20.24 xP "(?t)a b" "a b" "a b"
select * from test_regex('(?t)a b', 'a b', 'xP');
test_regex
-------------------
{0,REG_UNONPOSIX}
{"a b"}
(2 rows)
-- expectMatch 20.25 P "(?w)a.b" "a\nb" "a\nb"
select * from test_regex('(?w)a.b', E'a\nb', 'P');
test_regex
-------------------
{0,REG_UNONPOSIX}
{"a +
b"}
(2 rows)
-- expectMatch 20.26 P "(?w)^b" "a\nb" "b"
select * from test_regex('(?w)^b', E'a\nb', 'P');
test_regex
-------------------
{0,REG_UNONPOSIX}
{b}
(2 rows)
-- expectMatch 20.27 P "(?x)a b" "ab" "ab"
select * from test_regex('(?x)a b', 'ab', 'P');
test_regex
-------------------
{0,REG_UNONPOSIX}
{ab}
(2 rows)
-- expectError 20.28 - (?z)ab BADOPT
select * from test_regex('(?z)ab', '', '-');
ERROR: invalid regular expression: invalid embedded option
-- expectMatch 20.29 P (?ici)a+ Aa Aa
select * from test_regex('(?ici)a+', 'Aa', 'P');
test_regex
-------------------
{0,REG_UNONPOSIX}
{Aa}
(2 rows)
-- expectError 20.30 P (?i)(?q)a+ BADRPT
select * from test_regex('(?i)(?q)a+', '', 'P');
ERROR: invalid regular expression: quantifier operand invalid
-- expectMatch 20.31 P (?q)(?i)a+ (?i)a+ (?i)a+
select * from test_regex('(?q)(?i)a+', '(?i)a+', 'P');
test_regex
-------------------
{0,REG_UNONPOSIX}
{(?i)a+}
(2 rows)
-- expectMatch 20.32 P (?qe)a+ a a
select * from test_regex('(?qe)a+', 'a', 'P');
test_regex
-------------------
{0,REG_UNONPOSIX}
{a}
(2 rows)
-- expectMatch 20.33 xP "(?q)a b" "a b" "a b"
select * from test_regex('(?q)a b', 'a b', 'xP');
test_regex
-------------------
{0,REG_UNONPOSIX}
{"a b"}
(2 rows)
-- expectMatch 20.34 P "(?qx)a b" "a b" "a b"
select * from test_regex('(?qx)a b', 'a b', 'P');
test_regex
-------------------
{0,REG_UNONPOSIX}
{"a b"}
(2 rows)
-- expectMatch 20.35 P (?qi)ab Ab Ab
select * from test_regex('(?qi)ab', 'Ab', 'P');
test_regex
-------------------
{0,REG_UNONPOSIX}
{Ab}
(2 rows)
-- doing 21 "capturing"
-- expectMatch 21.1 - a(b)c abc abc b
select * from test_regex('a(b)c', 'abc', '-');
test_regex
------------
{1}
{abc,b}
(2 rows)
-- expectMatch 21.2 P a(?:b)c xabc abc
select * from test_regex('a(?:b)c', 'xabc', 'P');
test_regex
-------------------
{0,REG_UNONPOSIX}
{abc}
(2 rows)
-- expectMatch 21.3 - a((b))c xabcy abc b b
select * from test_regex('a((b))c', 'xabcy', '-');
test_regex
------------
{2}
{abc,b,b}
(2 rows)
-- expectMatch 21.4 P a(?:(b))c abcy abc b
select * from test_regex('a(?:(b))c', 'abcy', 'P');
test_regex
-------------------
{1,REG_UNONPOSIX}
{abc,b}
(2 rows)
-- expectMatch 21.5 P a((?:b))c abc abc b
select * from test_regex('a((?:b))c', 'abc', 'P');
test_regex
-------------------
{1,REG_UNONPOSIX}
{abc,b}
(2 rows)
-- expectMatch 21.6 P a(?:(?:b))c abc abc
select * from test_regex('a(?:(?:b))c', 'abc', 'P');
test_regex
-------------------
{0,REG_UNONPOSIX}
{abc}
(2 rows)
-- expectIndices 21.7 Q "a(b){0}c" ac {0 1} {-1 -1}
select * from test_regex('a(b){0}c', 'ac', '0Q');
test_regex
-----------------
{1,REG_UBOUNDS}
{"0 1","-1 -1"}
(2 rows)
-- expectMatch 21.8 - a(b)c(d)e abcde abcde b d
select * from test_regex('a(b)c(d)e', 'abcde', '-');
test_regex
-------------
{2}
{abcde,b,d}
(2 rows)
-- expectMatch 21.9 - (b)c(d)e bcde bcde b d
select * from test_regex('(b)c(d)e', 'bcde', '-');
test_regex
------------
{2}
{bcde,b,d}
(2 rows)
-- expectMatch 21.10 - a(b)(d)e abde abde b d
select * from test_regex('a(b)(d)e', 'abde', '-');
test_regex
------------
{2}
{abde,b,d}
(2 rows)
-- expectMatch 21.11 - a(b)c(d) abcd abcd b d
select * from test_regex('a(b)c(d)', 'abcd', '-');
test_regex
------------
{2}
{abcd,b,d}
(2 rows)
-- expectMatch 21.12 - (ab)(cd) xabcdy abcd ab cd
select * from test_regex('(ab)(cd)', 'xabcdy', '-');
test_regex
--------------
{2}
{abcd,ab,cd}
(2 rows)
-- expectMatch 21.13 - a(b)?c xabcy abc b
select * from test_regex('a(b)?c', 'xabcy', '-');
test_regex
------------
{1}
{abc,b}
(2 rows)
-- expectIndices 21.14 - a(b)?c xacy {1 2} {-1 -1}
select * from test_regex('a(b)?c', 'xacy', '0-');
test_regex
-----------------
{1}
{"1 2","-1 -1"}
(2 rows)
-- expectMatch 21.15 - a(b)?c(d)?e xabcdey abcde b d
select * from test_regex('a(b)?c(d)?e', 'xabcdey', '-');
test_regex
-------------
{2}
{abcde,b,d}
(2 rows)
-- expectIndices 21.16 - a(b)?c(d)?e xacdey {1 4} {-1 -1} {3 3}
select * from test_regex('a(b)?c(d)?e', 'xacdey', '0-');
test_regex
-----------------------
{2}
{"1 4","-1 -1","3 3"}
(2 rows)
-- expectIndices 21.17 - a(b)?c(d)?e xabcey {1 4} {2 2} {-1 -1}
select * from test_regex('a(b)?c(d)?e', 'xabcey', '0-');
test_regex
-----------------------
{2}
{"1 4","2 2","-1 -1"}
(2 rows)
-- expectIndices 21.18 - a(b)?c(d)?e xacey {1 3} {-1 -1} {-1 -1}
select * from test_regex('a(b)?c(d)?e', 'xacey', '0-');
test_regex
-------------------------
{2}
{"1 3","-1 -1","-1 -1"}
(2 rows)
-- expectMatch 21.19 - a(b)*c xabcy abc b
select * from test_regex('a(b)*c', 'xabcy', '-');
test_regex
------------
{1}
{abc,b}
(2 rows)
-- expectIndices 21.20 - a(b)*c xabbbcy {1 5} {4 4}
select * from test_regex('a(b)*c', 'xabbbcy', '0-');
test_regex
---------------
{1}
{"1 5","4 4"}
(2 rows)
-- expectIndices 21.21 - a(b)*c xacy {1 2} {-1 -1}
select * from test_regex('a(b)*c', 'xacy', '0-');
test_regex
-----------------
{1}
{"1 2","-1 -1"}
(2 rows)
-- expectMatch 21.22 - a(b*)c xabbbcy abbbc bbb
select * from test_regex('a(b*)c', 'xabbbcy', '-');
test_regex
-------------
{1}
{abbbc,bbb}
(2 rows)
-- expectMatch 21.23 - a(b*)c xacy ac ""
select * from test_regex('a(b*)c', 'xacy', '-');
test_regex
------------
{1}
{ac,""}
(2 rows)
-- expectNomatch 21.24 - a(b)+c xacy
select * from test_regex('a(b)+c', 'xacy', '-');
test_regex
------------
{1}
(1 row)
-- expectMatch 21.25 - a(b)+c xabcy abc b
select * from test_regex('a(b)+c', 'xabcy', '-');
test_regex
------------
{1}
{abc,b}
(2 rows)
-- expectIndices 21.26 - a(b)+c xabbbcy {1 5} {4 4}
select * from test_regex('a(b)+c', 'xabbbcy', '0-');
test_regex
---------------
{1}
{"1 5","4 4"}
(2 rows)
-- expectMatch 21.27 - a(b+)c xabbbcy abbbc bbb
select * from test_regex('a(b+)c', 'xabbbcy', '-');
test_regex
-------------
{1}
{abbbc,bbb}
(2 rows)
-- expectIndices 21.28 Q "a(b){2,3}c" xabbbcy {1 5} {4 4}
select * from test_regex('a(b){2,3}c', 'xabbbcy', '0Q');
test_regex
-----------------
{1,REG_UBOUNDS}
{"1 5","4 4"}
(2 rows)
-- expectIndices 21.29 Q "a(b){2,3}c" xabbcy {1 4} {3 3}
select * from test_regex('a(b){2,3}c', 'xabbcy', '0Q');
test_regex
-----------------
{1,REG_UBOUNDS}
{"1 4","3 3"}
(2 rows)
-- expectNomatch 21.30 Q "a(b){2,3}c" xabcy
select * from test_regex('a(b){2,3}c', 'xabcy', 'Q');
test_regex
-----------------
{1,REG_UBOUNDS}
(1 row)
-- expectMatch 21.31 LP "\\y(\\w+)\\y" "-- abc-" "abc" "abc"
select * from test_regex('\y(\w+)\y', '-- abc-', 'LP');
test_regex
-------------------------------
{1,REG_UNONPOSIX,REG_ULOCALE}
{abc,abc}
(2 rows)
-- expectMatch 21.32 - a((b|c)d+)+ abacdbd acdbd bd b
select * from test_regex('a((b|c)d+)+', 'abacdbd', '-');
test_regex
--------------
{2}
{acdbd,bd,b}
(2 rows)
-- expectMatch 21.33 N (.*).* abc abc abc
select * from test_regex('(.*).*', 'abc', 'N');
test_regex
---------------------
{1,REG_UEMPTYMATCH}
{abc,abc}
(2 rows)
-- expectMatch 21.34 N (a*)* bc "" ""
select * from test_regex('(a*)*', 'bc', 'N');
test_regex
---------------------
{1,REG_UEMPTYMATCH}
{"",""}
(2 rows)
-- expectMatch 21.35 M { TO (([a-z0-9._]+|"([^"]+|"")+")+)} {asd TO foo} { TO foo} foo o {}
select * from test_regex(' TO (([a-z0-9._]+|"([^"]+|"")+")+)', 'asd TO foo', 'M');
test_regex
------------------------
{3,REG_UUNPORT}
{" TO foo",foo,o,NULL}
(2 rows)
-- expectMatch 21.36 RPQ ((.))(\2){0} xy x x x {}
select * from test_regex('((.))(\2){0}', 'xy', 'RPQ');
test_regex
--------------------------------------------
{3,REG_UBACKREF,REG_UBOUNDS,REG_UNONPOSIX}
{x,x,x,NULL}
(2 rows)
-- expectMatch 21.37 RP ((.))(\2) xyy yy y y y
select * from test_regex('((.))(\2)', 'xyy', 'RP');
test_regex
--------------------------------
{3,REG_UBACKREF,REG_UNONPOSIX}
{yy,y,y,y}
(2 rows)
-- expectMatch 21.38 oRP ((.))(\2) xyy yy {} {} {}
select * from test_regex('((.))(\2)', 'xyy', 'oRP');
test_regex
--------------------------------
{3,REG_UBACKREF,REG_UNONPOSIX}
{yy,NULL,NULL,NULL}
(2 rows)
-- expectNomatch 21.39 PQR {(.){0}(\1)} xxx
select * from test_regex('(.){0}(\1)', 'xxx', 'PQR');
test_regex
--------------------------------------------
{2,REG_UBACKREF,REG_UBOUNDS,REG_UNONPOSIX}
(1 row)
-- expectNomatch 21.40 PQR {((.)){0}(\2)} xxx
select * from test_regex('((.)){0}(\2)', 'xxx', 'PQR');
test_regex
--------------------------------------------
{3,REG_UBACKREF,REG_UBOUNDS,REG_UNONPOSIX}
(1 row)
-- expectMatch 21.41 NPQR {((.)){0}(\2){0}} xyz {} {} {} {}
select * from test_regex('((.)){0}(\2){0}', 'xyz', 'NPQR');
test_regex
------------------------------------------------------------
{3,REG_UBACKREF,REG_UBOUNDS,REG_UNONPOSIX,REG_UEMPTYMATCH}
{"",NULL,NULL,NULL}
(2 rows)
-- doing 22 "multicharacter collating elements"
-- # again ugh
-- MCCEs are not implemented in Postgres, so we skip all these tests
-- expectMatch 22.1 &+L {a[c]e} ace ace
-- select * from test_regex('a[c]e', 'ace', '+L');
-- select * from test_regex('a[c]e', 'ace', '+Lb');
-- expectNomatch 22.2 &+IL {a[c]h} ach
-- select * from test_regex('a[c]h', 'ach', '+IL');
-- select * from test_regex('a[c]h', 'ach', '+ILb');
-- expectMatch 22.3 &+L {a[[.ch.]]} ach ach
-- select * from test_regex('a[[.ch.]]', 'ach', '+L');
-- select * from test_regex('a[[.ch.]]', 'ach', '+Lb');
-- expectNomatch 22.4 &+L {a[[.ch.]]} ace
-- select * from test_regex('a[[.ch.]]', 'ace', '+L');
-- select * from test_regex('a[[.ch.]]', 'ace', '+Lb');
-- expectMatch 22.5 &+L {a[c[.ch.]]} ac ac
-- select * from test_regex('a[c[.ch.]]', 'ac', '+L');
-- select * from test_regex('a[c[.ch.]]', 'ac', '+Lb');
-- expectMatch 22.6 &+L {a[c[.ch.]]} ace ac
-- select * from test_regex('a[c[.ch.]]', 'ace', '+L');
-- select * from test_regex('a[c[.ch.]]', 'ace', '+Lb');
-- expectMatch 22.7 &+L {a[c[.ch.]]} ache ach
-- select * from test_regex('a[c[.ch.]]', 'ache', '+L');
-- select * from test_regex('a[c[.ch.]]', 'ache', '+Lb');
-- expectNomatch 22.8 &+L {a[^c]e} ace
-- select * from test_regex('a[^c]e', 'ace', '+L');
-- select * from test_regex('a[^c]e', 'ace', '+Lb');
-- expectMatch 22.9 &+L {a[^c]e} abe abe
-- select * from test_regex('a[^c]e', 'abe', '+L');
-- select * from test_regex('a[^c]e', 'abe', '+Lb');
-- expectMatch 22.10 &+L {a[^c]e} ache ache
-- select * from test_regex('a[^c]e', 'ache', '+L');
-- select * from test_regex('a[^c]e', 'ache', '+Lb');
-- expectNomatch 22.11 &+L {a[^[.ch.]]} ach
-- select * from test_regex('a[^[.ch.]]', 'ach', '+L');
-- select * from test_regex('a[^[.ch.]]', 'ach', '+Lb');
-- expectMatch 22.12 &+L {a[^[.ch.]]} ace ac
-- select * from test_regex('a[^[.ch.]]', 'ace', '+L');
-- select * from test_regex('a[^[.ch.]]', 'ace', '+Lb');
-- expectMatch 22.13 &+L {a[^[.ch.]]} ac ac
-- select * from test_regex('a[^[.ch.]]', 'ac', '+L');
-- select * from test_regex('a[^[.ch.]]', 'ac', '+Lb');
-- expectMatch 22.14 &+L {a[^[.ch.]]} abe ab
-- select * from test_regex('a[^[.ch.]]', 'abe', '+L');
-- select * from test_regex('a[^[.ch.]]', 'abe', '+Lb');
-- expectNomatch 22.15 &+L {a[^c[.ch.]]} ach
-- select * from test_regex('a[^c[.ch.]]', 'ach', '+L');
-- select * from test_regex('a[^c[.ch.]]', 'ach', '+Lb');
-- expectNomatch 22.16 &+L {a[^c[.ch.]]} ace
-- select * from test_regex('a[^c[.ch.]]', 'ace', '+L');
-- select * from test_regex('a[^c[.ch.]]', 'ace', '+Lb');
-- expectNomatch 22.17 &+L {a[^c[.ch.]]} ac
-- select * from test_regex('a[^c[.ch.]]', 'ac', '+L');
-- select * from test_regex('a[^c[.ch.]]', 'ac', '+Lb');
-- expectMatch 22.18 &+L {a[^c[.ch.]]} abe ab
-- select * from test_regex('a[^c[.ch.]]', 'abe', '+L');
-- select * from test_regex('a[^c[.ch.]]', 'abe', '+Lb');
-- expectMatch 22.19 &+L {a[^b]} ac ac
-- select * from test_regex('a[^b]', 'ac', '+L');
-- select * from test_regex('a[^b]', 'ac', '+Lb');
-- expectMatch 22.20 &+L {a[^b]} ace ac
-- select * from test_regex('a[^b]', 'ace', '+L');
-- select * from test_regex('a[^b]', 'ace', '+Lb');
-- expectMatch 22.21 &+L {a[^b]} ach ach
-- select * from test_regex('a[^b]', 'ach', '+L');
-- select * from test_regex('a[^b]', 'ach', '+Lb');
-- expectNomatch 22.22 &+L {a[^b]} abe
-- select * from test_regex('a[^b]', 'abe', '+L');
-- select * from test_regex('a[^b]', 'abe', '+Lb');
-- doing 23 "lookahead constraints"
-- expectMatch 23.1 HP a(?=b)b* ab ab
select * from test_regex('a(?=b)b*', 'ab', 'HP');
test_regex
-----------------------------------
{0,REG_ULOOKAROUND,REG_UNONPOSIX}
{ab}
(2 rows)
-- expectNomatch 23.2 HP a(?=b)b* a
select * from test_regex('a(?=b)b*', 'a', 'HP');
test_regex
-----------------------------------
{0,REG_ULOOKAROUND,REG_UNONPOSIX}
(1 row)
-- expectMatch 23.3 HP a(?=b)b*(?=c)c* abc abc
select * from test_regex('a(?=b)b*(?=c)c*', 'abc', 'HP');
test_regex
-----------------------------------
{0,REG_ULOOKAROUND,REG_UNONPOSIX}
{abc}
(2 rows)
-- expectNomatch 23.4 HP a(?=b)b*(?=c)c* ab
select * from test_regex('a(?=b)b*(?=c)c*', 'ab', 'HP');
test_regex
-----------------------------------
{0,REG_ULOOKAROUND,REG_UNONPOSIX}
(1 row)
-- expectNomatch 23.5 HP a(?!b)b* ab
select * from test_regex('a(?!b)b*', 'ab', 'HP');
test_regex
-----------------------------------
{0,REG_ULOOKAROUND,REG_UNONPOSIX}
(1 row)
-- expectMatch 23.6 HP a(?!b)b* a a
select * from test_regex('a(?!b)b*', 'a', 'HP');
test_regex
-----------------------------------
{0,REG_ULOOKAROUND,REG_UNONPOSIX}
{a}
(2 rows)
-- expectMatch 23.7 HP (?=b)b b b
select * from test_regex('(?=b)b', 'b', 'HP');
test_regex
-----------------------------------
{0,REG_ULOOKAROUND,REG_UNONPOSIX}
{b}
(2 rows)
-- expectNomatch 23.8 HP (?=b)b a
select * from test_regex('(?=b)b', 'a', 'HP');
test_regex
-----------------------------------
{0,REG_ULOOKAROUND,REG_UNONPOSIX}
(1 row)
-- expectMatch 23.9 HP ...(?!.) abcde cde
select * from test_regex('...(?!.)', 'abcde', 'HP');
test_regex
-----------------------------------
{0,REG_ULOOKAROUND,REG_UNONPOSIX}
{cde}
(2 rows)
-- expectNomatch 23.10 HP ...(?=.) abc
select * from test_regex('...(?=.)', 'abc', 'HP');
test_regex
-----------------------------------
{0,REG_ULOOKAROUND,REG_UNONPOSIX}
(1 row)
-- Postgres addition: lookbehind constraints
-- expectMatch 23.11 HPN (?<=a)b* ab b
select * from test_regex('(?<=a)b*', 'ab', 'HPN');
test_regex
---------------------------------------------------
{0,REG_ULOOKAROUND,REG_UNONPOSIX,REG_UEMPTYMATCH}
{b}
(2 rows)
-- expectNomatch 23.12 HPN (?<=a)b* b
select * from test_regex('(?<=a)b*', 'b', 'HPN');
test_regex
---------------------------------------------------
{0,REG_ULOOKAROUND,REG_UNONPOSIX,REG_UEMPTYMATCH}
(1 row)
-- expectMatch 23.13 HP (?<=a)b*(?<=b)c* abc bc
select * from test_regex('(?<=a)b*(?<=b)c*', 'abc', 'HP');
test_regex
-----------------------------------
{0,REG_ULOOKAROUND,REG_UNONPOSIX}
{bc}
(2 rows)
-- expectNomatch 23.14 HP (?<=a)b*(?<=b)c* ac
select * from test_regex('(?<=a)b*(?<=b)c*', 'ac', 'HP');
test_regex
-----------------------------------
{0,REG_ULOOKAROUND,REG_UNONPOSIX}
(1 row)
-- expectNomatch 23.15 IHP a(?<!a)b* ab
select * from test_regex('a(?<!a)b*', 'ab', 'IHP');
test_regex
---------------------------------------------------
{0,REG_ULOOKAROUND,REG_UNONPOSIX,REG_UIMPOSSIBLE}
(1 row)
-- expectMatch 23.16 HP a(?<!b)b* a a
select * from test_regex('a(?<!b)b*', 'a', 'HP');
test_regex
-----------------------------------
{0,REG_ULOOKAROUND,REG_UNONPOSIX}
{a}
(2 rows)
-- expectMatch 23.17 HP (?<=b)b bb b
select * from test_regex('(?<=b)b', 'bb', 'HP');
test_regex
-----------------------------------
{0,REG_ULOOKAROUND,REG_UNONPOSIX}
{b}
(2 rows)
-- expectNomatch 23.18 HP (?<=b)b b
select * from test_regex('(?<=b)b', 'b', 'HP');
test_regex
-----------------------------------
{0,REG_ULOOKAROUND,REG_UNONPOSIX}
(1 row)
-- expectMatch 23.19 HP (?<=.).. abcde bc
select * from test_regex('(?<=.)..', 'abcde', 'HP');
test_regex
-----------------------------------
{0,REG_ULOOKAROUND,REG_UNONPOSIX}
{bc}
(2 rows)
-- expectMatch 23.20 HP (?<=..)a* aaabb a
select * from test_regex('(?<=..)a*', 'aaabb', 'HP');
test_regex
-----------------------------------
{0,REG_ULOOKAROUND,REG_UNONPOSIX}
{a}
(2 rows)
-- expectMatch 23.21 HP (?<=..)b* aaabb {}
-- Note: empty match here is correct, it matches after the first 2 characters
select * from test_regex('(?<=..)b*', 'aaabb', 'HP');
test_regex
-----------------------------------
{0,REG_ULOOKAROUND,REG_UNONPOSIX}
{""}
(2 rows)
-- expectMatch 23.22 HP (?<=..)b+ aaabb bb
select * from test_regex('(?<=..)b+', 'aaabb', 'HP');
test_regex
-----------------------------------
{0,REG_ULOOKAROUND,REG_UNONPOSIX}
{bb}
(2 rows)
-- doing 24 "non-greedy quantifiers"
-- expectMatch 24.1 PT ab+? abb ab
select * from test_regex('ab+?', 'abb', 'PT');
test_regex
---------------------------------
{0,REG_UNONPOSIX,REG_USHORTEST}
{ab}
(2 rows)
-- expectMatch 24.2 PT ab+?c abbc abbc
select * from test_regex('ab+?c', 'abbc', 'PT');
test_regex
---------------------------------
{0,REG_UNONPOSIX,REG_USHORTEST}
{abbc}
(2 rows)
-- expectMatch 24.3 PT ab*? abb a
select * from test_regex('ab*?', 'abb', 'PT');
test_regex
---------------------------------
{0,REG_UNONPOSIX,REG_USHORTEST}
{a}
(2 rows)
-- expectMatch 24.4 PT ab*?c abbc abbc
select * from test_regex('ab*?c', 'abbc', 'PT');
test_regex
---------------------------------
{0,REG_UNONPOSIX,REG_USHORTEST}
{abbc}
(2 rows)
-- expectMatch 24.5 PT ab?? ab a
select * from test_regex('ab??', 'ab', 'PT');
test_regex
---------------------------------
{0,REG_UNONPOSIX,REG_USHORTEST}
{a}
(2 rows)
-- expectMatch 24.6 PT ab??c abc abc
select * from test_regex('ab??c', 'abc', 'PT');
test_regex
---------------------------------
{0,REG_UNONPOSIX,REG_USHORTEST}
{abc}
(2 rows)
-- expectMatch 24.7 PQT "ab{2,4}?" abbbb abb
select * from test_regex('ab{2,4}?', 'abbbb', 'PQT');
test_regex
---------------------------------------------
{0,REG_UBOUNDS,REG_UNONPOSIX,REG_USHORTEST}
{abb}
(2 rows)
-- expectMatch 24.8 PQT "ab{2,4}?c" abbbbc abbbbc
select * from test_regex('ab{2,4}?c', 'abbbbc', 'PQT');
test_regex
---------------------------------------------
{0,REG_UBOUNDS,REG_UNONPOSIX,REG_USHORTEST}
{abbbbc}
(2 rows)
-- expectMatch 24.9 - 3z* 123zzzz456 3zzzz
select * from test_regex('3z*', '123zzzz456', '-');
test_regex
------------
{0}
{3zzzz}
(2 rows)
-- expectMatch 24.10 PT 3z*? 123zzzz456 3
select * from test_regex('3z*?', '123zzzz456', 'PT');
test_regex
---------------------------------
{0,REG_UNONPOSIX,REG_USHORTEST}
{3}
(2 rows)
-- expectMatch 24.11 - z*4 123zzzz456 zzzz4
select * from test_regex('z*4', '123zzzz456', '-');
test_regex
------------
{0}
{zzzz4}
(2 rows)
-- expectMatch 24.12 PT z*?4 123zzzz456 zzzz4
select * from test_regex('z*?4', '123zzzz456', 'PT');
test_regex
---------------------------------
{0,REG_UNONPOSIX,REG_USHORTEST}
{zzzz4}
(2 rows)
-- expectMatch 24.13 PT {^([^/]+?)(?:/([^/]+?))(?:/([^/]+?))?$} {foo/bar/baz} {foo/bar/baz} {foo} {bar} {baz}
select * from test_regex('^([^/]+?)(?:/([^/]+?))(?:/([^/]+?))?$', 'foo/bar/baz', 'PT');
test_regex
---------------------------------
{3,REG_UNONPOSIX,REG_USHORTEST}
{foo/bar/baz,foo,bar,baz}
(2 rows)
-- expectMatch 24.14 PRT {^(.+?)(?:/(.+?))(?:/(.+?)\3)?$} {foo/bar/baz/quux} {foo/bar/baz/quux} {foo} {bar/baz/quux} {}
select * from test_regex('^(.+?)(?:/(.+?))(?:/(.+?)\3)?$', 'foo/bar/baz/quux', 'PRT');
test_regex
----------------------------------------------
{3,REG_UBACKREF,REG_UNONPOSIX,REG_USHORTEST}
{foo/bar/baz/quux,foo,bar/baz/quux,NULL}
(2 rows)
-- doing 25 "mixed quantifiers"
-- # this is very incomplete as yet
-- # should include |
-- expectMatch 25.1 PNT {^(.*?)(a*)$} "xyza" xyza xyz a
select * from test_regex('^(.*?)(a*)$', 'xyza', 'PNT');
test_regex
-------------------------------------------------
{2,REG_UNONPOSIX,REG_UEMPTYMATCH,REG_USHORTEST}
{xyza,xyz,a}
(2 rows)
-- expectMatch 25.2 PNT {^(.*?)(a*)$} "xyzaa" xyzaa xyz aa
select * from test_regex('^(.*?)(a*)$', 'xyzaa', 'PNT');
test_regex
-------------------------------------------------
{2,REG_UNONPOSIX,REG_UEMPTYMATCH,REG_USHORTEST}
{xyzaa,xyz,aa}
(2 rows)
-- expectMatch 25.3 PNT {^(.*?)(a*)$} "xyz" xyz xyz ""
select * from test_regex('^(.*?)(a*)$', 'xyz', 'PNT');
test_regex
-------------------------------------------------
{2,REG_UNONPOSIX,REG_UEMPTYMATCH,REG_USHORTEST}
{xyz,xyz,""}
(2 rows)
-- doing 26 "tricky cases"
-- # attempts to trick the matcher into accepting a short match
-- expectMatch 26.1 - (week|wee)(night|knights) \
-- "weeknights" weeknights wee knights
select * from test_regex('(week|wee)(night|knights)', 'weeknights', '-');
test_regex
--------------------------
{2}
{weeknights,wee,knights}
(2 rows)
-- expectMatch 26.2 RP {a(bc*).*\1} abccbccb abccbccb b
select * from test_regex('a(bc*).*\1', 'abccbccb', 'RP');
test_regex
--------------------------------
{1,REG_UBACKREF,REG_UNONPOSIX}
{abccbccb,b}
(2 rows)
-- expectMatch 26.3 - {a(b.[bc]*)+} abcbd abcbd bd
select * from test_regex('a(b.[bc]*)+', 'abcbd', '-');
test_regex
------------
{1}
{abcbd,bd}
(2 rows)
-- doing 27 "implementation misc."
-- # duplicate arcs are suppressed
-- expectMatch 27.1 P a(?:b|b)c abc abc
select * from test_regex('a(?:b|b)c', 'abc', 'P');
test_regex
-------------------
{0,REG_UNONPOSIX}
{abc}
(2 rows)
-- # make color/subcolor relationship go back and forth
-- expectMatch 27.2 & {[ab][ab][ab]} aba aba
select * from test_regex('[ab][ab][ab]', 'aba', '');
test_regex
------------
{0}
{aba}
(2 rows)
select * from test_regex('[ab][ab][ab]', 'aba', 'b');
test_regex
------------
{0}
{aba}
(2 rows)
-- expectMatch 27.3 & {[ab][ab][ab][ab][ab][ab][ab]} \
-- "abababa" abababa
select * from test_regex('[ab][ab][ab][ab][ab][ab][ab]', 'abababa', '');
test_regex
------------
{0}
{abababa}
(2 rows)
select * from test_regex('[ab][ab][ab][ab][ab][ab][ab]', 'abababa', 'b');
test_regex
------------
{0}
{abababa}
(2 rows)
-- doing 28 "boundary busters etc."
-- # color-descriptor allocation changes at 10
-- expectMatch 28.1 & abcdefghijkl "abcdefghijkl" abcdefghijkl
select * from test_regex('abcdefghijkl', 'abcdefghijkl', '');
test_regex
----------------
{0}
{abcdefghijkl}
(2 rows)
select * from test_regex('abcdefghijkl', 'abcdefghijkl', 'b');
test_regex
----------------
{0}
{abcdefghijkl}
(2 rows)
-- # so does arc allocation
-- expectMatch 28.2 P a(?:b|c|d|e|f|g|h|i|j|k|l|m)n "agn" agn
select * from test_regex('a(?:b|c|d|e|f|g|h|i|j|k|l|m)n', 'agn', 'P');
test_regex
-------------------
{0,REG_UNONPOSIX}
{agn}
(2 rows)
-- # subexpression tracking also at 10
-- expectMatch 28.3 - a(((((((((((((b)))))))))))))c \
-- "abc" abc b b b b b b b b b b b b b
select * from test_regex('a(((((((((((((b)))))))))))))c', 'abc', '-');
test_regex
---------------------------------
{13}
{abc,b,b,b,b,b,b,b,b,b,b,b,b,b}
(2 rows)
-- # state-set handling changes slightly at unsigned size (might be 64...)
-- # (also stresses arc allocation)
-- expectMatch 28.4 Q "ab{1,100}c" abbc abbc
select * from test_regex('ab{1,100}c', 'abbc', 'Q');
test_regex
-----------------
{0,REG_UBOUNDS}
{abbc}
(2 rows)
-- expectMatch 28.5 Q "ab{1,100}c" \
-- "abbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbc" \
-- abbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbc
select * from test_regex('ab{1,100}c', 'abbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbc', 'Q');
test_regex
---------------------------------------
{0,REG_UBOUNDS}
{abbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbc}
(2 rows)
-- expectMatch 28.6 Q "ab{1,100}c" \
-- "abbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbc"\
-- abbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbc
select * from test_regex('ab{1,100}c', 'abbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbc', 'Q');
test_regex
------------------------------------------------------------------------
{0,REG_UBOUNDS}
{abbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbc}
(2 rows)
-- # force small cache and bust it, several ways
-- expectMatch 28.7 LP {\w+abcdefgh} xyzabcdefgh xyzabcdefgh
select * from test_regex('\w+abcdefgh', 'xyzabcdefgh', 'LP');
test_regex
-------------------------------
{0,REG_UNONPOSIX,REG_ULOCALE}
{xyzabcdefgh}
(2 rows)
-- expectMatch 28.8 %LP {\w+abcdefgh} xyzabcdefgh xyzabcdefgh
select * from test_regex('\w+abcdefgh', 'xyzabcdefgh', '%LP');
test_regex
-------------------------------
{0,REG_UNONPOSIX,REG_ULOCALE}
{xyzabcdefgh}
(2 rows)
-- expectMatch 28.9 %LP {\w+abcdefghijklmnopqrst} \
-- "xyzabcdefghijklmnopqrst" xyzabcdefghijklmnopqrst
select * from test_regex('\w+abcdefghijklmnopqrst', 'xyzabcdefghijklmnopqrst', '%LP');
test_regex
-------------------------------
{0,REG_UNONPOSIX,REG_ULOCALE}
{xyzabcdefghijklmnopqrst}
(2 rows)
-- expectIndices 28.10 %LP {\w+(abcdefgh)?} xyz {0 2} {-1 -1}
select * from test_regex('\w+(abcdefgh)?', 'xyz', '0%LP');
test_regex
-------------------------------
{1,REG_UNONPOSIX,REG_ULOCALE}
{"0 2","-1 -1"}
(2 rows)
-- expectIndices 28.11 %LP {\w+(abcdefgh)?} xyzabcdefg {0 9} {-1 -1}
select * from test_regex('\w+(abcdefgh)?', 'xyzabcdefg', '0%LP');
test_regex
-------------------------------
{1,REG_UNONPOSIX,REG_ULOCALE}
{"0 9","-1 -1"}
(2 rows)
-- expectIndices 28.12 %LP {\w+(abcdefghijklmnopqrst)?} \
-- "xyzabcdefghijklmnopqrs" {0 21} {-1 -1}
select * from test_regex('\w+(abcdefghijklmnopqrst)?', 'xyzabcdefghijklmnopqrs', '0%LP');
test_regex
-------------------------------
{1,REG_UNONPOSIX,REG_ULOCALE}
{"0 21","-1 -1"}
(2 rows)
-- doing 29 "incomplete matches"
-- expectPartial 29.1 t def abc {3 2} ""
select * from test_regex('def', 'abc', '0!t');
test_regex
---------------
{0}
{"3 2","3 2"}
(2 rows)
-- expectPartial 29.2 t bcd abc {1 2} ""
select * from test_regex('bcd', 'abc', '0!t');
test_regex
---------------
{0}
{"1 2","1 2"}
(2 rows)
-- expectPartial 29.3 t abc abab {0 3} ""
select * from test_regex('abc', 'abab', '0!t');
test_regex
---------------
{0}
{"0 3","0 3"}
(2 rows)
-- expectPartial 29.4 t abc abdab {3 4} ""
select * from test_regex('abc', 'abdab', '0!t');
test_regex
---------------
{0}
{"3 4","3 4"}
(2 rows)
-- expectIndices 29.5 t abc abc {0 2} {0 2}
select * from test_regex('abc', 'abc', '0t');
test_regex
---------------
{0}
{"0 2","0 2"}
(2 rows)
-- expectIndices 29.6 t abc xyabc {2 4} {2 4}
select * from test_regex('abc', 'xyabc', '0t');
test_regex
---------------
{0}
{"2 4","2 4"}
(2 rows)
-- expectPartial 29.7 t abc+ xyab {2 3} ""
select * from test_regex('abc+', 'xyab', '0!t');
test_regex
---------------
{0}
{"2 3","2 3"}
(2 rows)
-- expectIndices 29.8 t abc+ xyabc {2 4} {2 4}
select * from test_regex('abc+', 'xyabc', '0t');
test_regex
---------------
{0}
{"2 4","2 4"}
(2 rows)
-- knownBug expectIndices 29.9 t abc+ xyabcd {2 4} {6 5}
select * from test_regex('abc+', 'xyabcd', '0t');
test_regex
---------------
{0}
{"2 4","2 5"}
(2 rows)
-- expectIndices 29.10 t abc+ xyabcdd {2 4} {7 6}
select * from test_regex('abc+', 'xyabcdd', '0t');
test_regex
---------------
{0}
{"2 4","7 6"}
(2 rows)
-- expectPartial 29.11 tPT abc+? xyab {2 3} ""
select * from test_regex('abc+?', 'xyab', '0!tPT');
test_regex
---------------------------------
{0,REG_UNONPOSIX,REG_USHORTEST}
{"2 3","2 3"}
(2 rows)
-- # the retain numbers in these two may look wrong, but they aren't
-- expectIndices 29.12 tPT abc+? xyabc {2 4} {5 4}
select * from test_regex('abc+?', 'xyabc', '0tPT');
test_regex
---------------------------------
{0,REG_UNONPOSIX,REG_USHORTEST}
{"2 4","5 4"}
(2 rows)
-- expectIndices 29.13 tPT abc+? xyabcc {2 4} {6 5}
select * from test_regex('abc+?', 'xyabcc', '0tPT');
test_regex
---------------------------------
{0,REG_UNONPOSIX,REG_USHORTEST}
{"2 4","6 5"}
(2 rows)
-- expectIndices 29.14 tPT abc+? xyabcd {2 4} {6 5}
select * from test_regex('abc+?', 'xyabcd', '0tPT');
test_regex
---------------------------------
{0,REG_UNONPOSIX,REG_USHORTEST}
{"2 4","6 5"}
(2 rows)
-- expectIndices 29.15 tPT abc+? xyabcdd {2 4} {7 6}
select * from test_regex('abc+?', 'xyabcdd', '0tPT');
test_regex
---------------------------------
{0,REG_UNONPOSIX,REG_USHORTEST}
{"2 4","7 6"}
(2 rows)
-- expectIndices 29.16 t abcd|bc xyabc {3 4} {2 4}
select * from test_regex('abcd|bc', 'xyabc', '0t');
test_regex
---------------
{0}
{"3 4","2 4"}
(2 rows)
-- expectPartial 29.17 tn .*k "xx\nyyy" {3 5} ""
select * from test_regex('.*k', E'xx\nyyy', '0!tn');
test_regex
---------------
{0}
{"3 5","3 5"}
(2 rows)
-- doing 30 "misc. oddities and old bugs"
-- expectError 30.1 & *** BADRPT
select * from test_regex('***', '', '');
ERROR: invalid regular expression: quantifier operand invalid
select * from test_regex('***', '', 'b');
ERROR: invalid regular expression: quantifier operand invalid
-- expectMatch 30.2 N a?b* abb abb
select * from test_regex('a?b*', 'abb', 'N');
test_regex
---------------------
{0,REG_UEMPTYMATCH}
{abb}
(2 rows)
-- expectMatch 30.3 N a?b* bb bb
select * from test_regex('a?b*', 'bb', 'N');
test_regex
---------------------
{0,REG_UEMPTYMATCH}
{bb}
(2 rows)
-- expectMatch 30.4 & a*b aab aab
select * from test_regex('a*b', 'aab', '');
test_regex
------------
{0}
{aab}
(2 rows)
select * from test_regex('a*b', 'aab', 'b');
test_regex
------------
{0}
{aab}
(2 rows)
-- expectMatch 30.5 & ^a*b aaaab aaaab
select * from test_regex('^a*b', 'aaaab', '');
test_regex
------------
{0}
{aaaab}
(2 rows)
select * from test_regex('^a*b', 'aaaab', 'b');
test_regex
------------
{0}
{aaaab}
(2 rows)
-- expectMatch 30.6 &M {[0-6][1-2][0-3][0-6][1-6][0-6]} \
-- "010010" 010010
select * from test_regex('[0-6][1-2][0-3][0-6][1-6][0-6]', '010010', 'M');
test_regex
-----------------
{0,REG_UUNPORT}
{010010}
(2 rows)
select * from test_regex('[0-6][1-2][0-3][0-6][1-6][0-6]', '010010', 'Mb');
test_regex
-----------------
{0,REG_UUNPORT}
{010010}
(2 rows)
-- # temporary REG_BOSONLY kludge
-- expectMatch 30.7 s abc abcd abc
select * from test_regex('abc', 'abcd', 's');
test_regex
------------
{0}
{abc}
(2 rows)
-- expectNomatch 30.8 s abc xabcd
select * from test_regex('abc', 'xabcd', 's');
test_regex
------------
{0}
(1 row)
-- # back to normal stuff
-- expectMatch 30.9 HLP {(?n)^(?![t#])\S+} \
-- "tk\n\n#\n#\nit0" it0
select * from test_regex('(?n)^(?![t#])\S+', E'tk\n\n#\n#\nit0', 'HLP');
test_regex
-----------------------------------------------
{0,REG_ULOOKAROUND,REG_UNONPOSIX,REG_ULOCALE}
{it0}
(2 rows)
-- # Now for tests *not* written by Henry Spencer
-- # Tests resulting from bugs reported by users
-- test reg-31.1 {[[:xdigit:]] behaves correctly when followed by [[:space:]]} {
-- set str {2:::DebugWin32}
-- set re {([[:xdigit:]])([[:space:]]*)}
-- list [regexp $re $str match xdigit spaces] $match $xdigit $spaces
-- # Code used to produce {1 2:::DebugWin32 2 :::DebugWin32} !!!
-- } {1 2 2 {}}
select * from test_regex('([[:xdigit:]])([[:space:]]*)', '2:::DebugWin32', 'L');
test_regex
-----------------
{2,REG_ULOCALE}
{2,2,""}
(2 rows)
-- test reg-32.1 {canmatch functionality -- at end} testregexp {
-- set pat {blah}
-- set line "asd asd"
-- # can match at the final d, if '%' follows
-- set res [testregexp -xflags -- c $pat $line resvar]
-- lappend res $resvar
-- } {0 7}
select * from test_regex('blah', 'asd asd', 'c');
test_regex
---------------
{0}
{"7 6","7 6"}
(2 rows)
-- test reg-32.2 {canmatch functionality -- at end} testregexp {
-- set pat {s%$}
-- set line "asd asd"
-- # can only match after the end of the string
-- set res [testregexp -xflags -- c $pat $line resvar]
-- lappend res $resvar
-- } {0 7}
select * from test_regex('s%$', 'asd asd', 'c');
test_regex
---------------
{0}
{"7 6","7 6"}
(2 rows)
-- test reg-32.3 {canmatch functionality -- not last char} testregexp {
-- set pat {[^d]%$}
-- set line "asd asd"
-- # can only match after the end of the string
-- set res [testregexp -xflags -- c $pat $line resvar]
-- lappend res $resvar
-- } {0 7}
select * from test_regex('[^d]%$', 'asd asd', 'c');
test_regex
---------------
{0}
{"7 6","7 6"}
(2 rows)
-- test reg-32.3.1 {canmatch functionality -- no match} testregexp {
-- set pat {\Zx}
-- set line "asd asd"
-- # can match the last char, if followed by x
-- set res [testregexp -xflags -- c $pat $line resvar]
-- lappend res $resvar
-- } {0 -1}
select * from test_regex('\Zx', 'asd asd', 'cIP');
test_regex
-----------------------------------
{0,REG_UNONPOSIX,REG_UIMPOSSIBLE}
{"-1 -1","-1 -1"}
(2 rows)
-- test reg-32.4 {canmatch functionality -- last char} {knownBug testregexp} {
-- set pat {.x}
-- set line "asd asd"
-- # can match the last char, if followed by x
-- set res [testregexp -xflags -- c $pat $line resvar]
-- lappend res $resvar
-- } {0 6}
select * from test_regex('.x', 'asd asd', 'c');
test_regex
---------------
{0}
{"0 6","0 6"}
(2 rows)
-- test reg-32.4.1 {canmatch functionality -- last char} {knownBug testregexp} {
-- set pat {.x$}
-- set line "asd asd"
-- # can match the last char, if followed by x
-- set res [testregexp -xflags -- c $pat $line resvar]
-- lappend res $resvar
-- } {0 6}
select * from test_regex('.x$', 'asd asd', 'c');
test_regex
---------------
{0}
{"0 6","0 6"}
(2 rows)
-- test reg-32.5 {canmatch functionality -- last char} {knownBug testregexp} {
-- set pat {.[^d]x$}
-- set line "asd asd"
-- # can match the last char, if followed by not-d and x.
-- set res [testregexp -xflags -- c $pat $line resvar]
-- lappend res $resvar
-- } {0 6}
select * from test_regex('.[^d]x$', 'asd asd', 'c');
test_regex
---------------
{0}
{"0 6","0 6"}
(2 rows)
-- test reg-32.6 {canmatch functionality -- last char} {knownBug testregexp} {
-- set pat {[^a]%[^\r\n]*$}
-- set line "asd asd"
-- # can match at the final d, if '%' follows
-- set res [testregexp -xflags -- c $pat $line resvar]
-- lappend res $resvar
-- } {0 6}
select * from test_regex('[^a]%[^\r\n]*$', 'asd asd', 'cEP');
test_regex
----------------------------
{0,REG_UBBS,REG_UNONPOSIX}
{"5 6","5 6"}
(2 rows)
-- test reg-32.7 {canmatch functionality -- last char} {knownBug testregexp} {
-- set pat {[^a]%$}
-- set line "asd asd"
-- # can match at the final d, if '%' follows
-- set res [testregexp -xflags -- c $pat $line resvar]
-- lappend res $resvar
-- } {0 6}
select * from test_regex('[^a]%$', 'asd asd', 'c');
test_regex
---------------
{0}
{"5 6","5 6"}
(2 rows)
-- test reg-32.8 {canmatch functionality -- last char} {knownBug testregexp} {
-- set pat {[^x]%$}
-- set line "asd asd"
-- # can match at the final d, if '%' follows
-- set res [testregexp -xflags -- c $pat $line resvar]
-- lappend res $resvar
-- } {0 6}
select * from test_regex('[^x]%$', 'asd asd', 'c');
test_regex
---------------
{0}
{"0 6","0 6"}
(2 rows)
-- test reg-32.9 {canmatch functionality -- more complex case} {knownBug testregexp} {
-- set pat {((\B\B|\Bh+line)[ \t]*|[^\B]%[^\r\n]*)$}
-- set line "asd asd"
-- # can match at the final d, if '%' follows
-- set res [testregexp -xflags -- c $pat $line resvar]
-- lappend res $resvar
-- } {0 6}
select * from test_regex('((\B\B|\Bh+line)[ \t]*|[^\B]%[^\r\n]*)$', 'asd asd', 'cEP');
test_regex
-------------------------------
{2,REG_UBBS,REG_UNONPOSIX}
{"0 6","-1 -1","-1 -1","0 6"}
(2 rows)
-- # Tests reg-33.*: Checks for bug fixes
-- test reg-33.1 {Bug 230589} {
-- regexp {[ ]*(^|[^%])%V} "*%V2" m s
-- } 1
select * from test_regex('[ ]*(^|[^%])%V', '*%V2', '-');
test_regex
------------
{1}
{*%V,*}
(2 rows)
-- test reg-33.2 {Bug 504785} {
-- regexp -inline {([^_.]*)([^.]*)\.(..)(.).*} bbcos_001_c01.q1la
-- } {bbcos_001_c01.q1la bbcos _001_c01 q1 l}
select * from test_regex('([^_.]*)([^.]*)\.(..)(.).*', 'bbcos_001_c01.q1la', '-');
test_regex
------------------------------------------
{4}
{bbcos_001_c01.q1la,bbcos,_001_c01,q1,l}
(2 rows)
-- test reg-33.3 {Bug 505048} {
-- regexp {\A\s*[^<]*\s*<([^>]+)>} a<a>
-- } 1
select * from test_regex('\A\s*[^<]*\s*<([^>]+)>', 'a<a>', 'LP');
test_regex
-------------------------------
{1,REG_UNONPOSIX,REG_ULOCALE}
{a<a>,a}
(2 rows)
-- test reg-33.4 {Bug 505048} {
-- regexp {\A\s*([^b]*)b} ab
-- } 1
select * from test_regex('\A\s*([^b]*)b', 'ab', 'LP');
test_regex
-------------------------------
{1,REG_UNONPOSIX,REG_ULOCALE}
{ab,a}
(2 rows)
-- test reg-33.5 {Bug 505048} {
-- regexp {\A\s*[^b]*(b)} ab
-- } 1
select * from test_regex('\A\s*[^b]*(b)', 'ab', 'LP');
test_regex
-------------------------------
{1,REG_UNONPOSIX,REG_ULOCALE}
{ab,b}
(2 rows)
-- test reg-33.6 {Bug 505048} {
-- regexp {\A(\s*)[^b]*(b)} ab
-- } 1
select * from test_regex('\A(\s*)[^b]*(b)', 'ab', 'LP');
test_regex
-------------------------------
{2,REG_UNONPOSIX,REG_ULOCALE}
{ab,"",b}
(2 rows)
-- test reg-33.7 {Bug 505048} {
-- regexp {\A\s*[^b]*b} ab
-- } 1
select * from test_regex('\A\s*[^b]*b', 'ab', 'LP');
test_regex
-------------------------------
{0,REG_UNONPOSIX,REG_ULOCALE}
{ab}
(2 rows)
-- test reg-33.8 {Bug 505048} {
-- regexp -inline {\A\s*[^b]*b} ab
-- } ab
select * from test_regex('\A\s*[^b]*b', 'ab', 'LP');
test_regex
-------------------------------
{0,REG_UNONPOSIX,REG_ULOCALE}
{ab}
(2 rows)
-- test reg-33.9 {Bug 505048} {
-- regexp -indices -inline {\A\s*[^b]*b} ab
-- } {{0 1}}
select * from test_regex('\A\s*[^b]*b', 'ab', '0LP');
test_regex
-------------------------------
{0,REG_UNONPOSIX,REG_ULOCALE}
{"0 1"}
(2 rows)
-- test reg-33.10 {Bug 840258} -body {
-- regsub {(^|\n)+\.*b} \n.b {} tmp
-- } -cleanup {
-- unset tmp
-- } -result 1
select * from test_regex('(^|\n)+\.*b', E'\n.b', 'P');
test_regex
-------------------
{1,REG_UNONPOSIX}
{" +
.b"," +
"}
(2 rows)
-- test reg-33.11 {Bug 840258} -body {
-- regsub {(^|[\n\r]+)\.*\?<.*?(\n|\r)+} \
-- "TQ\r\n.?<5000267>Test already stopped\r\n" {} tmp
-- } -cleanup {
-- unset tmp
-- } -result 1
select * from test_regex('(^|[\n\r]+)\.*\?<.*?(\n|\r)+', E'TQ\r\n.?<5000267>Test already stopped\r\n', 'EP');
test_regex
-----------------------------------
{2,REG_UBBS,REG_UNONPOSIX}
{"\r +
.?<5000267>Test already stopped\r+
","\r +
"," +
"}
(2 rows)
-- test reg-33.12 {Bug 1810264 - bad read} {
-- regexp {\3161573148} {\3161573148}
-- } 0
select * from test_regex('\3161573148', '\3161573148', 'MP');
test_regex
-------------------------------
{0,REG_UNONPOSIX,REG_UUNPORT}
(1 row)
-- test reg-33.13 {Bug 1810264 - infinite loop} {
-- regexp {($|^)*} {x}
-- } 1
select * from test_regex('($|^)*', 'x', 'N');
test_regex
---------------------
{1,REG_UEMPTYMATCH}
{"",""}
(2 rows)
-- # Some environments have small default stack sizes. [Bug 1905562]
-- test reg-33.14 {Bug 1810264 - super-expensive expression} nonPortable {
-- regexp {(x{200}){200}$y} {x}
-- } 0
-- This might or might not work depending on platform, so skip it
-- select * from test_regex('(x{200}){200}$y', 'x', 'IQ');
-- test reg-33.15.1 {Bug 3603557 - an "in the wild" RE} {
-- lindex [regexp -expanded -about {
-- ^TETRA_MODE_CMD # Message Type
-- ([[:blank:]]+) # Pad
-- (ETS_1_1|ETS_1_2|ETS_2_2) # SystemCode
-- ([[:blank:]]+) # Pad
-- (CONTINUOUS|CARRIER|MCCH|TRAFFIC) # SharingMode
-- ([[:blank:]]+) # Pad
-- ([[:digit:]]{1,2}) # ColourCode
-- ([[:blank:]]+) # Pad
-- (1|2|3|4|6|9|12|18) # TSReservedFrames
-- ([[:blank:]]+) # Pad
-- (PASS|TRUE|FAIL|FALSE) # UPlaneDTX
-- ([[:blank:]]+) # Pad
-- (PASS|TRUE|FAIL|FALSE) # Frame18Extension
-- ([[:blank:]]+) # Pad
-- ([[:digit:]]{1,4}) # MCC
-- ([[:blank:]]+) # Pad
-- ([[:digit:]]{1,5}) # MNC
-- ([[:blank:]]+) # Pad
-- (BOTH|BCAST|ENQRY|NONE) # NbrCellBcast
-- ([[:blank:]]+) # Pad
-- (UNKNOWN|LOW|MEDIUM|HIGH) # CellServiceLevel
-- ([[:blank:]]+) # Pad
-- (PASS|TRUE|FAIL|FALSE) # LateEntryInfo
-- ([[:blank:]]+) # Pad
-- (300|400) # FrequencyBand
-- ([[:blank:]]+) # Pad
-- (NORMAL|REVERSE) # ReverseOperation
-- ([[:blank:]]+) # Pad
-- (NONE|\+6\.25|\-6\.25|\+12\.5) # Offset
-- ([[:blank:]]+) # Pad
-- (10) # DuplexSpacing
-- ([[:blank:]]+) # Pad
-- ([[:digit:]]{1,4}) # MainCarrierNr
-- ([[:blank:]]+) # Pad
-- (0|1|2|3) # NrCSCCH
-- ([[:blank:]]+) # Pad
-- (15|20|25|30|35|40|45) # MSTxPwrMax
-- ([[:blank:]]+) # Pad
-- (\-125|\-120|\-115|\-110|\-105|\-100|\-95|\-90|\-85|\-80|\-75|\-70|\-65|\-60|\-55|\-50)
-- # RxLevAccessMin
-- ([[:blank:]]+) # Pad
-- (\-53|\-51|\-49|\-47|\-45|\-43|\-41|\-39|\-37|\-35|\-33|\-31|\-29|\-27|\-25|\-23)
-- # AccessParameter
-- ([[:blank:]]+) # Pad
-- (DISABLE|[[:digit:]]{3,4}) # RadioDLTimeout
-- ([[:blank:]]+) # Pad
-- (\-[[:digit:]]{2,3}) # RSSIThreshold
-- ([[:blank:]]+) # Pad
-- ([[:digit:]]{1,5}) # CCKIdSCKVerNr
-- ([[:blank:]]+) # Pad
-- ([[:digit:]]{1,5}) # LocationArea
-- ([[:blank:]]+) # Pad
-- ([(1|0)]{16}) # SubscriberClass
-- ([[:blank:]]+) # Pad
-- ([(1|0)]{12}) # BSServiceDetails
-- ([[:blank:]]+) # Pad
-- (RANDOMIZE|IMMEDIATE|[[:digit:]]{1,2}) # IMM
-- ([[:blank:]]+) # Pad
-- ([[:digit:]]{1,2}) # WT
-- ([[:blank:]]+) # Pad
-- ([[:digit:]]{1,2}) # Nu
-- ([[:blank:]]+) # Pad
-- ([0-1]) # FrameLngFctr
-- ([[:blank:]]+) # Pad
-- ([[:digit:]]{1,2}) # TSPtr
-- ([[:blank:]]+) # Pad
-- ([0-7]) # MinPriority
-- ([[:blank:]]+) # Pad
-- (PASS|TRUE|FAIL|FALSE) # ExtdSrvcsEnabled
-- ([[:blank:]]+) # Pad
-- (.*) # ConditionalFields
-- }] 0
-- } 68
select * from test_regex($$
^TETRA_MODE_CMD # Message Type
([[:blank:]]+) # Pad
(ETS_1_1|ETS_1_2|ETS_2_2) # SystemCode
([[:blank:]]+) # Pad
(CONTINUOUS|CARRIER|MCCH|TRAFFIC) # SharingMode
([[:blank:]]+) # Pad
([[:digit:]]{1,2}) # ColourCode
([[:blank:]]+) # Pad
(1|2|3|4|6|9|12|18) # TSReservedFrames
([[:blank:]]+) # Pad
(PASS|TRUE|FAIL|FALSE) # UPlaneDTX
([[:blank:]]+) # Pad
(PASS|TRUE|FAIL|FALSE) # Frame18Extension
([[:blank:]]+) # Pad
([[:digit:]]{1,4}) # MCC
([[:blank:]]+) # Pad
([[:digit:]]{1,5}) # MNC
([[:blank:]]+) # Pad
(BOTH|BCAST|ENQRY|NONE) # NbrCellBcast
([[:blank:]]+) # Pad
(UNKNOWN|LOW|MEDIUM|HIGH) # CellServiceLevel
([[:blank:]]+) # Pad
(PASS|TRUE|FAIL|FALSE) # LateEntryInfo
([[:blank:]]+) # Pad
(300|400) # FrequencyBand
([[:blank:]]+) # Pad
(NORMAL|REVERSE) # ReverseOperation
([[:blank:]]+) # Pad
(NONE|\+6\.25|\-6\.25|\+12\.5) # Offset
([[:blank:]]+) # Pad
(10) # DuplexSpacing
([[:blank:]]+) # Pad
([[:digit:]]{1,4}) # MainCarrierNr
([[:blank:]]+) # Pad
(0|1|2|3) # NrCSCCH
([[:blank:]]+) # Pad
(15|20|25|30|35|40|45) # MSTxPwrMax
([[:blank:]]+) # Pad
(\-125|\-120|\-115|\-110|\-105|\-100|\-95|\-90|\-85|\-80|\-75|\-70|\-65|\-60|\-55|\-50)
# RxLevAccessMin
([[:blank:]]+) # Pad
(\-53|\-51|\-49|\-47|\-45|\-43|\-41|\-39|\-37|\-35|\-33|\-31|\-29|\-27|\-25|\-23)
# AccessParameter
([[:blank:]]+) # Pad
(DISABLE|[[:digit:]]{3,4}) # RadioDLTimeout
([[:blank:]]+) # Pad
(\-[[:digit:]]{2,3}) # RSSIThreshold
([[:blank:]]+) # Pad
([[:digit:]]{1,5}) # CCKIdSCKVerNr
([[:blank:]]+) # Pad
([[:digit:]]{1,5}) # LocationArea
([[:blank:]]+) # Pad
([(1|0)]{16}) # SubscriberClass
([[:blank:]]+) # Pad
([(1|0)]{12}) # BSServiceDetails
([[:blank:]]+) # Pad
(RANDOMIZE|IMMEDIATE|[[:digit:]]{1,2}) # IMM
([[:blank:]]+) # Pad
([[:digit:]]{1,2}) # WT
([[:blank:]]+) # Pad
([[:digit:]]{1,2}) # Nu
([[:blank:]]+) # Pad
([0-1]) # FrameLngFctr
([[:blank:]]+) # Pad
([[:digit:]]{1,2}) # TSPtr
([[:blank:]]+) # Pad
([0-7]) # MinPriority
([[:blank:]]+) # Pad
(PASS|TRUE|FAIL|FALSE) # ExtdSrvcsEnabled
([[:blank:]]+) # Pad
(.*) # ConditionalFields
$$, '', 'xLMPQ');
test_regex
--------------------------------------------------------
{68,REG_UBOUNDS,REG_UNONPOSIX,REG_UUNPORT,REG_ULOCALE}
(1 row)
-- test reg-33.16.1 {Bug [8d2c0da36d]- another "in the wild" RE} {
-- lindex [regexp -about "^MRK:client1: =1339 14HKelly Talisman 10011000 (\[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]*) \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* 8 0 8 0 0 0 77 77 1 1 2 0 11 { 1 3 8 \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* 00000000 1 13HC6 My Creator 2 3 8 \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* 00000000 1 31HC7 Slightly offensive name, huh 3 8 8 \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* 00000000 1 23HE-mail:kelly@hotbox.com 4 9 8 \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* 00000000 1 17Hcompface must die 5 10 8 \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* 00000000 0 3HAir 6 12 8 \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* 00000000 1 14HPGP public key 7 13 8 \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* 00000000 1 16Hkelly@hotbox.com 8 30 8 \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* 00000000 0 12H2 text/plain 9 30 8 \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* 00000000 0 13H2 x-kom/basic 10 33 8 \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* 00000000 1 1H0 11 14 8 \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* 00000000 1 1H3 }\r?"] 0
-- } 1
select * from test_regex(E'^MRK:client1: =1339 14HKelly Talisman 10011000 ([0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]*) [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* 8 0 8 0 0 0 77 77 1 1 2 0 11 { 1 3 8 [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* 00000000 1 13HC6 My Creator 2 3 8 [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* 00000000 1 31HC7 Slightly offensive name, huh 3 8 8 [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* 00000000 1 23HE-mail:kelly@hotbox.com 4 9 8 [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* 00000000 1 17Hcompface must die 5 10 8 [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* 00000000 0 3HAir 6 12 8 [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* 00000000 1 14HPGP public key 7 13 8 [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* 00000000 1 16Hkelly@hotbox.com 8 30 8 [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* 00000000 0 12H2 text/plain 9 30 8 [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* 00000000 0 13H2 x-kom/basic 10 33 8 [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* 00000000 1 1H0 11 14 8 [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* [0-9]* 00000000 1 1H3 }\r?', '', 'BMS');
test_regex
-----------------------------------------
{1,REG_UBRACES,REG_UUNSPEC,REG_UUNPORT}
(1 row)
-- test reg-33.15 {constraint fixes} {
-- regexp {(^)+^} x
-- } 1
select * from test_regex('(^)+^', 'x', 'N');
test_regex
---------------------
{1,REG_UEMPTYMATCH}
{"",""}
(2 rows)
-- test reg-33.16 {constraint fixes} {
-- regexp {($^)+} x
-- } 0
select * from test_regex('($^)+', 'x', 'N');
test_regex
---------------------
{1,REG_UEMPTYMATCH}
(1 row)
-- test reg-33.17 {constraint fixes} {
-- regexp {(^$)*} x
-- } 1
select * from test_regex('(^$)*', 'x', 'N');
test_regex
---------------------
{1,REG_UEMPTYMATCH}
{"",NULL}
(2 rows)
-- test reg-33.18 {constraint fixes} {
-- regexp {(^(?!aa))+} {aa bb cc}
-- } 0
select * from test_regex('(^(?!aa))+', 'aa bb cc', 'HP');
test_regex
-----------------------------------
{1,REG_ULOOKAROUND,REG_UNONPOSIX}
(1 row)
-- test reg-33.19 {constraint fixes} {
-- regexp {(^(?!aa)(?!bb)(?!cc))+} {aa x}
-- } 0
select * from test_regex('(^(?!aa)(?!bb)(?!cc))+', 'aa x', 'HP');
test_regex
-----------------------------------
{1,REG_ULOOKAROUND,REG_UNONPOSIX}
(1 row)
-- test reg-33.20 {constraint fixes} {
-- regexp {(^(?!aa)(?!bb)(?!cc))+} {bb x}
-- } 0
select * from test_regex('(^(?!aa)(?!bb)(?!cc))+', 'bb x', 'HP');
test_regex
-----------------------------------
{1,REG_ULOOKAROUND,REG_UNONPOSIX}
(1 row)
-- test reg-33.21 {constraint fixes} {
-- regexp {(^(?!aa)(?!bb)(?!cc))+} {cc x}
-- } 0
select * from test_regex('(^(?!aa)(?!bb)(?!cc))+', 'cc x', 'HP');
test_regex
-----------------------------------
{1,REG_ULOOKAROUND,REG_UNONPOSIX}
(1 row)
-- test reg-33.22 {constraint fixes} {
-- regexp {(^(?!aa)(?!bb)(?!cc))+} {dd x}
-- } 1
select * from test_regex('(^(?!aa)(?!bb)(?!cc))+', 'dd x', 'HP');
test_regex
-----------------------------------
{1,REG_ULOOKAROUND,REG_UNONPOSIX}
{"",""}
(2 rows)
-- test reg-33.23 {} {
-- regexp {abcd(\m)+xyz} x
-- } 0
select * from test_regex('abcd(\m)+xyz', 'x', 'ILP');
test_regex
-----------------------------------------------
{1,REG_UNONPOSIX,REG_ULOCALE,REG_UIMPOSSIBLE}
(1 row)
-- test reg-33.24 {} {
-- regexp {abcd(\m)+xyz} a
-- } 0
select * from test_regex('abcd(\m)+xyz', 'a', 'ILP');
test_regex
-----------------------------------------------
{1,REG_UNONPOSIX,REG_ULOCALE,REG_UIMPOSSIBLE}
(1 row)
-- test reg-33.25 {} {
-- regexp {^abcd*(((((^(a c(e?d)a+|)+|)+|)+|)+|a)+|)} x
-- } 0
select * from test_regex('^abcd*(((((^(a c(e?d)a+|)+|)+|)+|)+|a)+|)', 'x', 'S');
test_regex
-----------------
{7,REG_UUNSPEC}
(1 row)
-- test reg-33.26 {} {
-- regexp {a^(^)bcd*xy(((((($a+|)+|)+|)+$|)+|)+|)^$} x
-- } 0
select * from test_regex('a^(^)bcd*xy(((((($a+|)+|)+|)+$|)+|)+|)^$', 'x', 'IS');
test_regex
---------------------------------
{7,REG_UUNSPEC,REG_UIMPOSSIBLE}
(1 row)
-- test reg-33.27 {} {
-- regexp {xyz(\Y\Y)+} x
-- } 0
select * from test_regex('xyz(\Y\Y)+', 'x', 'LP');
test_regex
-------------------------------
{1,REG_UNONPOSIX,REG_ULOCALE}
(1 row)
-- test reg-33.28 {} {
-- regexp {x|(?:\M)+} x
-- } 1
select * from test_regex('x|(?:\M)+', 'x', 'LNP');
test_regex
-----------------------------------------------
{0,REG_UNONPOSIX,REG_ULOCALE,REG_UEMPTYMATCH}
{x}
(2 rows)
-- test reg-33.29 {} {
-- # This is near the limits of the RE engine
-- regexp [string repeat x*y*z* 480] x
-- } 1
-- The runtime cost of this seems out of proportion to the value,
-- so for Postgres purposes reduce the repeat to 200x
select * from test_regex(repeat('x*y*z*', 200), 'x', 'N');
test_regex
---------------------
{0,REG_UEMPTYMATCH}
{x}
(2 rows)
-- test reg-33.30 {Bug 1080042} {
-- regexp {(\Y)+} foo
-- } 1
select * from test_regex('(\Y)+', 'foo', 'LNP');
test_regex
-----------------------------------------------
{1,REG_UNONPOSIX,REG_ULOCALE,REG_UEMPTYMATCH}
{"",""}
(2 rows)
-- and now, tests not from either Spencer or the Tcl project
-- These cases exercise additional code paths in pushfwd()/push()/combine()
select * from test_regex('a\Y(?=45)', 'a45', 'HLP');
test_regex
-----------------------------------------------
{0,REG_ULOOKAROUND,REG_UNONPOSIX,REG_ULOCALE}
{a}
(2 rows)
select * from test_regex('a(?=.)c', 'ac', 'HP');
test_regex
-----------------------------------
{0,REG_ULOOKAROUND,REG_UNONPOSIX}
{ac}
(2 rows)
select * from test_regex('a(?=.).*(?=3)3*', 'azz33', 'HP');
test_regex
-----------------------------------
{0,REG_ULOOKAROUND,REG_UNONPOSIX}
{azz33}
(2 rows)
select * from test_regex('a(?=\w)\w*(?=.).*', 'az3%', 'HLP');
test_regex
-----------------------------------------------
{0,REG_ULOOKAROUND,REG_UNONPOSIX,REG_ULOCALE}
{az3%}
(2 rows)
-- These exercise the bulk-arc-movement paths in moveins() and moveouts();
-- you may need to make them longer if you change BULK_ARC_OP_USE_SORT()
select * from test_regex('ABCDEFGHIJKLMNOPQRSTUVWXYZ(?:\w|a|b|c|d|e|f|0|1|2|3|4|5|6|Q)',
'ABCDEFGHIJKLMNOPQRSTUVWXYZ3', 'LP');
test_regex
-------------------------------
{0,REG_UNONPOSIX,REG_ULOCALE}
{ABCDEFGHIJKLMNOPQRSTUVWXYZ3}
(2 rows)
select * from test_regex('ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789(\Y\Y)+',
'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789Z', 'LP');
test_regex
-------------------------------------------
{1,REG_UNONPOSIX,REG_ULOCALE}
{ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789,""}
(2 rows)
select * from test_regex('((x|xabcdefghijklmnopqrstuvwxyz0123456789)x*|[^y]z)$',
'az', '');
test_regex
--------------
{2}
{az,az,NULL}
(2 rows)
