mirror of
https://git.postgresql.org/git/postgresql.git
synced 2026-02-20 05:17:00 +08:00
65dc30ced6
Regexps like "(.){0}...\1" drew an "invalid backreference number".
That's not unreasonable on its face, since the capture group will
never be matched if it's iterated zero times. However, other engines
such as Perl's don't complain about this, nor do we throw an error for
related cases such as "(.)|\1", even though that backref can never
succeed either. Also, if the zero-iterations case happens at runtime
rather than compile time --- say, "(x)*...\1" when there's no "x" to
be found --- that's not an error, we just deem the backref to not
match. Making this even less defensible, no error was thrown for
nested cases such as "((.)){0}...\2"; and to add insult to injury,
those cases could result in assertion failures instead. (It seems
that nothing especially bad happened in non-assert builds, though.)
Let's just fix it so that no error is thrown and instead the backref
is deemed to never match, so that compile-time detection of no
iterations behaves the same as run-time detection.
Per report from Mark Dilger. This appears to be an aboriginal error
in Spencer's library, so back-patch to all supported versions.
Pre-v14, it turns out to also be necessary to back-patch one aspect of
commits cb76fbd7e/00116dee5, namely to create capture-node subREs with
the begin/end states of their subexpressions, not the current lp/rp
of the outer parseqatom invocation. Otherwise delsub complains that
we're trying to disconnect a state from itself. This is a bit scary
but code examination shows that it's safe: in the pre-v14 code, if we
want to wrap iteration around the subexpression, the first thing we do
is overwrite the atom's begin/end fields with new states. So the
bogus values didn't survive long enough to be used for anything, except
if no iteration is required, in which case it doesn't matter.
Discussion: https://postgr.es/m/A099E4A8-4377-4C64-A98C-3DEDDC075502@enterprisedb.com
test_regex is a module for testing the regular expression package.
It is mostly meant to allow us to absorb Tcl's regex test suite.
Therefore, there are provisions to exercise regex features that
aren't currently exposed at the SQL level by PostgreSQL.
Currently, one function is provided:
test_regex(pattern text, string text, flags text) returns setof text[]
Reports an error if the pattern is an invalid regex. Otherwise,
the first row of output contains the number of subexpressions,
followed by words reporting set bit(s) in the regex's re_info field.
If the pattern doesn't match the string, that's all.
If the pattern does match, the next row contains the whole match
as the first array element. If there are parenthesized subexpression(s),
following array elements contain the matches to those subexpressions.
If the "g" (glob) flag is set, then additional row(s) of output similarly
report any additional matches.
The "flags" argument is a string of zero or more single-character
flags that modify the behavior of the regex package or the test
function. As described in Tcl's reg.test file:
The flag characters are complex and a bit eclectic. Generally speaking,
lowercase letters are compile options, uppercase are expected re_info
bits, and nonalphabetics are match options, controls for how the test is
run, or testing options. The one small surprise is that AREs are the
default, and you must explicitly request lesser flavors of RE. The flags
are as follows. It is admitted that some are not very mnemonic.
- no-op (placeholder)
0 report indices not actual strings
(This substitutes for Tcl's -indices switch)
! expect partial match, report start position anyway
% force small state-set cache in matcher (to test cache replace)
^ beginning of string is not beginning of line
$ end of string is not end of line
* test is Unicode-specific, needs big character set
+ provide fake xy equivalence class and ch collating element
(Note: the equivalence class is implemented, the
collating element is not; so references to [.ch.] fail)
, set REG_PROGRESS (only useful in REG_DEBUG builds)
. set REG_DUMP (only useful in REG_DEBUG builds)
: set REG_MTRACE (only useful in REG_DEBUG builds)
; set REG_FTRACE (only useful in REG_DEBUG builds)
& test as both ARE and BRE
(Not implemented in Postgres, we use separate tests)
b BRE
e ERE
a turn advanced-features bit on (error unless ERE already)
q literal string, no metacharacters at all
g global match (find all matches)
i case-independent matching
o ("opaque") do not return match locations
p newlines are half-magic, excluded from . and [^ only
w newlines are half-magic, significant to ^ and $ only
n newlines are fully magic, both effects
x expanded RE syntax
t incomplete-match reporting
c canmatch (equivalent to "t0!", in Postgres implementation)
s match only at start (REG_BOSONLY)
A backslash-_a_lphanumeric seen
B ERE/ARE literal-_b_race heuristic used
E backslash (_e_scape) seen within []
H looka_h_ead constraint seen
I _i_mpossible to match
L _l_ocale-specific construct seen
M unportable (_m_achine-specific) construct seen
N RE can match empty (_n_ull) string
P non-_P_OSIX construct seen
Q {} _q_uantifier seen
R back _r_eference seen
S POSIX-un_s_pecified syntax seen
T prefers shortest (_t_iny)
U saw original-POSIX botch: unmatched right paren in ERE (_u_gh)