database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-06-14 18:42:34 +03:00
Code Activity

Fix semantics of regular expression back-references.

Browse Source 
POSIX defines the behavior of back-references thus:

    The back-reference expression '\n' shall match the same (possibly
    empty) string of characters as was matched by a subexpression
    enclosed between "\(" and "\)" preceding the '\n'.

As far as I can see, the back-reference is supposed to consider only
the data characters matched by the referenced subexpression.  However,
because our engine copies the NFA constructed from the referenced
subexpression, it effectively enforces any constraints therein, too.
As an example, '(^.)\1' ought to match 'xx', or any other string
starting with two occurrences of the same character; but in our code
it does not, and indeed can't match anything, because the '^' anchor
constraint is included in the backref's copied NFA.  If POSIX intended
that, you'd think they'd mention it.  Perl for one doesn't act that
way, so it's hard to conclude that this isn't a bug.

Fix by modifying the backref's NFA immediately after it's copied from
the reference, replacing all constraint arcs by EMPTY arcs so that the
constraints are treated as automatically satisfied.  This still allows
us to enforce matching rules that depend only on the data characters;
for example, in '(^\d+).*\1' the NFA matching step will still know
that the backref can only match strings of digits.

Perhaps surprisingly, this change does not affect the results of any
of a rather large corpus of real-world regexes.  Nonetheless, I would
not consider back-patching it, since it's a clear compatibility break.

Patch by me, reviewed by Joel Jacobson

Discussion: https://postgr.es/m/661609.1614560029@sss.pgh.pa.us
This commit is contained in:
Tom Lane
2021-03-02 11:34:53 -05:00
parent c5530d8474
commit 4aea704a5b
5 changed files with 107 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

71
src/backend/regex/regc_nfa.c
View File

@ -1382,6 +1382,77 @@ duptraverse(struct nfa *nfa,
}
}
/*
* removeconstraints - remove any constraints in an NFA
*
* Constraint arcs are replaced by empty arcs, essentially treating all
* constraints as automatically satisfied.
*/
static void
removeconstraints(struct nfa *nfa,
struct state *start, /* process subNFA starting here */
struct state *stop) /* and stopping here */
{
if (start == stop)
return;
stop->tmp = stop;
removetraverse(nfa, start);
/* done, except for clearing out the tmp pointers */
stop->tmp = NULL;
cleartraverse(nfa, start);
}
/*
* removetraverse - recursive heart of removeconstraints
*/
static void
removetraverse(struct nfa *nfa,
struct state *s)
{
struct arc *a;
struct arc *oa;
/* Since this is recursive, it could be driven to stack overflow */
if (STACK_TOO_DEEP(nfa->v->re))
{
NERR(REG_ETOOBIG);
return;
}
if (s->tmp != NULL)
return; /* already done */
s->tmp = s;
for (a = s->outs; a != NULL && !NISERR(); a = oa)
{
removetraverse(nfa, a->to);
if (NISERR())
break;
oa = a->outchain;
switch (a->type)
{
case PLAIN:
case EMPTY:
/* nothing to do */
break;
case AHEAD:
case BEHIND:
case '^':
case '$':
case LACON:
/* replace it */
newarc(nfa, EMPTY, 0, s, a->to);
freearc(nfa, a);
break;
default:
NERR(REG_ASSERT);
break;
}
}
}
/*
* cleartraverse - recursive cleanup for algorithms that leave tmp ptrs set
*/

6
src/backend/regex/regcomp.c
View File

@ -150,6 +150,8 @@ static void delsub(struct nfa *, struct state *, struct state *);
static void deltraverse(struct nfa *, struct state *, struct state *);
static void dupnfa(struct nfa *, struct state *, struct state *, struct state *, struct state *);
static void duptraverse(struct nfa *, struct state *, struct state *);
static void removeconstraints(struct nfa *, struct state *, struct state *);
static void removetraverse(struct nfa *, struct state *);
static void cleartraverse(struct nfa *, struct state *);
static struct state *single_color_transition(struct state *, struct state *);
static void specialcolors(struct nfa *);
@ -1182,6 +1184,10 @@ parseqatom(struct vars *v,
dupnfa(v->nfa, v->subs[subno]->begin, v->subs[subno]->end,
atom->begin, atom->end);
NOERR();
/* The backref node's NFA should not enforce any constraints */
removeconstraints(v->nfa, atom->begin, atom->end);
NOERR();
}
/*