Re: like/ilike improvements

I wrote:
> Andrew Dunstan <andrew(at)dunslane(dot)net> writes:
>> Yes, I agree completely. However it looks to me like IsFirstByte will in
>> fact always be true when we get to call NextChar for matching "_" for UTF8.

> If that's true, the patch is failing to achieve its goal of treating %
> bytewise ...

OK, I studied it a bit more and now see what you're driving at: in this
form of the patch, we treat % bytewise unless it is followed by _, in
which case we treat it char-wise. That seems a good tradeoff,
considering that such a pattern is probably pretty uncommon --- we
should be willing to handle it a bit slower to simplify other cases.

The patch seems still not right though, because you are advancing by
bytes when \ follows %, and that isn't correct in a non-UTF8 encoding.
The invariant we are actually insisting on here is that at the time of
entry to MatchText(), whether initial or recursive, t and p must be
correctly char-aligned. I suggest the attached revision of the logic as
a way to clarify that, and maybe save a cycle or two in the inner loop
as well.

Yes, I concur we needn't bother with IsFirstByte except maybe as an
Assert. If it is an Assert it should be up at the top of the function.

regards, tom lane

else if (*p == '%')
{
/* %% is the same as % according to the SQL standard */
/* Advance past all %'s */
do {
NextByte(p, plen);
} while (plen > 0 && *p == '%');
/* Trailing percent matches everything. */
if (plen <= 0)
return LIKE_TRUE;

/*
* Otherwise, scan for a text position at which we can match the
* rest of the pattern.
*/
if (*p == '_')
{
/*
* If we have %_ in the pattern, we need to advance char-wise
* to avoid starting the recursive call on a non-char boundary.
* This could be made more efficient, but at the cost of making
* other paths slower; it seems not a common case, so handle
* it this way.
*/
while (tlen > 0)
{
int matched = MatchText(t, tlen, p, plen);

if (matched != LIKE_FALSE)
return matched; /* TRUE or ABORT */

NextChar(t, tlen);
}
}
else
{
/*
* Optimization to prevent most recursion: don't recurse
* unless first pattern char matches the text char.
*/
char firstpat;

if (*p == '\\')
{
if (plen < 2)
return LIKE_FALSE;
firstpat = p[1];
}
else
firstpat = *p;

while (tlen > 0)
{
if (*t == firstpat)
{
int matched = MatchText(t, tlen, p, plen);

if (matched != LIKE_FALSE)
return matched; /* TRUE or ABORT */
}

/*
* In UTF8 it's cheaper to advance bytewise and do
* useless comparisons of firstpat to non-first bytes
* than to invoke pg_mblen. In other character sets
* we must advance by chars to avoid spurious matches.
*/
#ifdef UTF8OPT
NextByte(t, tlen);
#else
NextChar(t, tlen);
#endif
}
}

/*
* End of text with no match, so no point in trying later places
* to start matching this pattern.
*/
return LIKE_ABORT;
}