hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
1584d80d64fb6a45612b30245e3cb6125d86aa94
oceanbase/src/sql/engine/expr/ob_expr_array_contains.cpp
obdev 850479a759 [ARRAY] array_contains && attrs expr bugfix
2024-09-18 07:19:30 +00:00

540 lines
31 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.
* This file contains implementation for array.
*/
#define USING_LOG_PREFIX SQL_ENG
#include "sql/engine/expr/ob_expr_array_contains.h"
#include "lib/udt/ob_collection_type.h"
#include "lib/udt/ob_array_type.h"
#include "sql/engine/expr/ob_expr_lob_utils.h"
#include "sql/engine/expr/ob_array_expr_utils.h"
#include "sql/engine/ob_exec_context.h"
#include "sql/engine/expr/ob_expr_result_type_util.h"
using namespace oceanbase::common;
using namespace oceanbase::sql;
using namespace oceanbase::omt;
namespace oceanbase
{
namespace sql
{
ObExprArrayContains::ObExprArrayContains(ObIAllocator &alloc)
: ObFuncExprOperator(alloc, T_FUNC_SYS_ARRAY_CONTAINS, N_ARRAY_CONTAINS, 2, VALID_FOR_GENERATED_COL, NOT_ROW_DIMENSION)
{
}
ObExprArrayContains::ObExprArrayContains(ObIAllocator &alloc,
ObExprOperatorType type,
const char *name,
int32_t param_num,
int32_t dimension) : ObFuncExprOperator(alloc, type, name, param_num, VALID_FOR_GENERATED_COL, dimension)
{
}
ObExprArrayContains::~ObExprArrayContains()
{
}
int ObExprArrayContains::calc_result_type2(ObExprResType &type,
ObExprResType &type1,
ObExprResType &type2,
common::ObExprTypeCtx &type_ctx) const
{
int ret = OB_SUCCESS;
ObSQLSessionInfo *session = const_cast<ObSQLSessionInfo *>(type_ctx.get_session());
ObExecContext *exec_ctx = OB_ISNULL(session) ? NULL : session->get_cur_exec_ctx();
ObSubSchemaValue arr_meta;
const ObSqlCollectionInfo *coll_info = NULL;
ObExprResType *type1_ptr = &type1;
ObExprResType *type2_ptr = &type2;
uint16_t subschema_id;
if (OB_ISNULL(exec_ctx)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("exec ctx is null", K(ret));
} else if (OB_ISNULL(type_ctx.get_raw_expr())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("raw expr is null", K(ret));
} else if (type_ctx.get_raw_expr()->get_extra() != 0) {
// It's any operator ,param order is reversed
ObExprResType *type_tmp = type2_ptr;
type2_ptr = type1_ptr;
type1_ptr = type_tmp;
}
if (OB_FAIL(ret)) {
} else if (!ob_is_collection_sql_type(type1_ptr->get_type())) {
ret = OB_ERR_INVALID_TYPE_FOR_OP;
LOG_USER_ERROR(OB_ERR_INVALID_TYPE_FOR_OP, ob_obj_type_str(type1_ptr->get_type()), ob_obj_type_str(type2_ptr->get_type()));
} else if (type2_ptr->is_null()) {
// do nothing
} else if (OB_FAIL(exec_ctx->get_sqludt_meta_by_subschema_id(type1_ptr->get_subschema_id(), arr_meta))) {
LOG_WARN("failed to get elem meta.", K(ret), K(type1_ptr->get_subschema_id()));
} else if (arr_meta.type_ != ObSubSchemaType::OB_SUBSCHEMA_COLLECTION_TYPE) {
ret = OB_ERR_INVALID_TYPE_FOR_OP;
LOG_WARN("invalid subschema type", K(ret), K(arr_meta.type_));
} else if (OB_ISNULL(coll_info = static_cast<const ObSqlCollectionInfo *>(arr_meta.value_))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("coll info is null", K(ret));
} else if (!ob_is_collection_sql_type(type2_ptr->get_type())) {
ObCollectionArrayType *arr_type = static_cast<ObCollectionArrayType *>(coll_info->collection_meta_);
ObCollectionTypeBase *elem_type = arr_type->element_type_;
if (elem_type->type_id_ == ObNestedType::OB_BASIC_TYPE) {
if (ob_obj_type_class(type2_ptr->get_type()) != static_cast<ObCollectionBasicType *>(elem_type)->basic_meta_.get_type_class()) {
ObObjType calc_type = type2_ptr->get_type();
if (type2_ptr->get_type() == ObDecimalIntType || type2_ptr->get_type() == ObNumberType || type2_ptr->get_type() == ObUNumberType) {
calc_type = ObDoubleType;
if (get_decimalint_type(type2_ptr->get_precision()) == DECIMAL_INT_32) {
calc_type = ObFloatType;
}
}
if (calc_type == static_cast<ObCollectionBasicType *>(elem_type)->basic_meta_.get_obj_type()) {
type2_ptr->set_calc_type(calc_type);
} else {
uint32_t depth = 0;
ObDataType coll_elem1_type;
ObExprResType deduce_type;
bool is_vec = false;
if (OB_FAIL(ret)) {
} else if (OB_FAIL(ObArrayExprUtils::get_array_element_type(exec_ctx, type1_ptr->get_subschema_id(), coll_elem1_type, depth, is_vec))) {
LOG_WARN("failed to get array element type", K(ret));
} else if (OB_FAIL(ObExprResultTypeUtil::get_array_calc_type(exec_ctx, coll_elem1_type.get_obj_type(), calc_type,
depth, deduce_type, calc_type))) {
LOG_WARN("failed to get array calc type", K(ret));
} else {
type1_ptr->set_calc_meta(deduce_type);
type2_ptr->set_calc_type(calc_type);
}
}
}
} else {
ret = OB_ERR_INVALID_TYPE_FOR_OP;
LOG_WARN("invalid obj type", K(ret), K(*coll_info), K(type2_ptr->get_type()));
}
} else {
// type2_ptr->is array
ObString child_def;
uint16_t child_subschema_id;
ObExprResType child_type;
ObExprResType coll_calc_type;
if (OB_FAIL(coll_info->get_child_def_string(child_def))) {
LOG_WARN("failed to get type1 child define", K(ret), K(*coll_info));
} else if (OB_FAIL(exec_ctx->get_subschema_id_by_type_string(child_def, child_subschema_id))) {
LOG_WARN("failed to get type1 child subschema id", K(ret), K(*coll_info), K(child_def));
} else if (child_subschema_id == type2_ptr->get_subschema_id()) {
// do nothing
} else if (FALSE_IT(child_type.set_collection(child_subschema_id))) {
} else if (OB_FAIL(ObExprResultTypeUtil::get_array_calc_type(exec_ctx, child_type, *type2_ptr, coll_calc_type))) {
LOG_WARN("failed to check array compatibilty", K(ret));
} else {
if (type2_ptr->get_subschema_id() != coll_calc_type.get_subschema_id()) {
type2_ptr->set_calc_meta(coll_calc_type);
}
if (child_type.get_subschema_id() != coll_calc_type.get_subschema_id()) {
ObDataType child_calc_type;
uint16_t type1_calc_id;
child_calc_type.meta_.set_collection(coll_calc_type.get_subschema_id());
if (OB_FAIL(ObArrayExprUtils::deduce_nested_array_subschema_id(exec_ctx, child_calc_type, type1_calc_id))) {
LOG_WARN("failed to deduce nested array subschema id", K(ret));
} else {
coll_calc_type.set_collection(type1_calc_id);
type1_ptr->set_calc_meta(coll_calc_type);
}
}
}
}
if (OB_SUCC(ret)) {
type.set_int32();
type.set_scale(common::ObAccuracy::DDL_DEFAULT_ACCURACY[common::ObIntType].scale_);
type.set_precision(common::ObAccuracy::DDL_DEFAULT_ACCURACY[common::ObIntType].precision_);
}
return ret;
}
#define EVAL_FUNC_ARRAY_CONTAINS(TYPE, GET_FUNC) \
int ObExprArrayContains::eval_array_contains_##TYPE(const ObExpr &expr, ObEvalCtx &ctx, ObDatum &res) \
{ \
int ret = OB_SUCCESS; \
ObEvalCtx::TempAllocGuard tmp_alloc_g(ctx); \
common::ObArenaAllocator &tmp_allocator = tmp_alloc_g.get_allocator(); \
uint32_t p0 = expr.extra_ == 1 ? 1 : 0; \
uint32_t p1 = expr.extra_ == 1 ? 0 : 1; \
const uint16_t meta_id = expr.args_[p0]->obj_meta_.get_subschema_id(); \
ObIArrayType *arr_obj = NULL; \
ObDatum *datum = NULL; \
ObDatum *datum_val = NULL; \
TYPE val; \
bool bret = false; \
if (OB_FAIL(expr.args_[p0]->eval(ctx, datum))) { \
LOG_WARN("failed to eval args", K(ret)); \
} else if (OB_FAIL(expr.args_[p1]->eval(ctx, datum_val))) { \
LOG_WARN("failed to eval args", K(ret)); \
} else if (datum->is_null()) { \
res.set_null(); \
} else if (OB_FAIL(ObArrayExprUtils::get_array_obj(tmp_allocator, ctx, meta_id, datum->get_string(), arr_obj))) { \
LOG_WARN("construct array obj failed", K(ret)); \
} else if (datum_val->is_null()) { \
bool contains_null = arr_obj->contain_null(); \
res.set_bool(contains_null); \
} else if (FALSE_IT(val = datum_val->GET_FUNC())) { \
} else if (OB_FAIL(ObArrayUtil::contains(*arr_obj, val, bret))) { \
LOG_WARN("array contains failed", K(ret)); \
} else { \
res.set_bool(bret); \
} \
return ret; \
}
EVAL_FUNC_ARRAY_CONTAINS(int64_t, get_int)
EVAL_FUNC_ARRAY_CONTAINS(float, get_float)
EVAL_FUNC_ARRAY_CONTAINS(double, get_double)
EVAL_FUNC_ARRAY_CONTAINS(ObString, get_string)
int ObExprArrayContains::eval_array_contains_array(const ObExpr &expr, ObEvalCtx &ctx, ObDatum &res)
{
int ret = OB_SUCCESS;
ObEvalCtx::TempAllocGuard tmp_alloc_g(ctx);
common::ObArenaAllocator &tmp_allocator = tmp_alloc_g.get_allocator();
uint32_t p0 = expr.extra_ == 1 ? 1 : 0;
uint32_t p1 = expr.extra_ == 1 ? 0 : 1;
const uint16_t l_meta_id = expr.args_[p0]->obj_meta_.get_subschema_id();
const uint16_t r_meta_id = expr.args_[p1]->obj_meta_.get_subschema_id();
ObIArrayType *arr_obj = NULL;
ObIArrayType *arr_val = NULL;
ObDatum *datum = NULL;
ObDatum *datum_val = NULL;
bool bret = false;
if (OB_FAIL(expr.args_[p0]->eval(ctx, datum))) {
LOG_WARN("failed to eval args", K(ret));
} else if (OB_FAIL(expr.args_[p1]->eval(ctx, datum_val))) {
LOG_WARN("failed to eval args", K(ret));
} else if (datum->is_null()) {
res.set_null();
} else if (OB_FAIL(ObArrayExprUtils::get_array_obj(tmp_allocator, ctx, l_meta_id, datum->get_string(), arr_obj))) {
LOG_WARN("construct array obj failed", K(ret));
} else if (datum_val->is_null()) {
bool contains_null = arr_obj->contain_null();
res.set_bool(contains_null);
} else if (OB_FAIL(ObArrayExprUtils::get_array_obj(tmp_allocator, ctx, r_meta_id, datum_val->get_string(), arr_val))) {
LOG_WARN("construct array obj failed", K(ret));
} else if (OB_FAIL(ObArrayUtil::contains(*arr_obj, *arr_val, bret))) {
LOG_WARN("array contains failed", K(ret));
} else {
res.set_bool(bret);
}
return ret;
}
#define EVAL_FUNC_ARRAY_CONTAINS_BATCH(TYPE, GET_FUNC) \
int ObExprArrayContains::eval_array_contains_batch_##TYPE( \
const ObExpr &expr, ObEvalCtx &ctx, const ObBitVector &skip, const int64_t batch_size) \
{ \
int ret = OB_SUCCESS; \
ObDatumVector res_datum = expr.locate_expr_datumvector(ctx); \
ObBitVector &eval_flags = expr.get_evaluated_flags(ctx); \
ObEvalCtx::TempAllocGuard tmp_alloc_g(ctx); \
common::ObArenaAllocator &tmp_allocator = tmp_alloc_g.get_allocator(); \
uint32_t p0 = expr.extra_ == 1 ? 1 : 0; \
uint32_t p1 = expr.extra_ == 1 ? 0 : 1; \
const uint16_t meta_id = expr.args_[p0]->obj_meta_.get_subschema_id(); \
ObIArrayType *arr_obj = NULL; \
if (OB_FAIL(expr.args_[p0]->eval_batch(ctx, skip, batch_size))) { \
LOG_WARN("eval date_unit_datum failed", K(ret)); \
} else if (OB_FAIL(expr.args_[p1]->eval_batch(ctx, skip, batch_size))) { \
LOG_WARN("failed to eval batch result args0", K(ret)); \
} else { \
ObDatumVector src_array = expr.args_[p0]->locate_expr_datumvector(ctx); \
ObDatumVector val_array = expr.args_[p1]->locate_expr_datumvector(ctx); \
for (int64_t j = 0; OB_SUCC(ret) && j < batch_size; ++j) { \
if (skip.at(j) || eval_flags.at(j)) { \
continue; \
} \
eval_flags.set(j); \
bool bret = false; \
TYPE val; \
if (src_array.at(j)->is_null()) { \
res_datum.at(j)->set_null(); \
} else if (OB_FAIL(ObArrayExprUtils::get_array_obj( \
tmp_allocator, ctx, meta_id, src_array.at(j)->get_string(), arr_obj))) { \
LOG_WARN("construct array obj failed", K(ret)); \
} else if (val_array.at(j)->is_null()) { \
bool contains_null = arr_obj->contain_null(); \
res_datum.at(j)->set_bool(contains_null); \
} else if (FALSE_IT(val = val_array.at(j)->GET_FUNC())) { \
} else if (OB_FAIL(ObArrayUtil::contains(*arr_obj, val, bret))) { \
LOG_WARN("array contains failed", K(ret)); \
} else { \
res_datum.at(j)->set_bool(bret); \
} \
} \
} \
return ret; \
}
EVAL_FUNC_ARRAY_CONTAINS_BATCH(int64_t, get_int)
EVAL_FUNC_ARRAY_CONTAINS_BATCH(float, get_float)
EVAL_FUNC_ARRAY_CONTAINS_BATCH(double, get_double)
EVAL_FUNC_ARRAY_CONTAINS_BATCH(ObString, get_string)
int ObExprArrayContains::eval_array_contains_array_batch(const ObExpr &expr, ObEvalCtx &ctx, const ObBitVector &skip, const int64_t batch_size)
{
int ret = OB_SUCCESS;
ObDatumVector res_datum = expr.locate_expr_datumvector(ctx);
ObBitVector &eval_flags = expr.get_evaluated_flags(ctx);
ObEvalCtx::TempAllocGuard tmp_alloc_g(ctx);
common::ObArenaAllocator &tmp_allocator = tmp_alloc_g.get_allocator();
uint32_t p0 = expr.extra_ == 1 ? 1 : 0;
uint32_t p1 = expr.extra_ == 1 ? 0 : 1;
const uint16_t l_meta_id = expr.args_[p0]->obj_meta_.get_subschema_id();
const uint16_t r_meta_id = expr.args_[p1]->obj_meta_.get_subschema_id();
ObIArrayType *arr_obj = NULL;
ObIArrayType *arr_val = NULL;
if (OB_FAIL(expr.args_[p0]->eval_batch(ctx, skip, batch_size))) {
LOG_WARN("eval date_unit_datum failed", K(ret));
} else if (OB_FAIL(expr.args_[p1]->eval_batch(ctx, skip, batch_size))) {
LOG_WARN("failed to eval batch result args0", K(ret));
} else {
ObDatumVector src_array = expr.args_[p0]->locate_expr_datumvector(ctx);
ObDatumVector val_array = expr.args_[p1]->locate_expr_datumvector(ctx);
for (int64_t j = 0; OB_SUCC(ret) && j < batch_size; ++j) {
if (skip.at(j) || eval_flags.at(j)) {
continue;
}
eval_flags.set(j);
bool bret = false;
if (src_array.at(j)->is_null()) {
res_datum.at(j)->set_null();
} else if (OB_FAIL(
ObArrayExprUtils::get_array_obj(tmp_allocator, ctx, l_meta_id, src_array.at(j)->get_string(), arr_obj))) {
LOG_WARN("construct array obj failed", K(ret));
} else if (val_array.at(j)->is_null()) {
bool contains_null = arr_obj->contain_null();
res_datum.at(j)->set_bool(contains_null);
} else if (OB_FAIL(ObArrayExprUtils::get_array_obj(
tmp_allocator, ctx, r_meta_id, val_array.at(j)->get_string(), arr_val))) {
LOG_WARN("construct array obj failed", K(ret));
} else if (OB_FAIL(ObArrayUtil::contains(*arr_obj, *arr_val, bret))) {
LOG_WARN("array contains failed", K(ret));
} else {
res_datum.at(j)->set_bool(bret);
}
}
}
return ret;
}
#define EVAL_FUNC_ARRAY_CONTAINS_VECTOR(TYPE, GET_FUNC) \
int ObExprArrayContains::eval_array_contains_vector_##TYPE( \
const ObExpr &expr, ObEvalCtx &ctx, const ObBitVector &skip, const EvalBound &bound) \
{ \
int ret = OB_SUCCESS; \
uint32_t p0 = expr.extra_ == 1 ? 1 : 0; \
uint32_t p1 = expr.extra_ == 1 ? 0 : 1; \
if (OB_FAIL(expr.args_[p0]->eval_vector(ctx, skip, bound)) || \
OB_FAIL(expr.args_[p1]->eval_vector(ctx, skip, bound))) { \
LOG_WARN("fail to eval params", K(ret)); \
} else { \
ObEvalCtx::TempAllocGuard tmp_alloc_g(ctx); \
common::ObArenaAllocator &tmp_allocator = tmp_alloc_g.get_allocator(); \
ObIVector *left_vec = expr.args_[p0]->get_vector(ctx); \
VectorFormat left_format = left_vec->get_format(); \
ObIVector *right_vec = expr.args_[p1]->get_vector(ctx); \
const uint16_t meta_id = expr.args_[p0]->obj_meta_.get_subschema_id(); \
ObIVector *res_vec = expr.get_vector(ctx); \
ObBitVector &eval_flags = expr.get_evaluated_flags(ctx); \
ObIArrayType *arr_obj = NULL; \
TYPE val; \
for (int64_t idx = bound.start(); OB_SUCC(ret) && idx < bound.end(); ++idx) { \
bool is_null_res = false; \
if (skip.at(idx) || eval_flags.at(idx)) { \
continue; \
} else if (left_vec->is_null(idx)) { \
is_null_res = true; \
} else if (left_format == VEC_UNIFORM || left_format == VEC_UNIFORM_CONST) { \
ObString left = left_vec->get_string(idx); \
if (OB_FAIL(ObNestedVectorFunc::construct_param(tmp_allocator, ctx, meta_id, left, arr_obj))) { \
LOG_WARN("construct array obj failed", K(ret)); \
} \
} else if (OB_FAIL(ObNestedVectorFunc::construct_attr_param( \
tmp_allocator, ctx, *expr.args_[p0], meta_id, idx, arr_obj))) { \
LOG_WARN("construct array obj failed", K(ret)); \
} \
bool bret = false; \
if (OB_FAIL(ret)) { \
} else if (is_null_res) { \
res_vec->set_null(idx); \
eval_flags.set(idx); \
} else if (right_vec->is_null(idx)) { \
bool contains_null = arr_obj->contain_null(); \
res_vec->set_bool(idx, contains_null); \
eval_flags.set(idx); \
} else if (FALSE_IT(val = right_vec->GET_FUNC(idx))) { \
} else if (OB_FAIL(ObArrayUtil::contains(*arr_obj, val, bret))) { \
LOG_WARN("array contains failed", K(ret)); \
} else { \
res_vec->set_bool(idx, bret); \
eval_flags.set(idx); \
} \
} \
} \
return ret; \
}
EVAL_FUNC_ARRAY_CONTAINS_VECTOR(int64_t, get_int)
EVAL_FUNC_ARRAY_CONTAINS_VECTOR(float, get_float)
EVAL_FUNC_ARRAY_CONTAINS_VECTOR(double, get_double)
EVAL_FUNC_ARRAY_CONTAINS_VECTOR(ObString, get_string)
int ObExprArrayContains::eval_array_contains_array_vector(const ObExpr &expr, ObEvalCtx &ctx,
const ObBitVector &skip, const EvalBound &bound)
{
int ret = OB_SUCCESS;
uint32_t p0 = expr.extra_ == 1 ? 1 : 0;
uint32_t p1 = expr.extra_ == 1 ? 0 : 1;
if (OB_FAIL(expr.args_[p0]->eval_vector(ctx, skip, bound)) || OB_FAIL(expr.args_[p1]->eval_vector(ctx, skip, bound))) {
LOG_WARN("fail to eval params", K(ret));
} else {
ObEvalCtx::TempAllocGuard tmp_alloc_g(ctx);
common::ObArenaAllocator &tmp_allocator = tmp_alloc_g.get_allocator();
ObIVector *left_vec = expr.args_[p0]->get_vector(ctx);
VectorFormat left_format = left_vec->get_format();
ObIVector *right_vec = expr.args_[p1]->get_vector(ctx);
VectorFormat right_format = right_vec->get_format();
const uint16_t left_meta_id = expr.args_[p0]->obj_meta_.get_subschema_id();
const uint16_t right_meta_id = expr.args_[p1]->obj_meta_.get_subschema_id();
ObIVector *res_vec = expr.get_vector(ctx);
ObBitVector &eval_flags = expr.get_evaluated_flags(ctx);
ObIArrayType *arr_obj = NULL;
ObIArrayType *arr_val = NULL;
for (int64_t idx = bound.start(); OB_SUCC(ret) && idx < bound.end(); ++idx) {
bool is_null_res = false;
if (skip.at(idx) || eval_flags.at(idx)) {
continue;
} else if (left_vec->is_null(idx)) {
is_null_res = true;
} else if (left_format == VEC_UNIFORM || left_format == VEC_UNIFORM_CONST) {
ObString left = left_vec->get_string(idx);
if (OB_FAIL(ObNestedVectorFunc::construct_param(tmp_allocator, ctx, left_meta_id, left, arr_obj))) {
LOG_WARN("construct array obj failed", K(ret));
}
} else if (OB_FAIL(ObNestedVectorFunc::construct_attr_param(
tmp_allocator, ctx, *expr.args_[p0], left_meta_id, idx, arr_obj))) {
LOG_WARN("construct array obj failed", K(ret));
}
if (OB_FAIL(ret)) {
} else if (is_null_res) {
res_vec->set_null(idx);
eval_flags.set(idx);
} else if (right_vec->is_null(idx)) {
bool contains_null = arr_obj->contain_null();
res_vec->set_bool(idx, contains_null);
eval_flags.set(idx);
} else if (right_format == VEC_UNIFORM || right_format == VEC_UNIFORM_CONST) {
ObString right = right_vec->get_string(idx);
if (OB_FAIL(ObNestedVectorFunc::construct_param(tmp_allocator, ctx, right_meta_id, right, arr_val))) {
LOG_WARN("construct array obj failed", K(ret));
}
} else if (OB_FAIL(ObNestedVectorFunc::construct_attr_param(
tmp_allocator, ctx, *expr.args_[p1], right_meta_id, idx, arr_val))) {
LOG_WARN("construct array obj failed", K(ret));
}
bool bret = false;
if (OB_FAIL(ret)) {
} else if (OB_FAIL(ObArrayUtil::contains(*arr_obj, *arr_val, bret))) {
LOG_WARN("array contains failed", K(ret));
} else {
res_vec->set_bool(idx, bret);
eval_flags.set(idx);
}
}
}
return ret;
}
int ObExprArrayContains::cg_expr(ObExprCGCtx &expr_cg_ctx,
const ObRawExpr &raw_expr,
ObExpr &rt_expr) const
{
int ret = OB_SUCCESS;
UNUSED(raw_expr);
if (rt_expr.arg_cnt_ != 2 || OB_ISNULL(rt_expr.args_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("count of children is not 2 or children is null", K(ret), K(rt_expr.arg_cnt_),
K(rt_expr.args_));
} else if (OB_ISNULL(rt_expr.args_[0]) || OB_ISNULL(rt_expr.args_[1])) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("child is null", K(ret), K(rt_expr.args_[0]), K(rt_expr.args_[1]));
} else {
rt_expr.eval_func_ = NULL;
rt_expr.may_not_need_raw_check_ = false;
rt_expr.extra_ = raw_expr.get_extra();
uint32_t p1 = rt_expr.extra_ == 1 ? 0 : 1;
uint32_t p0 = rt_expr.extra_ == 1 ? 1 : 0;
const ObObjType right_type = rt_expr.args_[p1]->datum_meta_.type_;
ObObjTypeClass right_tc = ob_obj_type_class(right_type);
if (right_tc == ObNullTC) {
// use array element type
ObExecContext *exec_ctx = expr_cg_ctx.session_->get_cur_exec_ctx();
const uint16_t sub_id = rt_expr.args_[p0]->obj_meta_.get_subschema_id();
ObObjType elem_type;
uint32_t unused;
bool is_vec = false;
if (OB_FAIL(ObArrayExprUtils::get_array_element_type(exec_ctx, sub_id, elem_type, unused, is_vec))) {
LOG_WARN("failed to get collection elem type", K(ret), K(sub_id));
} else {
right_tc = ob_obj_type_class(elem_type);
}
}
if OB_SUCC(ret) {
switch (right_tc) {
case ObIntTC:
rt_expr.eval_func_ = eval_array_contains_int64_t;
rt_expr.eval_batch_func_ = eval_array_contains_batch_int64_t;
rt_expr.eval_vector_func_ = eval_array_contains_vector_int64_t;
break;
case ObFloatTC:
rt_expr.eval_func_ = eval_array_contains_float;
rt_expr.eval_batch_func_ = eval_array_contains_batch_float;
rt_expr.eval_vector_func_ = eval_array_contains_vector_float;
break;
case ObDoubleTC:
rt_expr.eval_func_ = eval_array_contains_double;
rt_expr.eval_batch_func_ = eval_array_contains_batch_double;
rt_expr.eval_vector_func_ = eval_array_contains_vector_double;
break;
case ObStringTC:
rt_expr.eval_func_ = eval_array_contains_ObString;
rt_expr.eval_batch_func_ = eval_array_contains_batch_ObString;
rt_expr.eval_vector_func_ = eval_array_contains_vector_ObString;
break;
case ObNullTC:
case ObCollectionSQLTC:
rt_expr.eval_func_ = eval_array_contains_array;
rt_expr.eval_batch_func_ = eval_array_contains_array_batch;
rt_expr.eval_vector_func_ = eval_array_contains_array_vector;
break;
default :
ret = OB_ERR_INVALID_TYPE_FOR_OP;
LOG_WARN("invalid type", K(ret), K(right_type));
}
}
}
return OB_SUCCESS;
}
} // namespace sql
} // namespace oceanbase
Reference in New Issue View Git Blame Copy Permalink