src/test/regress/expected/regex.out

   1 --
   2 -- Regular expression tests
   3 --
   4 -- Don't want to have to double backslashes in regexes
   5 set standard_conforming_strings = on;
   6 -- Test simple quantified backrefs
   7 select 'bbbbb' ~ '^([bc])\1*$' as t;
   8  t
   9 ---
  10  t
  11 (1 row)
  12
  13 select 'ccc' ~ '^([bc])\1*$' as t;
  14  t
  15 ---
  16  t
  17 (1 row)
  18
  19 select 'xxx' ~ '^([bc])\1*$' as f;
  20  f
  21 ---
  22  f
  23 (1 row)
  24
  25 select 'bbc' ~ '^([bc])\1*$' as f;
  26  f
  27 ---
  28  f
  29 (1 row)
  30
  31 select 'b' ~ '^([bc])\1*$' as t;
  32  t
  33 ---
  34  t
  35 (1 row)
  36
  37 -- Test quantified backref within a larger expression
  38 select 'abc abc abc' ~ '^(\w+)( \1)+$' as t;
  39  t
  40 ---
  41  t
  42 (1 row)
  43
  44 select 'abc abd abc' ~ '^(\w+)( \1)+$' as f;
  45  f
  46 ---
  47  f
  48 (1 row)
  49
  50 select 'abc abc abd' ~ '^(\w+)( \1)+$' as f;
  51  f
  52 ---
  53  f
  54 (1 row)
  55
  56 select 'abc abc abc' ~ '^(.+)( \1)+$' as t;
  57  t
  58 ---
  59  t
  60 (1 row)
  61
  62 select 'abc abd abc' ~ '^(.+)( \1)+$' as f;
  63  f
  64 ---
  65  f
  66 (1 row)
  67
  68 select 'abc abc abd' ~ '^(.+)( \1)+$' as f;
  69  f
  70 ---
  71  f
  72 (1 row)
  73
  74 -- Test some cases that crashed in 9.2beta1 due to pmatch[] array overrun
  75 select substring('asd TO foo' from ' TO (([a-z0-9._]+|"([^"]+|"")+")+)');
  76  substring
  77 -----------
  78  foo
  79 (1 row)
  80
  81 select substring('a' from '((a))+');
  82  substring
  83 -----------
  84  a
  85 (1 row)
  86
  87 select substring('a' from '((a)+)');
  88  substring
  89 -----------
  90  a
  91 (1 row)
  92
  93 -- Test regexp_match()
  94 select regexp_match('abc', '');
  95  regexp_match
  96 --------------
  97  {""}
  98 (1 row)
  99
 100 select regexp_match('abc', 'bc');
 101  regexp_match
 102 --------------
 103  {bc}
 104 (1 row)
 105
 106 select regexp_match('abc', 'd') is null;
 107  ?column?
 108 ----------
 109  t
 110 (1 row)
 111
 112 select regexp_match('abc', '(B)(c)', 'i');
 113  regexp_match
 114 --------------
 115  {b,c}
 116 (1 row)
 117
 118 select regexp_match('abc', 'Bd', 'ig'); -- error
 119 ERROR:  regexp_match() does not support the "global" option
 120 HINT:  Use the regexp_matches function instead.
 121 -- Test lookahead constraints
 122 select regexp_matches('ab', 'a(?=b)b*');
 123  regexp_matches
 124 ----------------
 125  {ab}
 126 (1 row)
 127
 128 select regexp_matches('a', 'a(?=b)b*');
 129  regexp_matches
 130 ----------------
 131 (0 rows)
 132
 133 select regexp_matches('abc', 'a(?=b)b*(?=c)c*');
 134  regexp_matches
 135 ----------------
 136  {abc}
 137 (1 row)
 138
 139 select regexp_matches('ab', 'a(?=b)b*(?=c)c*');
 140  regexp_matches
 141 ----------------
 142 (0 rows)
 143
 144 select regexp_matches('ab', 'a(?!b)b*');
 145  regexp_matches
 146 ----------------
 147 (0 rows)
 148
 149 select regexp_matches('a', 'a(?!b)b*');
 150  regexp_matches
 151 ----------------
 152  {a}
 153 (1 row)
 154
 155 select regexp_matches('b', '(?=b)b');
 156  regexp_matches
 157 ----------------
 158  {b}
 159 (1 row)
 160
 161 select regexp_matches('a', '(?=b)b');
 162  regexp_matches
 163 ----------------
 164 (0 rows)
 165
 166 -- Test lookbehind constraints
 167 select regexp_matches('abb', '(?<=a)b*');
 168  regexp_matches
 169 ----------------
 170  {bb}
 171 (1 row)
 172
 173 select regexp_matches('a', 'a(?<=a)b*');
 174  regexp_matches
 175 ----------------
 176  {a}
 177 (1 row)
 178
 179 select regexp_matches('abc', 'a(?<=a)b*(?<=b)c*');
 180  regexp_matches
 181 ----------------
 182  {abc}
 183 (1 row)
 184
 185 select regexp_matches('ab', 'a(?<=a)b*(?<=b)c*');
 186  regexp_matches
 187 ----------------
 188  {ab}
 189 (1 row)
 190
 191 select regexp_matches('ab', 'a*(?<!a)b*');
 192  regexp_matches
 193 ----------------
 194  {""}
 195 (1 row)
 196
 197 select regexp_matches('ab', 'a*(?<!a)b+');
 198  regexp_matches
 199 ----------------
 200 (0 rows)
 201
 202 select regexp_matches('b', 'a*(?<!a)b+');
 203  regexp_matches
 204 ----------------
 205  {b}
 206 (1 row)
 207
 208 select regexp_matches('a', 'a(?<!a)b*');
 209  regexp_matches
 210 ----------------
 211 (0 rows)
 212
 213 select regexp_matches('b', '(?<=b)b');
 214  regexp_matches
 215 ----------------
 216 (0 rows)
 217
 218 select regexp_matches('foobar', '(?<=f)b+');
 219  regexp_matches
 220 ----------------
 221 (0 rows)
 222
 223 select regexp_matches('foobar', '(?<=foo)b+');
 224  regexp_matches
 225 ----------------
 226  {b}
 227 (1 row)
 228
 229 select regexp_matches('foobar', '(?<=oo)b+');
 230  regexp_matches
 231 ----------------
 232  {b}
 233 (1 row)
 234
 235 -- Test optimization of single-chr-or-bracket-expression lookaround constraints
 236 select 'xz' ~ 'x(?=[xy])';
 237  ?column?
 238 ----------
 239  f
 240 (1 row)
 241
 242 select 'xy' ~ 'x(?=[xy])';
 243  ?column?
 244 ----------
 245  t
 246 (1 row)
 247
 248 select 'xz' ~ 'x(?![xy])';
 249  ?column?
 250 ----------
 251  t
 252 (1 row)
 253
 254 select 'xy' ~ 'x(?![xy])';
 255  ?column?
 256 ----------
 257  f
 258 (1 row)
 259
 260 select 'x'  ~ 'x(?![xy])';
 261  ?column?
 262 ----------
 263  t
 264 (1 row)
 265
 266 select 'xyy' ~ '(?<=[xy])yy+';
 267  ?column?
 268 ----------
 269  t
 270 (1 row)
 271
 272 select 'zyy' ~ '(?<=[xy])yy+';
 273  ?column?
 274 ----------
 275  f
 276 (1 row)
 277
 278 select 'xyy' ~ '(?<![xy])yy+';
 279  ?column?
 280 ----------
 281  f
 282 (1 row)
 283
 284 select 'zyy' ~ '(?<![xy])yy+';
 285  ?column?
 286 ----------
 287  t
 288 (1 row)
 289
 290 -- Test conversion of regex patterns to indexable conditions
 291 explain (costs off) select * from pg_proc where proname ~ 'abc';
 292             QUERY PLAN
 293 -----------------------------------
 294  Seq Scan on pg_proc
 295    Filter: (proname ~ 'abc'::text)
 296 (2 rows)
 297
 298 explain (costs off) select * from pg_proc where proname ~ '^abc';
 299                               QUERY PLAN
 300 ----------------------------------------------------------------------
 301  Index Scan using pg_proc_proname_args_nsp_index on pg_proc
 302    Index Cond: ((proname >= 'abc'::text) AND (proname < 'abd'::text))
 303    Filter: (proname ~ '^abc'::text)
 304 (3 rows)
 305
 306 explain (costs off) select * from pg_proc where proname ~ '^abc$';
 307                          QUERY PLAN
 308 ------------------------------------------------------------
 309  Index Scan using pg_proc_proname_args_nsp_index on pg_proc
 310    Index Cond: (proname = 'abc'::text)
 311    Filter: (proname ~ '^abc$'::text)
 312 (3 rows)
 313
 314 explain (costs off) select * from pg_proc where proname ~ '^abcd*e';
 315                               QUERY PLAN
 316 ----------------------------------------------------------------------
 317  Index Scan using pg_proc_proname_args_nsp_index on pg_proc
 318    Index Cond: ((proname >= 'abc'::text) AND (proname < 'abd'::text))
 319    Filter: (proname ~ '^abcd*e'::text)
 320 (3 rows)
 321
 322 explain (costs off) select * from pg_proc where proname ~ '^abc+d';
 323                               QUERY PLAN
 324 ----------------------------------------------------------------------
 325  Index Scan using pg_proc_proname_args_nsp_index on pg_proc
 326    Index Cond: ((proname >= 'abc'::text) AND (proname < 'abd'::text))
 327    Filter: (proname ~ '^abc+d'::text)
 328 (3 rows)
 329
 330 explain (costs off) select * from pg_proc where proname ~ '^(abc)(def)';
 331                                  QUERY PLAN
 332 ----------------------------------------------------------------------------
 333  Index Scan using pg_proc_proname_args_nsp_index on pg_proc
 334    Index Cond: ((proname >= 'abcdef'::text) AND (proname < 'abcdeg'::text))
 335    Filter: (proname ~ '^(abc)(def)'::text)
 336 (3 rows)
 337
 338 explain (costs off) select * from pg_proc where proname ~ '^(abc)$';
 339                          QUERY PLAN
 340 ------------------------------------------------------------
 341  Index Scan using pg_proc_proname_args_nsp_index on pg_proc
 342    Index Cond: (proname = 'abc'::text)
 343    Filter: (proname ~ '^(abc)$'::text)
 344 (3 rows)
 345
 346 explain (costs off) select * from pg_proc where proname ~ '^(abc)?d';
 347                QUERY PLAN
 348 ----------------------------------------
 349  Seq Scan on pg_proc
 350    Filter: (proname ~ '^(abc)?d'::text)
 351 (2 rows)
 352
 353 explain (costs off) select * from pg_proc where proname ~ '^abcd(x|(?=\w\w)q)';
 354                                QUERY PLAN
 355 ------------------------------------------------------------------------
 356  Index Scan using pg_proc_proname_args_nsp_index on pg_proc
 357    Index Cond: ((proname >= 'abcd'::text) AND (proname < 'abce'::text))
 358    Filter: (proname ~ '^abcd(x|(?=\w\w)q)'::text)
 359 (3 rows)
 360
 361 -- Test for infinite loop in pullback() (CVE-2007-4772)
 362 select 'a' ~ '($|^)*';
 363  ?column?
 364 ----------
 365  t
 366 (1 row)
 367
 368 -- These cases expose a bug in the original fix for CVE-2007-4772
 369 select 'a' ~ '(^)+^';
 370  ?column?
 371 ----------
 372  t
 373 (1 row)
 374
 375 select 'a' ~ '$($$)+';
 376  ?column?
 377 ----------
 378  t
 379 (1 row)
 380
 381 -- More cases of infinite loop in pullback(), not fixed by CVE-2007-4772 fix
 382 select 'a' ~ '($^)+';
 383  ?column?
 384 ----------
 385  f
 386 (1 row)
 387
 388 select 'a' ~ '(^$)*';
 389  ?column?
 390 ----------
 391  t
 392 (1 row)
 393
 394 select 'aa bb cc' ~ '(^(?!aa))+';
 395  ?column?
 396 ----------
 397  f
 398 (1 row)
 399
 400 select 'aa x' ~ '(^(?!aa)(?!bb)(?!cc))+';
 401  ?column?
 402 ----------
 403  f
 404 (1 row)
 405
 406 select 'bb x' ~ '(^(?!aa)(?!bb)(?!cc))+';
 407  ?column?
 408 ----------
 409  f
 410 (1 row)
 411
 412 select 'cc x' ~ '(^(?!aa)(?!bb)(?!cc))+';
 413  ?column?
 414 ----------
 415  f
 416 (1 row)
 417
 418 select 'dd x' ~ '(^(?!aa)(?!bb)(?!cc))+';
 419  ?column?
 420 ----------
 421  t
 422 (1 row)
 423
 424 -- Test for infinite loop in fixempties() (Tcl bugs 3604074, 3606683)
 425 select 'a' ~ '((((((a)*)*)*)*)*)*';
 426  ?column?
 427 ----------
 428  t
 429 (1 row)
 430
 431 select 'a' ~ '((((((a+|)+|)+|)+|)+|)+|)';
 432  ?column?
 433 ----------
 434  t
 435 (1 row)
 436
 437 -- These cases used to give too-many-states failures
 438 select 'x' ~ 'abcd(\m)+xyz';
 439  ?column?
 440 ----------
 441  f
 442 (1 row)
 443
 444 select 'a' ~ '^abcd*(((((^(a c(e?d)a+|)+|)+|)+|)+|a)+|)';
 445  ?column?
 446 ----------
 447  f
 448 (1 row)
 449
 450 select 'x' ~ 'a^(^)bcd*xy(((((($a+|)+|)+|)+$|)+|)+|)^$';
 451  ?column?
 452 ----------
 453  f
 454 (1 row)
 455
 456 select 'x' ~ 'xyz(\Y\Y)+';
 457  ?column?
 458 ----------
 459  f
 460 (1 row)
 461
 462 select 'x' ~ 'x|(?:\M)+';
 463  ?column?
 464 ----------
 465  t
 466 (1 row)
 467
 468 -- This generates O(N) states but O(N^2) arcs, so it causes problems
 469 -- if arc count is not constrained
 470 select 'x' ~ repeat('x*y*z*', 1000);
 471 ERROR:  invalid regular expression: regular expression is too complex
 472 -- Test backref in combination with non-greedy quantifier
 473 -- https://core.tcl.tk/tcl/tktview/6585b21ca8fa6f3678d442b97241fdd43dba2ec0
 474 select 'Programmer' ~ '(\w).*?\1' as t;
 475  t
 476 ---
 477  t
 478 (1 row)
 479
 480 select regexp_matches('Programmer', '(\w)(.*?\1)', 'g');
 481  regexp_matches
 482 ----------------
 483  {r,ogr}
 484  {m,m}
 485 (2 rows)
 486
 487 -- Test for proper matching of non-greedy iteration (bug #11478)
 488 select regexp_matches('foo/bar/baz',
 489                       '^([^/]+?)(?:/([^/]+?))(?:/([^/]+?))?$', '');
 490  regexp_matches
 491 ----------------
 492  {foo,bar,baz}
 493 (1 row)
 494
 495 -- Test that greediness can be overridden by outer quantifier
 496 select regexp_matches('llmmmfff', '^(l*)(.*)(f*)$');
 497  regexp_matches
 498 ----------------
 499  {ll,mmmfff,""}
 500 (1 row)
 501
 502 select regexp_matches('llmmmfff', '^(l*){1,1}(.*)(f*)$');
 503  regexp_matches
 504 ----------------
 505  {ll,mmmfff,""}
 506 (1 row)
 507
 508 select regexp_matches('llmmmfff', '^(l*){1,1}?(.*)(f*)$');
 509   regexp_matches
 510 ------------------
 511  {"",llmmmfff,""}
 512 (1 row)
 513
 514 select regexp_matches('llmmmfff', '^(l*){1,1}?(.*){1,1}?(f*)$');
 515  regexp_matches
 516 ----------------
 517  {"",llmmm,fff}
 518 (1 row)
 519
 520 select regexp_matches('llmmmfff', '^(l*?)(.*)(f*)$');
 521   regexp_matches
 522 ------------------
 523  {"",llmmmfff,""}
 524 (1 row)
 525
 526 select regexp_matches('llmmmfff', '^(l*?){1,1}(.*)(f*)$');
 527  regexp_matches
 528 ----------------
 529  {ll,mmmfff,""}
 530 (1 row)
 531
 532 select regexp_matches('llmmmfff', '^(l*?){1,1}?(.*)(f*)$');
 533   regexp_matches
 534 ------------------
 535  {"",llmmmfff,""}
 536 (1 row)
 537
 538 select regexp_matches('llmmmfff', '^(l*?){1,1}?(.*){1,1}?(f*)$');
 539  regexp_matches
 540 ----------------
 541  {"",llmmm,fff}
 542 (1 row)
 543
 544 -- Test for infinite loop in cfindloop with zero-length possible match
 545 -- but no actual match (can only happen in the presence of backrefs)
 546 select 'a' ~ '$()|^\1';
 547  ?column?
 548 ----------
 549  f
 550 (1 row)
 551
 552 select 'a' ~ '.. ()|\1';
 553  ?column?
 554 ----------
 555  f
 556 (1 row)
 557
 558 select 'a' ~ '()*\1';
 559  ?column?
 560 ----------
 561  t
 562 (1 row)
 563
 564 select 'a' ~ '()+\1';
 565  ?column?
 566 ----------
 567  t
 568 (1 row)
 569
 570 -- Test incorrect removal of capture groups within {0}
 571 select 'xxx' ~ '(.){0}(\1)' as f;
 572  f
 573 ---
 574  f
 575 (1 row)
 576
 577 select 'xxx' ~ '((.)){0}(\2)' as f;
 578  f
 579 ---
 580  f
 581 (1 row)
 582
 583 select 'xyz' ~ '((.)){0}(\2){0}' as t;
 584  t
 585 ---
 586  t
 587 (1 row)
 588
 589 -- Test ancient oversight in when to apply zaptreesubs
 590 select 'abcdef' ~ '^(.)\1|\1.' as f;
 591  f
 592 ---
 593  f
 594 (1 row)
 595
 596 select 'abadef' ~ '^((.)\2|..)\2' as f;
 597  f
 598 ---
 599  f
 600 (1 row)
 601
 602 -- Add coverage for some cases in checkmatchall
 603 select regexp_match('xy', '.|...');
 604  regexp_match
 605 --------------
 606  {x}
 607 (1 row)
 608
 609 select regexp_match('xyz', '.|...');
 610  regexp_match
 611 --------------
 612  {xyz}
 613 (1 row)
 614
 615 select regexp_match('xy', '.*');
 616  regexp_match
 617 --------------
 618  {xy}
 619 (1 row)
 620
 621 select regexp_match('fooba', '(?:..)*');
 622  regexp_match
 623 --------------
 624  {foob}
 625 (1 row)
 626
 627 select regexp_match('xyz', repeat('.', 260));
 628  regexp_match
 629 --------------
 630
 631 (1 row)
 632
 633 select regexp_match('foo', '(?:.|){99}');
 634  regexp_match
 635 --------------
 636  {foo}
 637 (1 row)
 638
 639 -- Error conditions
 640 select 'xyz' ~ 'x(\w)(?=\1)';  -- no backrefs in LACONs
 641 ERROR:  invalid regular expression: invalid backreference number
 642 select 'xyz' ~ 'x(\w)(?=(\1))';
 643 ERROR:  invalid regular expression: invalid backreference number
 644 select 'a' ~ '\x7fffffff';  -- invalid chr code
 645 ERROR:  invalid regular expression: invalid escape \ sequence