hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
0786a354dfd8ead3fb39310c6f21208709e0167e
oceanbase/src/sql/engine/expr/ob_expr_regexp_context.cpp
wangzelin.wzl 93a1074b0c patch 4.0
2022-10-24 17:57:12 +08:00

1080 lines
44 KiB
C++
Raw Blame History

/**
* Copyright (c) 2021 OceanBase
* OceanBase CE is licensed under Mulan PubL v2.
* You can use this software according to the terms and conditions of the Mulan PubL v2.
* You may obtain a copy of Mulan PubL v2 at:
* http://license.coscl.org.cn/MulanPubL-2.0
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PubL v2 for more details.
*/
#define USING_LOG_PREFIX LIB
#include <stdlib.h>
#include <locale.h>
#include <cstring>
#include "lib/oblog/ob_log.h"
#include "lib/allocator/ob_malloc.h"
#include "lib/charset/ob_charset.h"
#include "sql/engine/expr/ob_expr_regexp_context.h"
#include "sql/engine/expr/ob_expr_util.h"
namespace oceanbase
{
using namespace common;
namespace sql
{
ObExprRegexContext::ObExprRegexContext()
: ObExprOperatorCtx(),
inited_(false),
reg_(),
cflags_(0)
{
}
ObExprRegexContext::~ObExprRegexContext()
{
destroy();
}
void ObExprRegexContext::reset()
{
destroy();
}
void ObExprRegexContext::reset_reg()
{
reg_.re_magic = 0;
reg_.re_nsub = 0;
reg_.re_info = 0;
reg_.re_csize = 0;
reg_.re_endp = NULL;
reg_.re_guts = NULL;
reg_.re_fns = NULL;
}
int ObExprRegexContext::init(const ObString &origin_pattern,
int cflags,
ObExprStringBuf &string_buf,
const bool reusable)
{
int ret = OB_SUCCESS;
int regex_error_num = 0;
ObString pattern;
if (OB_UNLIKELY(inited_ && !reusable)) {
ret = OB_INIT_TWICE;
LOG_WARN("already inited", K(ret), K(this));
} else if (origin_pattern.length() < 0 ||
(origin_pattern.length() > 0 && OB_ISNULL(origin_pattern.ptr()))) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid param pattern", K(ret), K(pattern));
} else if (OB_FAIL(preprocess_pattern(string_buf, origin_pattern, pattern))) {
LOG_WARN("failed to prepare process pattern", K(origin_pattern), K(pattern));
} else if (reusable &&
pattern_ == ObString(0, pattern.length(), pattern.ptr())
&& cflags_ == cflags) {
// reuse the previous compile result.
} else {
if (inited_) { // reusable && pattern changed
ob_regfree(&reg_);
reset_reg();
inited_ = false;
cflags_ = 0;
}
pattern_allocator_.prepare(string_buf);
pattern_wc_allocator_.prepare(string_buf);
char *pattern_save = static_cast<char *>(pattern_allocator_.alloc(pattern.length()));
if (NULL == pattern_save) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_WARN("allocate memory failed", K(ret));
} else {
MEMCPY(pattern_save, pattern.ptr(), pattern.length());
pattern_.assign_ptr(pattern_save, pattern.length());
cflags_ = cflags;
}
int64_t wc_pattern_length = 0;
wchar_t *wc_pattern = NULL;
if (OB_FAIL(ret)) {
} else if (OB_FAIL(getwc(pattern, wc_pattern, wc_pattern_length, string_buf))) {
LOG_WARN("failed to getwc", K(ret));
} else if (OB_ISNULL(wc_pattern)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("getwc function failed.", K(ret));
} else {
reg_.re_endp = wc_pattern + wc_pattern_length;
regex_error_num = ob_re_wcomp(&reg_, wc_pattern, wc_pattern_length, (cflags | OB_REG_ADVANCED));
if (OB_UNLIKELY(0 != regex_error_num)) {
ret = convert_reg_err_code_to_ob_err_code(regex_error_num);
LOG_WARN("regex compilation failed", K(ret));
destroy();
} else {
inited_ = true;
}
}
}
return ret;
}
int ObExprRegexContext::match(const ObString &text,
int64_t start_offset,
bool& is_match,
ObExprStringBuf &string_buf) const
{
int ret = OB_SUCCESS;
int regex_error_num = 0;
is_match = false;
if (OB_UNLIKELY(!inited_)) {
ret = OB_NOT_INIT;
LOG_WARN("not inited", K(ret), K(this));
} else if (text.length() < 0 || (text.length() > 0 && OB_ISNULL(text.ptr()))) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid param", K(ret), K(text));
} else {
const static int64_t NMATCH = 1;
ob_regmatch_t pmatch[NMATCH];
wchar_t *wc_text = NULL;
int64_t wc_length = 0;
if (OB_FAIL(getwc(text, wc_text, wc_length, string_buf))) {
LOG_WARN("failed to getwc", K(ret));
} else if (OB_ISNULL(wc_text)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("getwc function failed.", K(ret));
} else {
pmatch[0].rm_so = start_offset;
pmatch[0].rm_eo = wc_length;
regex_error_num = ob_re_wexec((ob_regex_t *)&reg_, wc_text, wc_length, NULL, NMATCH, pmatch, 0);
if (OB_UNLIKELY(0 != regex_error_num)) {
if (OB_LIKELY(OB_REG_NOMATCH == regex_error_num)) {
is_match = false;
LOG_TRACE("regex not match", K(ret));
} else {
ret = convert_reg_err_code_to_ob_err_code(regex_error_num);
LOG_WARN("regex match error", K(ret));
}
} else {
is_match = true;
}
}
}
return ret;
}
int ObExprRegexContext::substr(const ObString &text,
int64_t occurrence,
int64_t subexpr,
ObString& sub,
ObExprStringBuf &string_buf,
bool from_begin,
bool from_end,
ObSEArray<uint32_t, 4> &begin_locations) const
{
int ret = OB_SUCCESS;
sub.reset();
if (OB_UNLIKELY(!inited_)) {
ret = OB_NOT_INIT;
LOG_WARN("regexp context not inited yet", K(ret), K(this));
} else if (reg_.re_nsub >= subexpr) {
size_t nsub = reg_.re_nsub;
ob_regmatch_t pmatch[nsub + 1];
int error = 0;
int64_t tmp_start = 0;
int64_t start = 0;
wchar_t *wc_text = NULL;
int64_t wc_length = 0;
if (OB_FAIL(getwc(text, wc_text, wc_length, string_buf))) {
LOG_WARN("failed to getwc", K(ret));
} else if (OB_ISNULL(wc_text)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("getwc function failed.", K(ret));
} else if (begin_locations.empty()) {
/*do nothing*/
} else {
for (int64_t idx = 0; OB_SUCC(ret) && idx < begin_locations.count() && occurrence > 0; ++idx) {
start = begin_locations.at(idx);
do {
tmp_start = start;
pmatch[0].rm_so = start;
pmatch[0].rm_eo = wc_length;
error = ob_re_wexec((ob_regex_t *)&reg_, wc_text, wc_length, NULL, nsub + 1, pmatch, 0);
if (OB_UNLIKELY(0 != error)) {
if (OB_LIKELY(OB_REG_NOMATCH == error)) {
LOG_TRACE("regex not match, str=%.*s", K(wc_length));
} else {
ret = convert_reg_err_code_to_ob_err_code(error);;
LOG_WARN("regex match error", K(ret));
}
} else if ( pmatch[0].rm_eo + tmp_start == start && start < wc_length){
start = start + 1;
} else {
start = static_cast<int64_t>(pmatch[0].rm_eo + tmp_start);
}
} while (OB_SUCC(ret) && --occurrence > 0 && 0 == error && tmp_start < wc_length && !from_begin && !from_end);
}
if (OB_SUCC(ret)) {
if (0 == error && 0 == occurrence) {
if (pmatch[subexpr].rm_so < 0 || pmatch[subexpr].rm_so > wc_length ||
pmatch[subexpr].rm_eo < 0 || pmatch[subexpr].rm_eo > wc_length ||
OB_UNLIKELY(tmp_start + pmatch[subexpr].rm_so > wc_length)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("regexp library error, get invalid offset from pmatch", K(ret));
} else {
int64_t offset = static_cast<int64_t>(pmatch[subexpr].rm_eo - pmatch[subexpr].rm_so);
if(offset > 0){
char *tmp_char = NULL;
int64_t length_chr = 0;
if (OB_FAIL(w2c(wc_text + pmatch[subexpr].rm_so + tmp_start, offset,
tmp_char, length_chr, string_buf))) {
LOG_WARN("failed to w2c.", K(ret));
} else if (OB_ISNULL(tmp_char)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("w2c function failed.", K(ret));
} else {
sub.assign_ptr(tmp_char, length_chr);
}
}
}
}
}
}
}
return ret;
}
int ObExprRegexContext::count_match_str(const ObString &text,
int64_t subexpr,
int64_t &sub,
ObExprStringBuf &string_buf,
bool from_begin,
bool from_end,
ObSEArray<uint32_t, 4> &begin_locations) const
{
int ret = OB_SUCCESS;
sub = 0;
if (OB_UNLIKELY(!inited_)) {
ret = OB_NOT_INIT;
LOG_WARN("regexp context not inited yet", K(ret), K(this));
} else if (reg_.re_nsub >= subexpr) {
size_t nsub = reg_.re_nsub;
ob_regmatch_t pmatch[nsub + 1];
int error = 0;
int64_t count = 0;
int64_t tmp_start = 0;
int64_t start = 0;
wchar_t *wc_text = NULL;
int64_t wc_length = 0;
if (OB_FAIL(getwc(text, wc_text, wc_length, string_buf))) {
LOG_WARN("failed to getwc", K(ret));
} else if (OB_ISNULL(wc_text)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("getwc function failed.", K(ret));
} else if (begin_locations.empty()) {
/*do nothing*/
} else {
for (int64_t idx = 0; OB_SUCC(ret) && idx < begin_locations.count(); ++idx) {
start = begin_locations.at(idx);
do {
tmp_start = start;
pmatch[0].rm_so = start;
pmatch[0].rm_eo = wc_length;
error = ob_re_wexec((ob_regex_t *)&reg_, wc_text, wc_length, NULL, nsub+1, pmatch, 0);
if (OB_UNLIKELY(0 != error)) {
if (OB_LIKELY(OB_REG_NOMATCH == error)) {
LOG_TRACE("regex not match, ", K(wc_length));
} else {
ret = convert_reg_err_code_to_ob_err_code(error);
LOG_WARN("regex match error", K(ret));
}
} else if ( pmatch[0].rm_eo + tmp_start == start && start < wc_length) {
start = start + 1;
++count;
} else {
start = static_cast<int32_t>(pmatch[0].rm_eo + tmp_start);
++count;
}
} while (OB_SUCC(ret) && 0 == error && tmp_start < wc_length && !from_begin && !from_end);
}
if (OB_SUCC(ret)) {
if (0 == error) {
if (pmatch[subexpr].rm_so < 0 || pmatch[subexpr].rm_so > wc_length
|| pmatch[subexpr].rm_eo < 0 || pmatch[subexpr].rm_eo > wc_length) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("regexp library error, get invalid offset from pmatch", K(ret));
}
}
sub = count;
}
}
}
return ret;
}
int ObExprRegexContext::instr(const ObString &text,
int64_t occurrence,
int64_t return_option,
int64_t subexpr,
int64_t& sub,
ObExprStringBuf &string_buf,
bool from_begin,
bool from_end,
ObSEArray<uint32_t, 4> &begin_locations) const
{
int ret = OB_SUCCESS;
sub = -1;
if (OB_UNLIKELY(!inited_)) {
ret = OB_NOT_INIT;
LOG_WARN("regexp context not inited yet", K(ret), K(this));
} else if (reg_.re_nsub >= subexpr) {
size_t nsub = reg_.re_nsub;
ob_regmatch_t pmatch[nsub + 1];
int error = 0;
int64_t tmp_start = 0;
int64_t start = 0;
wchar_t *wc_text = NULL;
int64_t wc_length = 0;
if (OB_FAIL(getwc(text, wc_text, wc_length, string_buf))) {
LOG_WARN("failed to getwc", K(ret));
} else if (OB_ISNULL(wc_text)) {
ret = OB_ERR_UNEXPECTED;
LOG_ERROR("getwc function failed.", K(ret));
} else if (begin_locations.empty()) {
/*do nothing*/
} else {
for (int64_t idx = 0; OB_SUCC(ret) && idx < begin_locations.count() && occurrence > 0; ++idx) {
start = begin_locations.at(idx);
do {
tmp_start = start;
pmatch[0].rm_so = start;
pmatch[0].rm_eo = wc_length;
error = ob_re_wexec((ob_regex_t *)&reg_, wc_text, wc_length, NULL, nsub + 1, pmatch, 0);
if (OB_UNLIKELY(0 != error)) {
if (OB_LIKELY(OB_REG_NOMATCH == error)) {
LOG_TRACE("regex not match", K(ret));
} else {
ret = convert_reg_err_code_to_ob_err_code(error);
LOG_WARN("regex match error", K(ret));
}
} else if ( pmatch[0].rm_eo + tmp_start == start && start < wc_length){
start = start + 1;
} else {
start = static_cast<int64_t>(pmatch[0].rm_eo + tmp_start);
}
} while (OB_SUCC(ret) && --occurrence > 0 && 0 == error && tmp_start < wc_length && !from_begin && !from_end);
}
if (OB_SUCC(ret)) {
if (0 == error && 0 == occurrence) {
if (pmatch[subexpr].rm_so < 0 || pmatch[subexpr].rm_so > wc_length ||
pmatch[subexpr].rm_eo < 0 || pmatch[subexpr].rm_eo > wc_length ||
OB_UNLIKELY(tmp_start + pmatch[subexpr].rm_so > wc_length)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("regexp library error, get invalid offset from pmatch", K(ret));
} else {
sub = return_option ? pmatch[subexpr].rm_eo + tmp_start : pmatch[subexpr].rm_so + tmp_start;
}
}
}
}
}
return ret;
}
int ObExprRegexContext::like(const ObString &text,
int64_t occurrence,
bool& sub,
ObExprStringBuf &string_buf,
bool from_begin,
bool from_end,
ObSEArray<uint32_t, 4> &begin_locations) const
{
int ret = OB_SUCCESS;
sub = false;
if (OB_UNLIKELY(!inited_)) {
ret = OB_NOT_INIT;
LOG_WARN("regexp context not inited yet", K(ret), K(this));
} else if (text.length() < 0 || (text.length() > 0 && OB_ISNULL(text.ptr()))) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid param, source text is null", K(ret), K(text));
} else {
size_t nsub = reg_.re_nsub;
ob_regmatch_t pmatch[nsub + 1];
int error = 0;
int64_t tmp_start = 0;
int64_t start = 0;
wchar_t *wc_text = NULL;
int64_t wc_length = 0;
if (OB_FAIL(getwc(text, wc_text, wc_length, string_buf))) {
LOG_WARN("failed to getwc", K(ret));
} else if (OB_ISNULL(wc_text)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("getwc function failed.", K(ret));
} else if (begin_locations.empty()) {
/*do nothing*/
} else {
for (int64_t idx = 0; OB_SUCC(ret) && idx < begin_locations.count() && occurrence > 0; ++idx) {
start = begin_locations.at(idx);
do {
tmp_start = start;
pmatch[0].rm_so = start;
pmatch[0].rm_eo = wc_length;
error = ob_re_wexec((ob_regex_t *)&reg_, wc_text, wc_length, NULL, nsub+1, pmatch, 0);
if (OB_UNLIKELY(0 != error)) {
if (OB_LIKELY(OB_REG_NOMATCH == error)) {
LOG_TRACE("regex not match", K(ret));
} else {
ret = convert_reg_err_code_to_ob_err_code(error);
LOG_WARN("regex match error", K(error));
}
} else if ( pmatch[0].rm_eo + tmp_start == start && start < wc_length) {
start = start + 1;
} else {
start = static_cast<int64_t>(pmatch[0].rm_eo + tmp_start);
}
} while (OB_SUCC(ret) && --occurrence > 0 && 0 == error && tmp_start < wc_length && !from_begin && !from_end);
}
if (OB_SUCC(ret)) {
if (0 == error && 0 == occurrence) {
if (pmatch[0].rm_so < 0 || pmatch[0].rm_so > wc_length
|| pmatch[0].rm_eo < 0 || pmatch[0].rm_eo > wc_length) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("regexp library error, get invalid offset from pmatch", K(ret));
} else {
sub = true;
}
}
}
}
}
return ret;
}
int ObExprRegexContext::replace_substr(const ObString &text_string,
const ObString &replace_string,
int64_t occurrence,
ObExprStringBuf &string_buf,
ObIArray<size_t> &ch_position,
ObString &sub,
bool from_begin,
bool from_end,
ObSEArray<uint32_t, 4> &begin_locations) const
{
const char* text = text_string.ptr();
char *tmp = NULL;
sub.reset();
int ret = OB_SUCCESS;
ObSEArray<uint32_t, 4> locations_and_length(common::ObModIds::OB_SQL_EXPR_REPLACE,
common::OB_MALLOC_NORMAL_BLOCK_SIZE);
int64_t tmp_start = 0;
int64_t start = 0;
ObSEArray<ObSEArray<ObString, 8>, 8> subexpr_arrays;//用于保存匹配分组内容用于后续替换
if (OB_UNLIKELY(!inited_)) {
ret = OB_NOT_INIT;
LOG_WARN("regexp context not inited yet", K(ret), K(this));
} else if (OB_ISNULL(text)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid param, source text is null", K(ret), K(text));
} else if (begin_locations.empty()) {
sub = text_string;
} else {
size_t nsub = reg_.re_nsub;
int error = 0;
wchar_t *wc_text = NULL;
int64_t length = 0;
if (OB_FAIL(getwc(text_string, wc_text, length, string_buf))) {
LOG_WARN("failed to getwc", K(ret));
} else if (OB_ISNULL(wc_text)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("getwc function failed.", K(ret));
} else {
if (0 != occurrence) {
ob_regmatch_t pmatch[nsub + 1];
ObSEArray<ObString, 8> subexpr_array;
for (int64_t idx = 0; OB_SUCC(ret) && idx < begin_locations.count() && occurrence > 0; ++idx) {
start = begin_locations.at(idx);
do {
tmp_start = start;
pmatch[0].rm_so = start;
pmatch[0].rm_eo = length;
error = ob_re_wexec((ob_regex_t *)&reg_, wc_text, length, NULL, nsub+1, pmatch, 0);
if (OB_UNLIKELY(0 != error)) {
if (OB_LIKELY(OB_REG_NOMATCH == error)) {
LOG_TRACE("regex not match", K(length));
} else {
ret = convert_reg_err_code_to_ob_err_code(error);
LOG_WARN("regex match error", K(ret));
}
} else if ( pmatch[0].rm_eo + tmp_start == start && start < length){
start = start + 1;
} else {
start = static_cast<int64_t>(pmatch[0].rm_eo + tmp_start);
}
} while (OB_SUCC(ret) && --occurrence > 0 && 0 == error && tmp_start < length && !from_begin && !from_end);
}
if (OB_SUCC(ret)) {
if (0 == error && 0 == occurrence) {
if (pmatch[0].rm_so < 0 || pmatch[0].rm_so > length ||
pmatch[0].rm_eo < 0 || pmatch[0].rm_eo > length) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("regexp library error, get invalid offset from pmatch", K(ret));
} else if (extract_subpre_string(wc_text, length, tmp_start, pmatch, nsub + 1,
string_buf, subexpr_array)) {
LOG_WARN("failed to extract subpre string", K(ret));
} else if (OB_FAIL(subexpr_arrays.push_back(subexpr_array))) {
LOG_WARN("failed to push back subexpr array", K(ret));
} else if (pmatch[0].rm_eo == pmatch[0].rm_so) {
if (OB_UNLIKELY(pmatch[0].rm_so + tmp_start >= ch_position.count())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("beyond array boundary", K(ret), K(pmatch[0].rm_so + tmp_start), K(ch_position.count()));
} else if (OB_FAIL(locations_and_length.push_back(ch_position.at(pmatch[0].rm_so + tmp_start)))
|| OB_FAIL(locations_and_length.push_back(0))) {
LOG_WARN("locations_and_length push_back error", K(ret));
} else if (OB_FAIL(replace(text_string, replace_string, locations_and_length, string_buf, subexpr_arrays, sub))) {
LOG_WARN("replace function failed", K(ret));
}
} else {
int64_t length_chr = 0;
if (OB_FAIL(w2c(wc_text + pmatch[0].rm_so + tmp_start, pmatch[0].rm_eo - pmatch[0].rm_so,
tmp, length_chr, string_buf))) {
LOG_WARN("failed to w2c.", K(ret));
} else if (OB_ISNULL(tmp)) {
ret = OB_ERR_UNEXPECTED;
LOG_ERROR("w2c function failed", K(ret));
} else if (OB_UNLIKELY(pmatch[0].rm_so + tmp_start >= ch_position.count())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("beyond array boundary", K(ret), K(pmatch[0].rm_so + tmp_start), K(ch_position.count()));
} else if (OB_FAIL(locations_and_length.push_back(ch_position.at(pmatch[0].rm_so + tmp_start)))
|| OB_FAIL(locations_and_length.push_back(length_chr))) {
LOG_WARN("locations_and_length push_back error", K(ret));
} else if (OB_FAIL(replace(text_string, replace_string, locations_and_length, string_buf, subexpr_arrays, sub))) {
LOG_WARN("replace function failed", K(ret));
}
}
} else {
sub = text_string;
}
} else {
/*do nothing */
}
} else {
for (int64_t idx = 0; OB_SUCC(ret) && idx < begin_locations.count(); ++idx) {
start = begin_locations.at(idx);
do {
ob_regmatch_t pmatch[nsub + 1];
tmp_start = start;
pmatch[0].rm_so = start;
pmatch[0].rm_eo = length;
ObSEArray<ObString, 8> subexpr_array;
error = ob_re_wexec((ob_regex_t *)&reg_, wc_text, length, NULL, nsub+1, pmatch, 0);
if (OB_UNLIKELY(0 != error)) {
if (OB_LIKELY(OB_REG_NOMATCH == error)) {
LOG_TRACE("regex not match", K(length), K(text + start));
} else {
ret = convert_reg_err_code_to_ob_err_code(error);
LOG_WARN("regex match error", K(ret));
}
} else if (pmatch[0].rm_eo == pmatch[0].rm_so) {
if (OB_UNLIKELY(pmatch[0].rm_so + tmp_start >= ch_position.count())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("beyond array boundary", K(ret), K(pmatch[0].rm_so + tmp_start), K(ch_position.count()));
} else if (OB_FAIL(locations_and_length.push_back(ch_position.at(pmatch[0].rm_so + tmp_start)))
|| OB_FAIL(locations_and_length.push_back(0))) {
LOG_WARN("locations_and_length push_back error", K(ret));
} else if (extract_subpre_string(wc_text, length, tmp_start, pmatch, nsub + 1,
string_buf, subexpr_array)) {
LOG_WARN("failed to extract subpre string", K(ret));
} else if (OB_FAIL(subexpr_arrays.push_back(subexpr_array))) {
LOG_WARN("failed to push back subexpr array", K(ret));
} else if (pmatch[0].rm_eo + tmp_start == start && start < length) {
start = start + 1;
} else {
start = static_cast<int64_t>(pmatch[0].rm_eo + tmp_start);
}
} else {
int64_t length_chr = 0;
if (OB_FAIL(w2c(wc_text + pmatch[0].rm_so + tmp_start, pmatch[0].rm_eo - pmatch[0].rm_so,
tmp, length_chr, string_buf))) {
LOG_WARN("failed to w2c.", K(ret));
} else if (OB_ISNULL(tmp)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("w2c function failed", K(ret));
} else if (OB_UNLIKELY(pmatch[0].rm_so + tmp_start >= ch_position.count())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("beyond array boundary", K(ret), K(pmatch[0].rm_so + tmp_start), K(ch_position.count()));
} else if (extract_subpre_string(wc_text, length, tmp_start, pmatch, nsub + 1,
string_buf, subexpr_array)) {
LOG_WARN("failed to extract subpre string", K(ret));
} else if (OB_FAIL(subexpr_arrays.push_back(subexpr_array))) {
LOG_WARN("failed to push back subexpr array", K(ret));
} else if (OB_FAIL(locations_and_length.push_back(ch_position.at(pmatch[0].rm_so + tmp_start)))
|| OB_FAIL(locations_and_length.push_back(length_chr))) {
LOG_WARN("locations_and_length push_back error", K(ret));
} else if (pmatch[0].rm_eo + tmp_start == start && start < length) {
start = start + 1;
} else {
start = static_cast<int64_t>(pmatch[0].rm_eo + tmp_start);
}
}
} while (OB_SUCC(ret) && tmp_start < length && 0 == error && !from_begin && !from_end);
}
if (OB_SUCC(ret)) {
if (!locations_and_length.empty()) {
if (OB_FAIL(replace(text_string, replace_string, locations_and_length, string_buf, subexpr_arrays, sub))) {
LOG_WARN("replace function failed", K(ret));
}
} else {
sub = text_string;
}
}
}
}
}
return ret;
}
int ObExprRegexContext::replace(const ObString &text,
const ObString &to,
ObSEArray<uint32_t, 4> &locations_and_length,
ObExprStringBuf &string_buf,
ObIArray<ObSEArray<ObString, 8> > &subexpr_arrays,
ObString &sub) const
{
int ret = OB_SUCCESS;
ObSEArray<ObString, 8> to_strings;
sub.reset();
if (OB_UNLIKELY(text.length() <= 0 || to.length() < 0 || locations_and_length.count() <= 0)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("text_string or to_string or locations_and_length is null or invalid", K(ret));
} else if (OB_FAIL(pre_process_replace_str(text, to, string_buf, subexpr_arrays, to_strings))) {
LOG_WARN("failed to pre process replace str", K(ret));
} else {
int64_t sum_length = 0;
int64_t length_text = text.length();
int64_t length_to = to.length();
int64_t tot_length = 0;
int64_t count_location = locations_and_length.count();
for (int64_t i = 1; i < count_location; i = i + 2)
{
sum_length += locations_and_length.at(i);
}
if (OB_UNLIKELY(OB_MAX_VARCHAR_LENGTH < count_location / 2 * (length_to + length_text) + length_text - sum_length)) {
ret = OB_ERR_VARCHAR_TOO_LONG;
LOG_WARN("Result of replace_all_str() was larger than OB_MAX_VARCHAR_LENGTH.",
K(length_text), K(length_to), K(OB_MAX_VARCHAR_LENGTH), K(ret));
} else if (OB_UNLIKELY((tot_length = count_location / 2 * (length_to + length_text) + length_text - sum_length) < 0)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("the tot_length is invalid", K(length_text), K(tot_length), K(ret));
} else if (tot_length != 0) {
char *buf = static_cast<char *>(string_buf.alloc(tot_length));
int64_t real_tot_length = 0;
if (OB_ISNULL(buf)) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_ERROR("alloc memory failed.", K(tot_length), K(ret));
} else {
MEMSET(buf, 0, tot_length);
int64_t pos = 0;
const char * const text_ptr_start = text.ptr();
const char * const text_ptr_end = text.ptr() + length_text;
const char *text_ptr_lower = text.ptr();
const char *text_ptr_upper = text.ptr();
char *tmp_buf = buf;
for (int64_t i = 0, j = 0; i < count_location && j < to_strings.count(); i = i + 2, ++j) {
const char *to_ptr = to_strings.at(j).ptr();
pos = locations_and_length.at(i);
text_ptr_upper = text_ptr_start + pos;
if (OB_UNLIKELY(text_ptr_upper - text_ptr_lower < 0 || text_ptr_end - text_ptr_upper < 0)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get offset is invalid", K(text_ptr_upper - text_ptr_lower), K(text_ptr_end - text_ptr_upper), K(ret));
} else {
MEMCPY(tmp_buf, text_ptr_lower, text_ptr_upper - text_ptr_lower);
tmp_buf += text_ptr_upper - text_ptr_lower;
real_tot_length += text_ptr_upper - text_ptr_lower;
text_ptr_lower = text_ptr_upper + locations_and_length.at(i+1);
if (OB_UNLIKELY(to_strings.at(j).length() < 0)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get offset is invalid", K(to_strings.at(j).length()), K(ret));
} else {
MEMCPY(tmp_buf, to_ptr, to_strings.at(j).length());
tmp_buf += to_strings.at(j).length();
real_tot_length += to_strings.at(j).length();
}
}
}
if (text_ptr_lower < text_ptr_end) {
MEMCPY(tmp_buf, text_ptr_lower, text_ptr_end - text_ptr_lower);
real_tot_length += text_ptr_end - text_ptr_lower;
}
if (OB_UNLIKELY(real_tot_length > tot_length)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get invalid argument", K(real_tot_length), K(tot_length), K(ret));
} else if (real_tot_length > 0) {
char *real_buf = static_cast<char *>(string_buf.alloc(real_tot_length));
if (OB_ISNULL(real_buf)) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_WARN("alloc memory failed.", K(real_buf), K(ret));
} else {
MEMSET(real_buf, 0, real_tot_length);
MEMCPY(real_buf, buf, real_tot_length);
sub.assign_ptr(real_buf, static_cast<int64_t>(real_tot_length));
}
}
}
}
}
return ret;
}
//convert char to wchar_t
int ObExprRegexContext::getwc(const ObString &text,
wchar_t *&wc,
int64_t &wc_length,
ObExprStringBuf &string_buf) const
{
// %string_buf may be instance of ObInplaceAllocator, can only allocate once here.
int ret = OB_SUCCESS;
wc = NULL;
wc_length = 0;
if (text.length() < 0 || (text.length() > 0 && OB_ISNULL(text.ptr()))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("source text is null or length is invalid", K(ret), K(text));
} else {
int64_t length = text.length();
ObSEArray<size_t, 4> byte_num;
ObSEArray<size_t, 4> byte_offsets;
wc = static_cast<wchar_t*>(string_buf.alloc((length + 1) * sizeof(wchar_t)));
if (OB_ISNULL(wc)) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_WARN("alloc memory failed.", K(wc), K(ret));
} else if (OB_FAIL(ObExprUtil::get_mb_str_info(text,
ObCharset::get_default_collation_oracle(CHARSET_UTF8MB4),
byte_num,
byte_offsets))) {
LOG_WARN("failed to get mb str info", K(ret));
} else if (OB_UNLIKELY(byte_num.count() >= length + 1 ||
(byte_num.count() != 0 && byte_num.count() != byte_offsets.count() - 1))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected error", K(ret), K(length + 1 ), K(byte_num.count()),
K(byte_offsets.count()));
} else {
wmemset(wc, 0, length + 1);
wc_length = byte_num.count();
for (int64_t i = 0; OB_SUCC(ret) && i < byte_num.count(); ++i) {
int32_t wc_int = 0;
int32_t unused_length = 0;
if (OB_UNLIKELY(byte_offsets.at(i) + byte_num.at(i) > text.length())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected error", K(byte_offsets.at(i)), K(byte_num.at(i)), K(ret));
//这里采用utf8的collation type是因为到这里之前已经将其他类型的type转为了utf8，已经有这个保证
} else if (OB_FAIL(ObCharset::mb_wc(ObCharset::get_default_collation_oracle(CHARSET_UTF8MB4),
text.ptr() + byte_offsets.at(i),
byte_num.at(i),
unused_length,
wc_int))) {
LOG_WARN("failed to multi byte to wide char", K(ret));
} else {
wc[i] = static_cast<wchar_t>(wc_int);
}
}
}
}
return ret;
}
//convert wchar_t to char
int ObExprRegexContext::w2c(const wchar_t *wc,
int64_t length,
char *&chr,
int64_t &chr_length,
ObExprStringBuf &string_buf) const
{
int ret = OB_SUCCESS;
chr_length = 0;
chr = NULL;
if (length < 0 || (length > 0 && OB_ISNULL(wc))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("source text is null or length is vaild", K(ret), K(wc), K(length));
} else if (length > 0) {
int32_t buff_len = sizeof(wchar_t);
int64_t chr_len = (length + 1) * buff_len;
char *buff = NULL;
if (OB_ISNULL(buff = static_cast<char *>(string_buf.alloc(buff_len))) ||
OB_ISNULL(chr = static_cast<char *>(string_buf.alloc(chr_len)))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_WARN("alloc memory failed.", K(buff), K(chr), K(ret));
} else {
char *tmp_chr = chr;
MEMSET(chr, 0, chr_len);
MEMSET(buff, 0, buff_len);
for (int64_t i = 0; OB_SUCC(ret) && i < length; ++i) {
int32_t wc_int = static_cast<int32_t>(wc[i]);
int32_t real_length = 0;
//这里采用utf8的collation type是因为到这里之前已经将其他类型的type转为了utf8，已经有这个保证
if (OB_FAIL(ObCharset::wc_mb(ObCharset::get_default_collation_oracle(CHARSET_UTF8MB4),
wc_int,
buff,
buff_len,
real_length))) {
LOG_WARN("failed to multi byte to wide char", K(ret));
} else if (OB_UNLIKELY(chr_length + real_length > chr_len)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected error", K(chr_length), K(real_length), K(chr_len), K(ret));
} else {
MEMCPY(tmp_chr, buff, real_length);
chr_length += real_length;
tmp_chr = tmp_chr + real_length;
}
}
}
}
return ret;
}
void ObExprRegexContext::destroy()
{
if (inited_) {
ob_regfree(&reg_);
reset_reg();
inited_ = false;
cflags_ = 0;
}
}
int ObExprRegexContext::pre_process_replace_str(const ObString &text,
const ObString &to,
ObExprStringBuf &string_buf,
ObIArray<ObSEArray<ObString, 8> > &subexpr_arrays,
ObIArray<ObString> &to_strings) const
{
int ret = OB_SUCCESS;
int64_t length_text = text.length();
int64_t length_to = to.length();
int64_t tot_length = 0;
if (OB_UNLIKELY(OB_MAX_VARCHAR_LENGTH < (tot_length = length_text + length_to))) {
ret = OB_ERR_VARCHAR_TOO_LONG;
LOG_WARN("Result of replace_all_str() was larger than OB_MAX_VARCHAR_LENGTH.",
K(length_text), K(length_to), K(OB_MAX_VARCHAR_LENGTH), K(ret));
} else if (tot_length != 0) {
char *buf = static_cast<char *>(string_buf.alloc(tot_length));
if (OB_ISNULL(buf)) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_ERROR("alloc memory failed.", K(tot_length), K(ret));
} else {
for (int64_t j = 0; OB_SUCC(ret) && j < subexpr_arrays.count(); ++j) {
ObString tmp_string;
ObIArray<ObString> &subexpr_array = subexpr_arrays.at(j);
MEMSET(buf, 0, tot_length);
const char * const to_ptr = to.ptr();
char *tmp_buf = buf;
int64_t i = 0;
int64_t real_tot_length = 0;
bool need_copy_last = true;
bool before_is_escape = false;
if (length_to != 0) {
for (; i < length_to - 1; ++i) {
need_copy_last = true;
if (to_ptr[i] == '\\') {
if (to_ptr[i+1] == '\\') {
MEMCPY(tmp_buf, to_ptr + i, 1);
tmp_buf += 1;
++ real_tot_length;
++ i;
before_is_escape = true;
need_copy_last = (length_to - 1 != i);
} else if (!before_is_escape) {
if (to_ptr[i + 1] >= '1' && to_ptr[i + 1] <= '9') {
int64_t idx = to_ptr[i + 1] - '1';
if (OB_UNLIKELY(idx < 0 || idx >= subexpr_array.count())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected error", K(ret), K(idx), K(subexpr_array));
} else {
MEMCPY(tmp_buf, subexpr_array.at(idx).ptr(), subexpr_array.at(idx).length());
tmp_buf += subexpr_array.at(idx).length();
real_tot_length += subexpr_array.at(idx).length();
++i;
need_copy_last = (length_to - 1 != i);
}
} else {
MEMCPY(tmp_buf, to_ptr + i, 1);
tmp_buf += 1;
++real_tot_length;
}
} else {
MEMCPY(tmp_buf, to_ptr + i, 1);
tmp_buf += 1;
++ real_tot_length;
before_is_escape = false;
}
} else {
before_is_escape = false;
MEMCPY(tmp_buf, to_ptr + i, 1);
tmp_buf += 1;
++ real_tot_length;
}
}
if (need_copy_last) {
MEMCPY(tmp_buf, to_ptr + length_to - 1, 1);
++ real_tot_length;
}
char *real_buf = static_cast<char *>(string_buf.alloc(real_tot_length));
if (OB_ISNULL(real_buf)) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_ERROR("alloc memory failed.", K(real_buf), K(ret));
} else {
MEMSET(real_buf, 0, real_tot_length);
MEMCPY(real_buf, buf, real_tot_length);
tmp_string.assign_ptr(real_buf, static_cast<int64_t>(real_tot_length));
}
}
if (OB_SUCC(ret) && OB_FAIL(to_strings.push_back(tmp_string))) {
LOG_WARN("failed to push back string", K(ret));
}
}
}
}
return ret;
}
int ObExprRegexContext::extract_subpre_string(const wchar_t *wc_text,
int64_t wc_length,
int64_t start_pos,
ob_regmatch_t pmatch[],
uint64_t pmatch_size,
ObExprStringBuf &string_buf,
ObIArray<ObString> &subexpr_array) const
{
int ret = OB_SUCCESS;
if (OB_ISNULL(wc_text) || OB_ISNULL(pmatch) ||
OB_UNLIKELY(wc_length < 0 || start_pos < 0 || pmatch_size <= 0)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected nullptr", K(ret), K(wc_text), K(wc_length),
K(start_pos), K(pmatch), K(pmatch_size));
} else {
for (int64_t i = 1; OB_SUCC(ret) && i < pmatch_size; ++i) {
ObString sub;
if (OB_UNLIKELY(start_pos + pmatch[i].rm_so > wc_length)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("regexp library error, get invalid offset from pmatch", K(ret));
} else {
int64_t offset = static_cast<int64_t>(pmatch[i].rm_eo - pmatch[i].rm_so);
if (offset > 0){
char *tmp_char = NULL;
int64_t length = 0;
if (OB_FAIL(w2c(wc_text + pmatch[i].rm_so + start_pos, offset, tmp_char, length, string_buf))) {
LOG_WARN("failed to w2c.", K(ret));
} else if (OB_ISNULL(tmp_char)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("w2c function failed.", K(ret));
} else {
sub.assign_ptr(tmp_char, length);
}
}
if (OB_SUCC(ret)) {
if (OB_FAIL(subexpr_array.push_back(sub))) {
LOG_WARN("failed to push back string", K(ret));
}
}
}
}
for (int64_t i = pmatch_size; OB_SUCC(ret) && i < 10; ++i) {
ObString sub;
if (OB_SUCC(ret)) {
if (OB_FAIL(subexpr_array.push_back(sub))) {
LOG_WARN("failed to push back string", K(ret));
}
}
}
}
return ret;
}
int ObExprRegexContext::convert_reg_err_code_to_ob_err_code(int reg_err) const
{
int ret = OB_ERR_REGEXP_ERROR;
switch(reg_err) {
case OB_REG_NOMATCH: ret = OB_ERR_REGEXP_NOMATCH; break;
case OB_REG_BADPAT: ret = OB_ERR_REGEXP_BADPAT; break;
case OB_REG_ECOLLATE: ret = OB_ERR_REGEXP_ECOLLATE; break;
case OB_REG_ECTYPE: ret = OB_ERR_REGEXP_ECTYPE; break;
case OB_REG_EESCAPE: ret = OB_ERR_REGEXP_EESCAPE; break;
case OB_REG_ESUBREG: ret = OB_ERR_REGEXP_ESUBREG; break;
case OB_REG_EBRACK: ret = OB_ERR_REGEXP_EBRACK; break;
case OB_REG_EPAREN: ret = OB_ERR_REGEXP_EPAREN; break;
case OB_REG_EBRACE: ret = OB_ERR_REGEXP_EBRACE; break;
case OB_REG_BADBR: ret = OB_ERR_REGEXP_BADBR; break;
case OB_REG_ERANGE: ret = OB_ERR_REGEXP_ERANGE; break;
case OB_REG_ESPACE: ret = OB_SIZE_OVERFLOW; break;
case OB_REG_BADRPT: ret = OB_ERR_REGEXP_BADRPT; break;
case OB_REG_ASSERT: ret = OB_ERR_REGEXP_ASSERT; break;
case OB_REG_INVARG: ret = OB_ERR_REGEXP_INVARG; break;
case OB_REG_MIXED: ret = OB_ERR_REGEXP_MIXED; break;
case OB_REG_BADOPT: ret = OB_ERR_REGEXP_BADOPT; break;
case OB_REG_ETOOBIG: ret = OB_ERR_REGEXP_ETOOBIG; break;
default:break;
}
return ret;
}
int ObExprRegexContext::preprocess_pattern(ObExprStringBuf &string_buf,
const ObString &origin_pattern,
ObString &pattern)
{
int ret = OB_SUCCESS;
if (lib::is_mysql_mode()) {
pattern = origin_pattern;
} else if (!origin_pattern.empty()) {
/*oracle mode allow:
* regexp_substr('xxxx','[^][:]') <==> regexp_substr('xxxx','[^:]')
*/
bool need_transform = false;
const char *origin_buf = origin_pattern.ptr();
const int32_t origin_buf_len = origin_pattern.length();
int32_t begin_idx = -1;
const char *const_str1 = "[^][:]";
const char *const_str2 = "[^:]";
bool is_continued = true;
for (int32_t i = 0; is_continued && i < origin_buf_len; ++i) {
if (i + strlen(const_str1) <= origin_buf_len) {
ObString tmp_str(strlen(const_str1), origin_buf + i);
if (0 == tmp_str.compare(const_str1)) {
if (!need_transform) {
need_transform = true;
begin_idx = i;
i = i + strlen(const_str1) - 1;
} else {
need_transform = false;
is_continued = false;
}
}
}
}
if (need_transform && begin_idx >= 0 && begin_idx + strlen(const_str1) <= origin_buf_len) {
char *buf = NULL;
int32_t buf_len = 0;
if (OB_ISNULL(buf = static_cast<char *>(string_buf.alloc(
origin_buf_len - strlen(const_str1) + strlen(const_str2))))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_WARN("failed to alloc memory", K(origin_pattern), K(ret));
} else {
MEMCPY(buf, origin_buf, begin_idx);
buf_len += begin_idx;
MEMCPY(buf + buf_len, const_str2, strlen(const_str2));
buf_len += strlen(const_str2);
if (origin_buf_len - begin_idx - strlen(const_str1) > 0) {
MEMCPY(buf + buf_len,
origin_buf + begin_idx + strlen(const_str1),
origin_buf_len - begin_idx - strlen(const_str1));
buf_len += origin_buf_len - begin_idx - strlen(const_str1);
}
pattern.assign_ptr(buf, buf_len);
}
} else {
pattern = origin_pattern;
}
}
if (OB_SUCC(ret)) {
LOG_TRACE("succeed to preprocess pattern", K(origin_pattern), K(pattern));
}
return ret;
}
}
}
Reference in New Issue View Git Blame Copy Permalink