hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
b286d9ec97e86a788904030f3d398dc3f1741792
oceanbase/src/sql/engine/expr/ob_expr_trim.cpp
bf0 9fa49d5dca fix trim expr deduce bug
2022-03-23 14:01:34 +08:00

936 lines
34 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 SQL_ENG
#include "sql/engine/expr/ob_expr_trim.h"
#include <string.h>
#include "share/object/ob_obj_cast.h"
#include "sql/parser/ob_item_type.h"
//#include "sql/engine/expr/ob_expr_promotion_util.h"
#include "sql/session/ob_sql_session_info.h"
#include "sql/engine/expr/ob_expr_util.h"
namespace oceanbase {
using namespace common;
namespace sql {
ObExprTrim::ObExprTrim(ObIAllocator& alloc) : ObStringExprOperator(alloc, T_FUN_SYS_TRIM, N_TRIM, MORE_THAN_ZERO)
{
need_charset_convert_ = false;
}
ObExprTrim::ObExprTrim(ObIAllocator& alloc, ObExprOperatorType type, const char* name, int32_t param_num)
: ObStringExprOperator(alloc, type, name, param_num)
{}
ObExprTrim::~ObExprTrim()
{}
int ObExprTrim::trim(ObString& result, const int64_t trim_type, const ObString& pattern, const ObString& text)
{
int ret = OB_SUCCESS;
int32_t start = 0;
int32_t end = 0;
if (OB_UNLIKELY(pattern.length() <= 0)) {
start = 0;
end = text.length();
} else {
switch (trim_type) {
case TYPE_LRTRIM: {
ret = lrtrim(text, pattern, start, end);
break;
}
case TYPE_LTRIM: {
end = text.length();
ret = ltrim(text, pattern, start);
break;
}
case TYPE_RTRIM: {
start = 0;
ret = rtrim(text, pattern, end);
break;
}
default: {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid type", K(trim_type), K(ret));
break;
}
}
}
if (OB_SUCC(ret)) {
result = ObString(end - start, end - start, const_cast<char*>(text.ptr() + start));
}
return ret;
}
// for func Ltrim/Rtrim which has 2 string param
int ObExprTrim::trim2(common::ObString& result, const int64_t trim_type, const common::ObString& pattern,
const common::ObString& text, const ObCollationType& cs_type,
const ObFixedArray<size_t, ObIAllocator>& pattern_byte_num,
const ObFixedArray<size_t, ObIAllocator>& pattern_byte_offset)
{
int ret = OB_SUCCESS;
int32_t start = 0;
int32_t end = 0;
if (OB_UNLIKELY(pattern.length() <= 0)) {
start = 0;
end = text.length();
} else {
switch (trim_type) {
case TYPE_LTRIM: {
end = text.length();
ret = ltrim2(text, pattern, start, cs_type, pattern_byte_num, pattern_byte_offset);
break;
}
case TYPE_RTRIM: {
start = 0;
ret = rtrim2(text, pattern, end, cs_type, pattern_byte_num, pattern_byte_offset);
break;
}
default: {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid type", K(trim_type), K(ret));
break;
}
}
}
if (OB_SUCC(ret)) {
result = ObString(end - start, end - start, const_cast<char*>(text.ptr() + start));
}
return ret;
}
int ObExprTrim::calc(ObObj& result, const int64_t trim_type, const ObString& pattern, const ObString& text,
const ObObjType& res_type, ObExprCtx& expr_ctx)
{
UNUSED(expr_ctx);
int ret = OB_SUCCESS;
ObString varchar;
if (OB_FAIL(trim(varchar, trim_type, pattern, text))) {
LOG_WARN("do trim failed", K(ret));
} else {
if (share::is_oracle_mode() && (0 == varchar.length()) && !ob_is_text_tc(res_type)) {
result.set_null();
} else if (ob_is_text_tc(res_type)) {
result.set_lob_value(res_type, varchar.ptr(), varchar.length());
} else {
result.set_varchar(varchar);
}
}
return ret;
}
int ObExprTrim::calc_resultN(ObObj& result, const ObObj* objs_array, int64_t param_num, ObExprCtx& expr_ctx) const
{
int ret = OB_SUCCESS;
int64_t trim_type_val = TYPE_LRTRIM;
ObString pattern_val;
char default_pattern_buffer[8]; // 8 is enough for all charset
ObString text_val;
bool is_result_null = false;
if (OB_ISNULL(expr_ctx.calc_buf_) || OB_UNLIKELY(param_num <= 0 || param_num > 3) || OB_ISNULL(objs_array)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("Invalid argument", K(ret), K(param_num), K(expr_ctx.calc_buf_), K(objs_array));
} else if (param_num == 1) {
if (objs_array[0].is_null()) {
result.set_null();
is_result_null = true;
} else {
trim_type_val = TYPE_LRTRIM;
int64_t out_len = 0;
ObCollationType cs_type = (lib::is_oracle_mode() && !(expr_ctx.my_session_->use_static_typing_engine()))
? expr_ctx.my_session_->get_nls_collation()
: result_type_.get_collation_type();
if (OB_FAIL(fill_default_pattern(default_pattern_buffer, sizeof(default_pattern_buffer), cs_type, out_len))) {
} else if (out_len <= 0) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected out length", K(ret), K(out_len));
} else {
pattern_val.assign_ptr(default_pattern_buffer, static_cast<int32_t>(out_len));
}
text_val = objs_array[0].get_string();
}
} else if (param_num == 2) {
if (OB_UNLIKELY(objs_array[0].is_null()) || OB_UNLIKELY(objs_array[1].is_null())) {
result.set_null();
is_result_null = true;
} else {
int64_t out_len = 0;
ObCollationType cs_type = (lib::is_oracle_mode() && !(expr_ctx.my_session_->use_static_typing_engine()))
? expr_ctx.my_session_->get_nls_collation()
: result_type_.get_collation_type();
if (OB_FAIL(fill_default_pattern(default_pattern_buffer, sizeof(default_pattern_buffer), cs_type, out_len))) {
} else if (out_len <= 0) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected out length", K(ret), K(out_len));
} else {
pattern_val.assign_ptr(default_pattern_buffer, static_cast<int32_t>(out_len));
}
trim_type_val = objs_array[0].get_int();
text_val = objs_array[1].get_string();
}
} else if (param_num == 3) {
if (OB_UNLIKELY(objs_array[0].is_null()) || OB_UNLIKELY(objs_array[1].is_null()) ||
OB_UNLIKELY(objs_array[2].is_null())) {
result.set_null();
is_result_null = true;
} else {
trim_type_val = objs_array[0].get_int();
pattern_val = objs_array[1].get_string();
text_val = objs_array[2].get_string();
}
}
if (OB_LIKELY(OB_SUCC(ret) && !is_result_null)) {
ObCollationType cs_type = result_type_.get_collation_type();
if (share::is_oracle_mode() && ObCharset::strlen_char(cs_type, pattern_val.ptr(), pattern_val.length()) > 1) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("trim set should have only one character", K(ret), K(pattern_val));
} else {
ret = calc(result, trim_type_val, pattern_val, text_val, get_result_type().get_type(), expr_ctx);
if (OB_LIKELY(OB_SUCC(ret) && !result.is_null())) {
if (share::is_oracle_mode()) {
if (OB_NOT_NULL(expr_ctx.my_session_)) {
result.set_collation_type(expr_ctx.my_session_->get_nls_collation());
}
if (OB_FAIL(convert_result_collation(result_type_, result, expr_ctx.calc_buf_))) {
LOG_WARN("fail to convert result collation", K(ret));
}
}
result.set_collation(result_type_);
}
}
}
return ret;
}
int ObExprTrim::lrtrim(const ObString src, const ObString pattern, int32_t& start, int32_t& end)
{
int ret = OB_SUCCESS;
if (OB_UNLIKELY(pattern.length() <= 0)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("Invalid argument", K(ret), K(pattern.length()));
} else {
int32_t i = 0;
start = 0;
end = src.length();
int32_t src_len = src.length();
int32_t pattern_len = pattern.length();
for (i = 0; OB_SUCC(ret) && i <= src_len - pattern_len; i += pattern_len) {
if (0 == MEMCMP(src.ptr() + i, pattern.ptr(), pattern_len)) {
start += pattern_len;
} else {
break;
}
} // end for
for (i = src_len - pattern_len; OB_SUCC(ret) && i >= start; i -= pattern_len) {
if (0 == MEMCMP(src.ptr() + i, pattern.ptr(), pattern_len)) {
end -= pattern_len;
} else {
break;
}
} // end for
}
return ret;
}
// NOTE: pattern.length() MUST > 0
int ObExprTrim::ltrim(const ObString src, const ObString pattern, int32_t& start)
{
int ret = OB_SUCCESS;
if (OB_UNLIKELY(pattern.length() <= 0)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("Invalid argument", K(ret), K(pattern.length()));
} else {
start = 0;
int32_t src_len = src.length();
int32_t pattern_len = pattern.length();
for (int32_t i = 0; OB_SUCC(ret) && i <= src_len - pattern_len; i += pattern_len) {
if (0 == MEMCMP(src.ptr() + i, pattern.ptr(), pattern_len)) {
start += pattern_len;
} else {
break;
}
} // end for
}
return ret;
}
// NOTE: pattern.length() MUST > 0
int ObExprTrim::rtrim(const ObString src, const ObString pattern, int32_t& end)
{
int ret = OB_SUCCESS;
if (OB_UNLIKELY(pattern.length() <= 0)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("Invalid argument", K(ret), K(pattern.length()));
} else {
end = src.length();
int32_t src_len = src.length();
int32_t pattern_len = pattern.length();
for (int32_t i = src_len - pattern_len; OB_SUCC(ret) && i >= 0; i -= pattern_len) {
if (0 == MEMCMP(src.ptr() + i, pattern.ptr(), pattern_len)) {
end -= pattern_len;
} else {
break;
}
}
}
return ret;
}
int ObExprTrim::ltrim2(const ObString src, const ObString pattern, int32_t& start, const ObCollationType& cs_type,
const ObFixedArray<size_t, ObIAllocator>& pattern_byte_num,
const ObFixedArray<size_t, ObIAllocator>& pattern_byte_offset)
{
UNUSED(cs_type);
int ret = OB_SUCCESS;
if (OB_UNLIKELY(pattern.length() <= 0)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("Invaild arguemnt", K(ret), K(pattern.length()));
} else {
int32_t i = 0;
start = 0;
int32_t src_len = src.length();
int32_t pattern_len = pattern.length();
bool is_match = false;
do {
is_match = false;
for (i = 0; OB_SUCC(ret) && i < pattern_byte_num.count() && !is_match; ++i) {
int32_t char_len = pattern_byte_num[i];
int32_t pattern_offset = pattern_byte_offset[i];
if (src_len - start < char_len) {
} else if (0 == MEMCMP(src.ptr() + start, pattern.ptr() + pattern_offset, char_len)) {
start += char_len;
is_match = true;
} else {
continue;
}
}
} while (is_match);
}
return ret;
}
int ObExprTrim::rtrim2(const ObString src, const ObString pattern, int32_t& end, const ObCollationType& cs_type,
const ObFixedArray<size_t, ObIAllocator>& pattern_byte_num,
const ObFixedArray<size_t, ObIAllocator>& pattern_byte_offset)
{
UNUSED(cs_type);
int ret = OB_SUCCESS;
if (OB_UNLIKELY(pattern.length() <= 0)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("Invaild arguemnt", K(ret), K(pattern.length()));
} else {
int32_t i = 0;
int32_t src_len = src.length();
end = src_len;
int32_t pattern_len = pattern.length();
bool is_match = false;
do {
is_match = false;
for (i = 0; OB_SUCC(ret) && i < pattern_byte_num.count() && !is_match; ++i) {
int32_t char_len = pattern_byte_num[i];
int32_t pattern_offset = pattern_byte_offset[i];
if (end < char_len) {
} else if (0 == MEMCMP(src.ptr() + end - char_len, pattern.ptr() + pattern_offset, char_len)) {
end -= char_len;
is_match = true;
} else {
continue;
}
}
} while (is_match);
}
return ret;
}
inline int ObExprTrim::deduce_result_type(
ObExprResType& type, ObExprResType* types, int64_t param_num, ObExprTypeCtx& type_ctx)
{
int ret = OB_SUCCESS;
CK(NULL != types);
CK(NULL != type_ctx.get_session());
CK(param_num >= 1 && param_num <= 3);
ObExprResType* str_type = &types[param_num - 1];
type.set_length(types[param_num - 1].get_length());
ObExprResType* pattern_type = (3 == param_num) ? &types[1] : NULL;
if (param_num > 2) {
types[0].set_calc_type(ObIntType);
}
if (lib::is_oracle_mode() && type_ctx.get_session()->use_static_typing_engine()) {
auto str_params = make_const_carray(str_type);
LOG_DEBUG("str_type is", K(str_type));
if (str_type->is_null()) {
type.set_meta(*str_type);
} else {
OZ(aggregate_string_type_and_charset_oracle(*type_ctx.get_session(), str_params,
type, true)); // prefer varchar
OZ(deduce_string_param_calc_type_and_charset(*type_ctx.get_session(), type, str_params));
if (OB_SUCC(ret) && NULL != pattern_type) {
pattern_type->set_calc_meta(type);
}
}
} else {
if (str_type->is_lob()) {
type.set_type(str_type->get_type());
str_type->set_calc_type(str_type->get_type());
if (NULL != pattern_type) {
pattern_type->set_calc_type(str_type->get_type());
}
} else if (str_type->is_nstring()) {
type.set_meta(*str_type);
type.set_type_simple(ObNVarchar2Type);
str_type->set_calc_type(ObVarcharType);
if (NULL != pattern_type) {
pattern_type->set_calc_type(ObVarcharType);
}
} else if (str_type->is_null()) {
type.set_meta(*str_type);
} else {
const common::ObLengthSemantics default_length_semantics =
(OB_NOT_NULL(type_ctx.get_session()) ? type_ctx.get_session()->get_actual_nls_length_semantics()
: common::LS_BYTE);
type.set_varchar();
type.set_length_semantics(
types[0].is_varchar_or_char() ? types[0].get_length_semantics() : default_length_semantics);
str_type->set_calc_type(ObVarcharType);
if (NULL != pattern_type) {
pattern_type->set_calc_type(ObVarcharType);
}
}
// deduce charset
ObSEArray<ObExprResType, 2> tmp_types;
OZ(tmp_types.push_back(*str_type));
// if (NULL != pattern_type) {
// OZ(tmp_types.push_back(*pattern_type));
//}
OZ(aggregate_charsets_for_string_result_with_comparison(
type, &tmp_types.at(0), tmp_types.count(), type_ctx.get_coll_type()));
str_type->set_calc_collation_type(type.get_collation_type());
str_type->set_calc_collation_level(type.get_collation_level());
if (NULL != pattern_type) {
pattern_type->set_calc_collation_type(type.get_collation_type());
pattern_type->set_calc_collation_level(type.get_collation_level());
}
}
return ret;
}
int ObExprTrim::fill_default_pattern(char* buf, const int64_t in_len, ObCollationType cs_type, int64_t& out_len)
{
int ret = OB_SUCCESS;
char default_pattern = ' ';
const ObCharsetInfo* cs = ObCharset::get_charset(cs_type);
if (OB_ISNULL(cs) || OB_ISNULL(cs->cset)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected collation type", K(ret), K(cs_type), K(cs));
} else if (NULL == buf || in_len < cs->mbminlen) {
ret = OB_BUF_NOT_ENOUGH;
LOG_WARN("buffer not enough", K(ret), KP(buf), K(in_len), K(cs->mbminlen));
} else if (1 == cs->mbminlen) {
*buf = default_pattern;
out_len = 1;
} else {
// mbminlen is always enough
cs->cset->fill(cs, buf, cs->mbminlen, default_pattern);
out_len = cs->mbminlen;
}
return ret;
}
int ObExprTrim::cg_expr(ObExprCGCtx&, const ObRawExpr&, ObExpr& rt_expr) const
{
int ret = OB_SUCCESS;
CK(1 <= rt_expr.arg_cnt_ && rt_expr.arg_cnt_ <= 3);
rt_expr.eval_func_ = eval_trim;
return ret;
}
int ObExprTrim::eval_trim(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& expr_datum)
{
int ret = OB_SUCCESS;
bool has_null = false;
if (OB_FAIL(expr.eval_param_value(ctx))) {
LOG_WARN("evaluate parameters failed", K(ret));
} else {
for (int64_t i = 0; i < expr.arg_cnt_; i++) {
if (expr.locate_param_datum(ctx, i).is_null()) {
has_null = true;
}
}
}
if (OB_FAIL(ret)) {
} else if (has_null) {
expr_datum.set_null();
} else {
int64_t trim_type = TYPE_LRTRIM;
// may be called by ltrim() or rtrim()
if (1 == expr.arg_cnt_) {
if (T_FUN_SYS_LTRIM == expr.type_) {
trim_type = TYPE_LTRIM;
} else if (T_FUN_SYS_RTRIM == expr.type_) {
trim_type = TYPE_RTRIM;
}
} else if (2 == expr.arg_cnt_) {
if (T_FUN_SYS_LTRIM == expr.type_) {
LOG_WARN("trim_type is ltrim");
trim_type = TYPE_LTRIM;
} else if (T_FUN_SYS_RTRIM == expr.type_) {
LOG_WARN("trim type is rtrim");
trim_type = TYPE_RTRIM;
} else {
trim_type = expr.locate_param_datum(ctx, 0).get_int();
LOG_WARN("trim type is ", K(trim_type));
}
} else {
trim_type = expr.locate_param_datum(ctx, 0).get_int();
}
ObString str;
char default_pattern_buffer[8];
ObString pattern;
bool res_is_clob = false;
if (2 == expr.arg_cnt_ && (T_FUN_SYS_LTRIM == expr.type_ || T_FUN_SYS_RTRIM == expr.type_)) {
str = expr.locate_param_datum(ctx, expr.arg_cnt_ - 2).get_string();
pattern = expr.locate_param_datum(ctx, expr.arg_cnt_ - 1).get_string();
res_is_clob = lib::is_oracle_mode() && ob_is_text_tc(expr.args_[expr.arg_cnt_ - 2]->datum_meta_.type_) &&
(CS_TYPE_BINARY != expr.args_[expr.arg_cnt_ - 2]->datum_meta_.cs_type_);
} else {
str = expr.locate_param_datum(ctx, expr.arg_cnt_ - 1).get_string();
res_is_clob = lib::is_oracle_mode() && ob_is_text_tc(expr.args_[expr.arg_cnt_ - 1]->datum_meta_.type_) &&
(CS_TYPE_BINARY != expr.args_[expr.arg_cnt_ - 1]->datum_meta_.cs_type_);
if (3 == expr.arg_cnt_) {
pattern = expr.locate_param_datum(ctx, 1).get_string();
if (lib::is_oracle_mode() &&
1 < ObCharset::strlen_char(expr.datum_meta_.cs_type_, pattern.ptr(), pattern.length())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("trim set should have only one character", K(ret), K(pattern));
}
} else {
int64_t out_len = 0;
if (OB_FAIL(fill_default_pattern(
default_pattern_buffer, sizeof(default_pattern_buffer), expr.datum_meta_.cs_type_, out_len))) {
} else if (out_len <= 0) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected out length", K(ret), K(out_len));
} else {
pattern.assign_ptr(default_pattern_buffer, static_cast<int32_t>(out_len));
}
}
}
ObString output;
// 2 param for Ltrim or Rtrim
if (2 == expr.arg_cnt_ && (T_FUN_SYS_LTRIM == expr.type_ || T_FUN_SYS_RTRIM == expr.type_)) {
ObIAllocator& calc_alloc = ctx.get_reset_tmp_alloc();
ObCollationType cs_type = expr.datum_meta_.cs_type_;
size_t pattern_len_in_char = ObCharset::strlen_char(cs_type, pattern.ptr(), pattern.length());
ObFixedArray<size_t, ObIAllocator> pattern_byte_num(calc_alloc, pattern_len_in_char);
ObFixedArray<size_t, ObIAllocator> pattern_byte_offset(calc_alloc, pattern_len_in_char + 1);
if (OB_FAIL(ObExprUtil::get_mb_str_info(pattern, cs_type, pattern_byte_num, pattern_byte_offset))) {
LOG_WARN("get_mb_str_info failed", K(ret), K(pattern), K(cs_type), K(pattern_len_in_char));
} else if (!res_is_clob && (pattern_byte_num.count() + 1 != pattern_byte_offset.count())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("size of pattern_byte_num and size of pattern_byte_offset should be same",
K(ret),
K(pattern_byte_num),
K(pattern_byte_offset));
}
if (OB_FAIL(ret)) {
} else if (OB_FAIL(trim2(output, trim_type, pattern, str, cs_type, pattern_byte_num, pattern_byte_offset))) {
LOG_WARN("do trim2 failed", K(ret));
} else {
if (output.empty() && lib::is_oracle_mode() && !res_is_clob) {
expr_datum.set_null();
} else {
expr_datum.set_string(output);
}
}
} else {
if (OB_FAIL(ret)) {
} else if (OB_FAIL(trim(output, trim_type, pattern, str))) {
LOG_WARN("do trim failed", K(ret));
} else {
if (output.empty() && lib::is_oracle_mode() && !res_is_clob) {
expr_datum.set_null();
} else {
expr_datum.set_string(output);
}
}
}
}
return ret;
}
// Ltrim start
ObExprLtrim::ObExprLtrim(ObIAllocator& alloc)
: ObExprTrim(alloc, T_FUN_SYS_LTRIM, N_LTRIM, (share::is_oracle_mode()) ? ONE_OR_TWO : 1)
{}
ObExprLtrim::ObExprLtrim(ObIAllocator& alloc, ObExprOperatorType type, const char* name, int32_t param_num)
: ObExprTrim(alloc, type, name, param_num)
{}
ObExprLtrim::~ObExprLtrim()
{}
inline int ObExprLtrim::calc_result_type1(ObExprResType& res_type, ObExprResType& type1, ObExprTypeCtx& type_ctx) const
{
int ret = OB_SUCCESS;
CK(NULL != type_ctx.get_session());
// old engine, keep old logic.
if (OB_SUCC(ret) && !type_ctx.get_session()->use_static_typing_engine()) {
if (type1.is_lob()) {
res_type.set_type(type1.get_type());
} else if (type1.is_nstring()) {
res_type.set_meta(type1);
} else {
res_type.set_varchar();
const common::ObLengthSemantics default_length_semantics =
(OB_NOT_NULL(type_ctx.get_session()) ? type_ctx.get_session()->get_actual_nls_length_semantics()
: common::LS_BYTE);
res_type.set_length_semantics(
type1.is_varchar_or_char() ? type1.get_length_semantics() : default_length_semantics);
}
if (type1.is_null()) {
res_type.set_null();
} else {
res_type.set_length(type1.get_length());
type1.set_calc_type(ObVarcharType);
ret = aggregate_charsets_for_string_result_with_comparison(res_type, &type1, 1, type_ctx.get_coll_type());
}
}
// static typing engine
if (OB_SUCC(ret) && type_ctx.get_session()->use_static_typing_engine()) {
OZ(ObExprTrim::deduce_result_type(res_type, &type1, 1, type_ctx));
}
return ret;
}
inline int ObExprLtrim::deduce_result_type(
ObExprResType& type, ObExprResType* types, int64_t param_num, ObExprTypeCtx& type_ctx)
{
int ret = OB_SUCCESS;
CK(NULL != types);
CK(NULL != type_ctx.get_session());
CK(param_num >= 1 && param_num <= 2);
ObExprResType* str_type = &types[0];
type.set_length(types[0].get_length());
ObExprResType* pattern_type = (2 == param_num) ? &types[1] : NULL;
if (lib::is_oracle_mode() && type_ctx.get_session()->use_static_typing_engine()) {
auto str_params = make_const_carray(str_type);
OZ(aggregate_string_type_and_charset_oracle(*type_ctx.get_session(), str_params, type, true)); // prefer varchar
OZ(deduce_string_param_calc_type_and_charset(*type_ctx.get_session(), type, str_params));
if (NULL != pattern_type) {
pattern_type->set_calc_meta(type);
}
} else {
if (str_type->is_lob()) {
type.set_type(str_type->get_type());
str_type->set_calc_type(str_type->get_type());
if (NULL != pattern_type) {
pattern_type->set_calc_type(pattern_type->get_type());
}
} else if (str_type->is_nstring()) {
type.set_meta(*str_type);
type.set_type_simple(ObNVarchar2Type);
str_type->set_calc_type(ObVarcharType);
if (NULL != pattern_type) {
pattern_type->set_calc_type(ObVarcharType);
}
} else {
const common::ObLengthSemantics default_length_semantics =
(OB_NOT_NULL(type_ctx.get_session()) ? type_ctx.get_session()->get_actual_nls_length_semantics()
: common::LS_BYTE);
type.set_varchar();
type.set_length_semantics(
types[0].is_varchar_or_char() ? types[0].get_length_semantics() : default_length_semantics);
str_type->set_calc_type(ObVarcharType);
if (NULL != pattern_type) {
pattern_type->set_calc_type(ObVarcharType);
}
}
// deduce charset
ObSEArray<ObExprResType, 2> tmp_types;
OZ(tmp_types.push_back(*str_type));
if (NULL != pattern_type) {
OZ(tmp_types.push_back(*pattern_type));
}
OZ(aggregate_charsets_for_string_result_with_comparison(
type, &tmp_types.at(0), tmp_types.count(), type_ctx.get_coll_type()));
str_type->set_calc_collation_type(type.get_collation_type());
str_type->set_calc_collation_level(type.get_collation_level());
if (NULL != pattern_type) {
pattern_type->set_calc_collation_type(type.get_collation_type());
pattern_type->set_calc_collation_level(type.get_collation_level());
}
}
return ret;
}
int ObExprLtrim::calc_result1(ObObj& res_obj, const ObObj& obj1, ObExprCtx& expr_ctx) const
{
return calc(res_obj, obj1, expr_ctx, TYPE_LTRIM);
}
// @param: trim_type_use
// 1: LTRIM or 2: RTRIM
int ObExprLtrim::calc(ObObj& res_obj, const ObObj& obj1, ObExprCtx& expr_ctx, int64_t trim_type_use) const
{
int ret = OB_SUCCESS;
ObString pattern_val;
char default_pattern_buffer[8]; // 8 is enough for all charset
ObString text_val;
bool is_result_null = false;
if (OB_ISNULL(expr_ctx.calc_buf_)) {
ret = OB_NOT_INIT;
LOG_WARN("calc_buf in not init", K(ret), K(expr_ctx.calc_buf_));
} else {
if (obj1.is_null()) {
res_obj.set_null();
is_result_null = true;
} else {
int64_t out_len = 0;
ObCollationType cs_type = (lib::is_oracle_mode() && !(expr_ctx.my_session_->use_static_typing_engine()))
? expr_ctx.my_session_->get_nls_collation()
: result_type_.get_collation_type();
if (OB_FAIL(fill_default_pattern(default_pattern_buffer, sizeof(default_pattern_buffer), cs_type, out_len))) {
} else if (out_len <= 0) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected out length", K(ret), K(out_len));
} else {
pattern_val.assign_ptr(default_pattern_buffer, static_cast<int32_t>(out_len));
}
text_val = obj1.get_string();
}
}
if (OB_LIKELY(OB_SUCC(ret) && !is_result_null)) {
ret = ObExprTrim::calc(res_obj, trim_type_use, pattern_val, text_val, get_result_type().get_type(), expr_ctx);
if (OB_LIKELY(OB_SUCC(ret) && !res_obj.is_null())) {
if (share::is_oracle_mode()) {
if (OB_NOT_NULL(expr_ctx.my_session_)) {
res_obj.set_collation_type(expr_ctx.my_session_->get_nls_collation());
}
if (OB_FAIL(convert_result_collation(result_type_, res_obj, expr_ctx.calc_buf_))) {
LOG_WARN("fail to convert result collation", K(ret));
}
}
res_obj.set_collation(result_type_);
}
}
return ret;
}
int ObExprLtrim::calc_resultN(ObObj& result, const ObObj* objs_array, int64_t param_num, ObExprCtx& expr_ctx) const
{
int ret = OB_SUCCESS;
int64_t trim_type_val = TYPE_LTRIM;
ObString pattern_val;
char default_pattern_buffer[8]; // 8 is enough for all charset
ObString text_val;
bool is_result_null = false;
if (OB_ISNULL(expr_ctx.calc_buf_) || OB_UNLIKELY(param_num <= 0 || param_num > 2 || OB_ISNULL(objs_array))) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("Invalid argument", K(ret), K(param_num), K(expr_ctx.calc_buf_), K(objs_array));
} else if (1 == param_num) {
if (objs_array[0].is_null()) {
result.set_null();
is_result_null = true;
} else {
int64_t out_len = 0;
ObCollationType cs_type = (lib::is_oracle_mode() && !(expr_ctx.my_session_->use_static_typing_engine()))
? expr_ctx.my_session_->get_nls_collation()
: result_type_.get_collation_type();
if (OB_FAIL(fill_default_pattern(default_pattern_buffer, sizeof(default_pattern_buffer), cs_type, out_len))) {
} else if (out_len <= 0) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected out length", K(ret), K(out_len));
} else {
pattern_val.assign_ptr(default_pattern_buffer, static_cast<int32_t>(out_len));
}
}
text_val = objs_array[0].get_string();
} else if (param_num == 2) {
if (OB_UNLIKELY(objs_array[0].is_null()) || OB_UNLIKELY(objs_array[1].is_null())) {
result.set_null();
is_result_null = true;
} else {
pattern_val = objs_array[1].get_string();
text_val = objs_array[0].get_string();
}
}
if (OB_LIKELY(OB_SUCCESS == ret && !is_result_null)) {
ObCollationType cs_type = result_type_.get_collation_type();
ret = calc_oracle_mode(
result, trim_type_val, pattern_val, text_val, get_result_type().get_type(), expr_ctx, param_num, cs_type);
if (OB_LIKELY(OB_SUCCESS == ret && !result.is_null())) {
if (share::is_oracle_mode()) {
if (OB_NOT_NULL(expr_ctx.my_session_)) {
result.set_collation_type(expr_ctx.my_session_->get_nls_collation());
}
if (OB_FAIL(convert_result_collation(result_type_, result, expr_ctx.calc_buf_))) {
LOG_WARN("fail to convert result collation", K(ret));
}
}
result.set_collation(result_type_);
}
}
return ret;
}
int ObExprLtrim::calc_oracle_mode(ObObj& result, const int64_t trim_type, const ObString& pattern, const ObString& text,
const ObObjType& res_type, ObExprCtx& expr_ctx, const int64_t param_num, const ObCollationType& cs_type)
{
UNUSED(expr_ctx);
int ret = OB_SUCCESS;
ObString varchar;
if (1 == param_num) {
if (OB_FAIL(trim(varchar, trim_type, pattern, text))) {
LOG_WARN("do trim failed", K(ret));
} else {
if (share::is_oracle_mode() && (0 == varchar.length()) && !ob_is_text_tc(res_type)) {
result.set_null();
} else if (ob_is_text_tc(res_type)) {
result.set_lob_value(res_type, varchar.ptr(), varchar.length());
} else {
result.set_varchar(varchar);
}
}
} else if (2 == param_num) {
size_t pattern_len_in_char = ObCharset::strlen_char(cs_type, pattern.ptr(), pattern.length());
ObFixedArray<size_t, ObIAllocator> pattern_byte_num(expr_ctx.calc_buf_, pattern_len_in_char);
ObFixedArray<size_t, ObIAllocator> pattern_byte_offset(expr_ctx.calc_buf_, pattern_len_in_char + 1);
if (OB_FAIL(ObExprUtil::get_mb_str_info(pattern, cs_type, pattern_byte_num, pattern_byte_offset))) {
LOG_WARN("get_mb_str_info failed", K(ret), K(pattern), K(cs_type), K(pattern_len_in_char));
} else if (!ob_is_text_tc(res_type) && (pattern_byte_num.count() + 1 != pattern_byte_offset.count())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("size of pattern_byte_num and size of pattern_byte_offset should be same",
K(ret),
K(pattern_byte_num),
K(pattern_byte_offset));
}
if (OB_FAIL(trim2(varchar, trim_type, pattern, text, cs_type, pattern_byte_num, pattern_byte_offset))) {
LOG_WARN("do trim2 failed", K(ret));
} else {
if (share::is_oracle_mode() && 0 == varchar.length() && !ob_is_text_tc(res_type)) {
result.set_null();
} else if (ob_is_text_tc(res_type)) {
result.set_lob_value(res_type, varchar.ptr(), varchar.length());
} else {
result.set_varchar(varchar);
}
}
} else {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("Invalid argument", K(ret), K(param_num));
}
return ret;
}
int ObExprLtrim::cg_expr(ObExprCGCtx&, const ObRawExpr&, ObExpr& rt_expr) const
{
int ret = OB_SUCCESS;
CK(1 == rt_expr.arg_cnt_ || 2 == rt_expr.arg_cnt_);
// trim type is detected by expr type in ObExprTrim::eval_trim
rt_expr.eval_func_ = &ObExprTrim::eval_trim;
return ret;
}
// Rtrim start
ObExprRtrim::ObExprRtrim(ObIAllocator& alloc)
: ObExprLtrim(alloc, T_FUN_SYS_RTRIM, N_RTRIM, (share::is_oracle_mode()) ? ONE_OR_TWO : 1)
{}
ObExprRtrim::~ObExprRtrim()
{}
inline int ObExprRtrim::calc_result_type1(ObExprResType& res_type, ObExprResType& type1, ObExprTypeCtx& type_ctx) const
{
return ObExprLtrim::calc_result_type1(res_type, type1, type_ctx);
}
inline int ObExprRtrim::calc_result1(ObObj& res_obj, const ObObj& obj1, ObExprCtx& expr_ctx) const
{
return ObExprLtrim::calc(res_obj, obj1, expr_ctx, TYPE_RTRIM);
}
int ObExprRtrim::calc_resultN(ObObj& result, const ObObj* objs_array, int64_t param_num, ObExprCtx& expr_ctx) const
{
int ret = OB_SUCCESS;
int64_t trim_type_val = TYPE_RTRIM;
ObString pattern_val;
char default_pattern_buffer[8]; // 8 is enough for all charset
ObString text_val;
bool is_result_null = false;
if (OB_ISNULL(expr_ctx.calc_buf_) || OB_UNLIKELY(param_num <= 0 || param_num > 2 || OB_ISNULL(objs_array))) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("Invalid argument", K(ret), K(param_num), K(expr_ctx.calc_buf_), K(objs_array));
} else if (1 == param_num) {
if (objs_array[0].is_null()) {
result.set_null();
is_result_null = true;
} else {
int64_t out_len = 0;
ObCollationType cs_type = (lib::is_oracle_mode() && !(expr_ctx.my_session_->use_static_typing_engine()))
? expr_ctx.my_session_->get_nls_collation()
: result_type_.get_collation_type();
if (OB_FAIL(fill_default_pattern(default_pattern_buffer, sizeof(default_pattern_buffer), cs_type, out_len))) {
} else if (out_len <= 0) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected out length", K(ret), K(out_len));
} else {
pattern_val.assign_ptr(default_pattern_buffer, static_cast<int32_t>(out_len));
}
}
text_val = objs_array[0].get_string();
} else if (param_num == 2) {
if (OB_UNLIKELY(objs_array[0].is_null()) || OB_UNLIKELY(objs_array[1].is_null())) {
result.set_null();
is_result_null = true;
} else {
pattern_val = objs_array[1].get_string();
text_val = objs_array[0].get_string();
}
}
if (OB_LIKELY(OB_SUCCESS == ret && !is_result_null)) {
ObCollationType cs_type = result_type_.get_collation_type();
ret = ObExprLtrim::calc_oracle_mode(
result, trim_type_val, pattern_val, text_val, get_result_type().get_type(), expr_ctx, param_num, cs_type);
if (OB_LIKELY(OB_SUCCESS == ret && !result.is_null())) {
if (share::is_oracle_mode()) {
if (OB_NOT_NULL(expr_ctx.my_session_)) {
result.set_collation_type(expr_ctx.my_session_->get_nls_collation());
}
if (OB_FAIL(convert_result_collation(result_type_, result, expr_ctx.calc_buf_))) {
LOG_WARN("fail to convert result collation", K(ret));
}
}
result.set_collation(result_type_);
}
}
return ret;
}
} // namespace sql
} // namespace oceanbase
Reference in New Issue View Git Blame Copy Permalink