• Transform replaceRegexp(One|All) to replace(One|All) if pattern is trivial and replacement doesn't contain any captured substitutions.
• Replace underlying regexp library from re2 to OptimizedRegularExpression.
• Add a new interface unsigned match(std::string_view text, const char * subject, size_t subject_size, MatchVec & matches, unsigned limit) const in OptimizedRegularExpression to process cases like: select replaceRegexpAll('Hello, World!', '^', 'here: '), making it compatiable with original re2 library.
• Replace offset value std::string::npos with its actual value. It makes sense because even when captured pieces are empty, we still want to know its position for later replacement.

Why we need to add a new interface unsigned match(std::string_view text, const char * subject, size_t subject_size, MatchVec & matches, unsigned limit) const?

We have to add a new interface to make sure OptimizedRegularExpression have the same functionality with previous regexp library re2.

When invoking unsigned match(std::string_view text, const char * subject, size_t subject_size, MatchVec & matches, unsigned limit) const.

• text: the whole input: 'Hello, World!'
• subject: pointer to suffix of text after we have processed some prefix of text. In function regexpRegexpAll, above match method maybe called multiple times. Each time we have the same text but different subject.
• subject_size: suffix length

Consider case: select replaceRegexpAll('Hello, World!', '^', 'here: ') . The pattern ^ refers to the beginning of text 'Hello, World!', it should be matched only once. But old interface in OptimizedRegularExpression doesn't meet the the requirement.

If we use the new interface above, valid match will only happend once, which makes replacement happen only once. The output matches are:

• First time: subject = haystack_data, length(matches) = 1 and matches[0]: offset 0, length 0
• Second time: subject = haystack_data + 1, length(matches) = 1, length(matches) = 0.

And the sql will outcome correct output.

If we use the old interface unsigned match(const char * subject, size_t subject_size, MatchVec & matches, unsigned limit) const, it will be invoked multiple times, which makes replacement happen multiple times. The output matches are:

• First time: subject = haystack_data, length(matches) = 1 and matches[0]: offset 0, length 0
• Second time: subject = haystack_data + 1, length(matches) = 1 and matches[0]: offset 0, length 0
• Multiple loops until subject reaches end of haystack_data

It is obvious that the sql generate wrong output under current condition.

Changelog category (leave one):

• Performance Improvement

Changelog entry (a user-readable short description of the changes that goes to CHANGELOG.md):

Speed up replaceRegexp by 1.8x (4.41x especially when needle and replacement are trivail ) and replaceAll by 1.10x