522 lines
18 KiB
C++
522 lines
18 KiB
C++
/**
|
|
* 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_coll_pred.h"
|
|
#include "sql/engine/ob_physical_plan_ctx.h"
|
|
#include "sql/engine/ob_exec_context.h"
|
|
#include "lib/hash/ob_hashmap.h"
|
|
#include "pl/ob_pl_user_type.h"
|
|
#include "pl/ob_pl_allocator.h"
|
|
#include "lib/utility/utility.h"
|
|
#include "share/object/ob_obj_cast.h"
|
|
|
|
namespace oceanbase
|
|
{
|
|
using namespace common;
|
|
namespace sql
|
|
{
|
|
OB_SERIALIZE_MEMBER((ObExprCollPred, ObExprOperator),
|
|
ms_type_,
|
|
ms_modifier_);
|
|
|
|
typedef hash::ObHashMap<ObObj, int64_t, common::hash::NoPthreadDefendMode> LocalNTSHashMap;
|
|
|
|
ObExprCollPred::ObExprCollPred(ObIAllocator &alloc)
|
|
: ObExprOperator(alloc, T_OP_COLL_PRED, N_COLL_PRED, 2, NOT_VALID_FOR_GENERATED_COL, NOT_ROW_DIMENSION),
|
|
ms_type_(ObMultiSetType::MULTISET_TYPE_INVALID),
|
|
ms_modifier_(ObMultiSetModifier::MULTISET_MODIFIER_INVALID)
|
|
{
|
|
}
|
|
|
|
ObExprCollPred::~ObExprCollPred()
|
|
{
|
|
}
|
|
|
|
void ObExprCollPred::reset()
|
|
{
|
|
ms_type_ = ObMultiSetType::MULTISET_TYPE_INVALID;
|
|
ms_modifier_ = ObMultiSetModifier::MULTISET_MODIFIER_INVALID;
|
|
ObExprOperator::reset();
|
|
}
|
|
|
|
int ObExprCollPred::assign(const ObExprOperator &other)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
if (other.get_type() != T_OP_COLL_PRED) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("expr operator is mismatch", K(other.get_type()));
|
|
} else if (OB_FAIL(ObExprOperator::assign(other))) {
|
|
LOG_WARN("assign parent expr failed", K(ret));
|
|
} else {
|
|
const ObExprCollPred &other_expr = static_cast<const ObExprCollPred &>(other);
|
|
ms_type_ = other_expr.ms_type_;
|
|
ms_modifier_ = other_expr.ms_modifier_;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObExprCollPred::calc_result_type2(ObExprResType &type,
|
|
ObExprResType &type1,
|
|
ObExprResType &type2,
|
|
ObExprTypeCtx &type_ctx) const
|
|
{
|
|
UNUSED(type_ctx);
|
|
int ret = OB_SUCCESS;
|
|
if (lib::is_oracle_mode()) {
|
|
type.set_type(ObTinyIntType);
|
|
type.set_precision(DEFAULT_PRECISION_FOR_BOOL);
|
|
type.set_scale(DEFAULT_SCALE_FOR_INTEGER);
|
|
} else {
|
|
ret = OB_NOT_SUPPORTED;
|
|
LOG_WARN("multiset operator not support non udt type", K(type1), K(type2), K(ret));
|
|
LOG_USER_ERROR(OB_NOT_SUPPORTED, "multiset operator non udt type");
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
#define FILL_HASH_MAP(map_name, coll, map_cnt) \
|
|
do { \
|
|
if (OB_FAIL(map_name.create(coll->get_actual_count(), ObModIds::OB_SQL_HASH_SET))) { \
|
|
LOG_WARN("fail create hash map", K(coll->get_actual_count()), K(ret)); \
|
|
} else { \
|
|
const ObObj *elem = NULL; \
|
|
bool is_del = false; \
|
|
ObObj *data_arr = static_cast<ObObj*>(coll->get_data()); \
|
|
for (int64_t i = 0; OB_SUCC(ret) && i < coll->get_count(); ++i) {\
|
|
if (OB_FAIL(coll->is_elem_deleted(i, is_del))) { \
|
|
LOG_WARN("failed to check is collection elem deleted", K(ret)); \
|
|
} else if (!is_del) { \
|
|
elem = data_arr + i;\
|
|
ret = map_name.set_refactored(*elem, i);\
|
|
if (OB_HASH_EXIST == ret) {\
|
|
ret = OB_SUCCESS;\
|
|
continue;\
|
|
} else if (OB_SUCC(ret)) {\
|
|
map_cnt++;\
|
|
} else {\
|
|
LOG_WARN("insert elem into hashmap failed.", K(ret));\
|
|
}\
|
|
} \
|
|
}\
|
|
}\
|
|
} while(0)
|
|
|
|
int ObExprCollPred::compare_obj(const ObObj &obj1, const ObObj &obj2, ObCompareCtx &cmp_ctx) {
|
|
UNUSED(cmp_ctx);
|
|
return obj1 == obj2 ? 0 : 1;
|
|
}
|
|
|
|
int ObExprCollPred::calc_collection_is_contained_without_null(const pl::ObPLCollection *c1,
|
|
const pl::ObPLCollection *c2,
|
|
int64_t tz_offset,
|
|
const ObExprCalcType calc_type,
|
|
CollectionPredRes &result)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
obj_cmp_func lt_cmp_fp;
|
|
const ObObjType type1 = c1->get_element_type().get_obj_type();
|
|
const ObObjType type2 = c2->get_element_type().get_obj_type();
|
|
ObObjTypeClass tc1 = ob_obj_type_class(type1);
|
|
ObObjTypeClass tc2 = ob_obj_type_class(type2);
|
|
if (OB_FAIL(ObObjCmpFuncs::get_cmp_func(tc1, tc2, CO_LT, lt_cmp_fp))) {
|
|
LOG_WARN("get cmp func failed", K(type1), K(type2), K(tc1), K(tc2), K(ret));
|
|
} else {
|
|
ObCompareCtx cmp_ctx(calc_type.get_type(),
|
|
calc_type.get_collation_type(),
|
|
false,
|
|
tz_offset,
|
|
default_null_pos());
|
|
struct udtComparer{
|
|
udtComparer(ObCompareCtx &cmp_ctx, common::obj_cmp_func cmp_func) :
|
|
cmp_ctx_(cmp_ctx),
|
|
cmp_func_(cmp_func) {}
|
|
|
|
bool operator()(const ObObj *&e1, const ObObj *&e2) {
|
|
int cmpRes = cmp_func_(*e1, *e2, cmp_ctx_);
|
|
return cmpRes;
|
|
}
|
|
ObCompareCtx &cmp_ctx_;
|
|
common::obj_cmp_func cmp_func_;
|
|
};
|
|
udtComparer uc(cmp_ctx, lt_cmp_fp);
|
|
common::ObArray<const ObObj *> c1_copy, c2_copy;
|
|
bool del_flag = false;
|
|
for (int64_t i = 0; OB_SUCC(ret) && i < c1->get_count(); ++i) {
|
|
const ObObj *elem = reinterpret_cast<const ObObj*>(c1->get_data()) + i;
|
|
CK (OB_NOT_NULL(elem));
|
|
if (OB_SUCC(ret)) {
|
|
if (elem->is_null()) {
|
|
} else if (c1->is_elem_deleted(i, del_flag)) {
|
|
LOG_WARN("failed to test if element is deleted", K(*elem), K(ret), K(i));
|
|
} else {
|
|
if (!del_flag) {
|
|
OZ (c1_copy.push_back(elem));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for (int64_t i = 0; OB_SUCC(ret) && i < c2->get_count(); ++i) {
|
|
const ObObj *elem = reinterpret_cast<const ObObj*>(c2->get_data()) + i;
|
|
CK (OB_NOT_NULL(elem));
|
|
if (OB_SUCC(ret)) {
|
|
if (elem->is_null()) {
|
|
} else if (c2->is_elem_deleted(i, del_flag)) {
|
|
LOG_WARN("failed to test if element is deleted", K(*elem), K(ret), K(i));
|
|
} else {
|
|
if (!del_flag) {
|
|
OZ (c2_copy.push_back(elem));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
int64_t c1_cnt = c1_copy.count();
|
|
int64_t c2_cnt = c2_copy.count();
|
|
if (c1_cnt > 0 && c2_cnt > 0) {
|
|
result = COLL_PRED_TRUE;
|
|
if (c1_cnt > c2_cnt) {
|
|
result = COLL_PRED_FALSE;
|
|
} else {
|
|
const ObObj **first = &c1_copy.at(0);
|
|
std::sort(first, first + c1_cnt, uc);
|
|
first = &c2_copy.at(0);
|
|
std::sort(first, first + c2_cnt, uc);
|
|
for (int64_t i = 0; OB_SUCC(ret) && i < c1_copy.count(); ++i) {
|
|
if (0 != compare_obj(*(c1_copy.at(i)), *(c2_copy.at(i)), cmp_ctx)) {
|
|
result = COLL_PRED_FALSE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
if (0 == c1_cnt && 0 == c2_cnt) {
|
|
result = COLL_PRED_BOTH_COLL_ZERO;
|
|
} else if (0 == c1_cnt) {
|
|
result = COLL_PRED_FIRST_COLL_ZERO;
|
|
} else if (0 == c2_cnt) {
|
|
result = COLL_PRED_SECOND_COLL_ZERO;
|
|
}
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int ObExprCollPred::calc_is_submultiset(const ObObj &obj1,
|
|
const ObObj &obj2,
|
|
int64_t tz_offset,
|
|
const ObExprCalcType calc_type,
|
|
CollectionPredRes &result)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
result = COLL_PRED_FALSE;
|
|
if (obj1.get_meta().is_ext() && obj2.get_meta().is_ext()) {
|
|
pl::ObPLCollection *c1 = reinterpret_cast<pl::ObPLCollection *>(obj1.get_ext());
|
|
pl::ObPLCollection *c2 = reinterpret_cast<pl::ObPLCollection *>(obj2.get_ext());
|
|
int64_t c1_cnt = c1->get_actual_count();
|
|
int64_t c2_cnt = c2->get_actual_count();
|
|
// 1) return true when:
|
|
// 1. obj1 is not null and contains no row, return true whatever obj2 is.
|
|
// for example obj nest_type := nest_type();
|
|
// 2. obj1 and obj2 not null, obj1 does not contain any null element, obj1 elem one-to-one
|
|
// mapping to obj2 element.
|
|
|
|
// 2) return null when:
|
|
// 1. obj1 is null
|
|
// 2. obj2 is null, and obj1 is not null and not empty.
|
|
// 3. obj1 contain null element, and any non null is element is one-to-one mapping to obj2 elem
|
|
// for example: nt1(1,2,3,4,5), nt2(1,2,NULL), nt3(1,7,null); nt2 submultiset of nt1 => null
|
|
// nt3 submultiset nt1 => false
|
|
|
|
// 3) return false when:
|
|
// if none of above conditions occur, return false;
|
|
if (OB_ISNULL(c1) || OB_ISNULL(c2)) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("union udt failed due to null udt", K(ret), K(obj1), K(obj2));
|
|
} else if (pl::PL_NESTED_TABLE_TYPE != c1->get_type()
|
|
|| pl::PL_NESTED_TABLE_TYPE != c2->get_type()) {
|
|
ret = OB_NOT_SUPPORTED;
|
|
LOG_WARN("not support udt union except nested table", K(ret), K(c1), K(c2));
|
|
LOG_USER_ERROR(OB_NOT_SUPPORTED, "udt union except nested table");
|
|
} else if ((c1->get_element_type().get_obj_type() != c2->get_element_type().get_obj_type())) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("udt union failed due to uninited", K(ret));
|
|
} else if (0 == c1_cnt && (c1->is_inited())) {
|
|
result = COLL_PRED_TRUE;
|
|
} else if (!c1->is_inited()) {
|
|
result = COLL_PRED_NULL; // null
|
|
} else if (!c2->is_inited()) {
|
|
result = COLL_PRED_NULL;
|
|
} else if (c1_cnt > c2_cnt) {
|
|
result = COLL_PRED_FALSE;
|
|
} else if (calc_collection_is_contained_without_null(c1, c2, tz_offset, calc_type, result)) {
|
|
LOG_WARN("faile to calc multiset without null and delete val", K(ret));
|
|
} else {
|
|
// 去除了null和delete数据之后比较，如果是包含关系，但是c1含有null，置结果为null.
|
|
if (COLL_PRED_TRUE == result && c1->is_contain_null_val()) {
|
|
result = COLL_PRED_NULL;
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
OB_DEF_SERIALIZE(ObExprCollPredInfo)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
LST_DO_CODE(OB_UNIS_ENCODE,
|
|
ms_type_,
|
|
ms_modifier_,
|
|
tz_offset_,
|
|
result_type_);
|
|
return ret;
|
|
}
|
|
|
|
OB_DEF_DESERIALIZE(ObExprCollPredInfo)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
LST_DO_CODE(OB_UNIS_DECODE,
|
|
ms_type_,
|
|
ms_modifier_,
|
|
tz_offset_,
|
|
result_type_);
|
|
return ret;
|
|
}
|
|
|
|
OB_DEF_SERIALIZE_SIZE(ObExprCollPredInfo)
|
|
{
|
|
int64_t len = 0;
|
|
LST_DO_CODE(OB_UNIS_ADD_LEN,
|
|
ms_type_,
|
|
ms_modifier_,
|
|
tz_offset_,
|
|
result_type_);
|
|
return len;
|
|
}
|
|
|
|
int ObExprCollPredInfo::deep_copy(common::ObIAllocator &allocator,
|
|
const ObExprOperatorType type,
|
|
ObIExprExtraInfo *&copied_info) const
|
|
{
|
|
int ret = common::OB_SUCCESS;
|
|
OZ(ObExprExtraInfoFactory::alloc(allocator, type, copied_info));
|
|
ObExprCollPredInfo &other = *static_cast<ObExprCollPredInfo *>(copied_info);
|
|
other.ms_type_ = ms_type_;
|
|
other.ms_modifier_ = ms_modifier_;
|
|
other.tz_offset_ = tz_offset_;
|
|
other.result_type_ = result_type_;
|
|
return ret;
|
|
}
|
|
|
|
template <typename RE>
|
|
int ObExprCollPredInfo::from_raw_expr(RE &raw_expr)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
ObCollPredRawExpr &set_expr
|
|
= const_cast<ObCollPredRawExpr &> (static_cast<const ObCollPredRawExpr&>(raw_expr));
|
|
ms_type_ = set_expr.get_multiset_type();
|
|
ms_modifier_ = set_expr.get_multiset_modifier();
|
|
return ret;
|
|
}
|
|
|
|
int ObExprCollPred::cg_expr(ObExprCGCtx &expr_cg_ctx,
|
|
const ObRawExpr &raw_expr,
|
|
ObExpr &rt_expr) const
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
if (2 != rt_expr.arg_cnt_) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("wrong param num for coll pred", K(ret), K(rt_expr.arg_cnt_));
|
|
} else if (OB_ISNULL(expr_cg_ctx.session_)) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("session info is nullptr", K(ret));
|
|
} else {
|
|
ObIAllocator &alloc = *expr_cg_ctx.allocator_;
|
|
const ObCollPredRawExpr &fun_sys = static_cast<const ObCollPredRawExpr &>(raw_expr);
|
|
ObExprCollPredInfo *info = OB_NEWx(ObExprCollPredInfo, (&alloc), alloc, T_OP_COLL_PRED);
|
|
if (NULL == info) {
|
|
ret = OB_ALLOCATE_MEMORY_FAILED;
|
|
LOG_WARN("allocate memory failed", K(ret));
|
|
} else {
|
|
OZ(info->from_raw_expr(fun_sys));
|
|
const ObTimeZoneInfo *tz_info = get_timezone_info(expr_cg_ctx.session_);
|
|
int64_t tz_offset = 0;
|
|
if (OB_FAIL(get_tz_offset(tz_info, tz_offset))) {
|
|
LOG_WARN("failed to get tz offset", K(ret));
|
|
} else {
|
|
info->tz_offset_ = tz_offset;
|
|
info->result_type_ = result_type_;
|
|
rt_expr.extra_info_ = info;
|
|
rt_expr.eval_func_ = eval_coll_pred;
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObExprCollPred::eval_coll_pred(const ObExpr &expr, ObEvalCtx &ctx, ObDatum &res)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
ObDatum *datum1 = nullptr;
|
|
ObDatum *datum2 = nullptr;
|
|
ObObj result;
|
|
ObObj obj1;
|
|
ObObj obj2;
|
|
const ObExprCollPredInfo *info = static_cast<ObExprCollPredInfo *>(expr.extra_info_);
|
|
if (OB_FAIL(expr.eval_param_value(ctx, datum1, datum2))) {
|
|
LOG_WARN("failed to eval params", K(ret));
|
|
} else if (lib::is_oracle_mode()) {
|
|
if (OB_FAIL(datum1->to_obj(obj1, expr.args_[0]->obj_meta_))) {
|
|
LOG_WARN("failed to convert to obj", K(ret));
|
|
} else if (OB_FAIL(datum2->to_obj(obj2, expr.args_[1]->obj_meta_))) {
|
|
LOG_WARN("failed to convert to obj", K(ret));
|
|
} else {
|
|
switch (info->ms_type_)
|
|
{
|
|
case MULTISET_TYPE_SUBMULTISET: {
|
|
CollectionPredRes pred_res = COLL_PRED_INVALID;
|
|
if (OB_FAIL(calc_is_submultiset(obj1, obj2, info->tz_offset_,
|
|
info->result_type_.get_calc_meta(), pred_res))) {
|
|
LOG_WARN("failed to call submultiset", K(ret));
|
|
} else {
|
|
if (COLL_PRED_NULL == pred_res) {
|
|
result.set_null();
|
|
} else {
|
|
if (pred_res ^ (MULTISET_MODIFIER_NOT == info->ms_modifier_)) {
|
|
result.set_tinyint(1);
|
|
} else {
|
|
result.set_tinyint(0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case MULTISET_TYPE_MEMBER_OF: {
|
|
if (obj2.get_meta().is_ext()) {
|
|
pl::ObPLCollection *c2 = reinterpret_cast<pl::ObPLCollection *>(obj2.get_ext());
|
|
if (OB_NOT_NULL(c2) && 0 < c2->get_actual_count()) {
|
|
ObObj *elem = static_cast<ObObj*>(c2->get_data());
|
|
ObObj mem_cast;
|
|
const ObObj * res_obj1 = &obj1;
|
|
ObCollationType cast_coll_type = elem->get_collation_type();
|
|
ObCastMode cp_cast_mode;
|
|
if (OB_FAIL(ObSQLUtils::get_default_cast_mode(ctx.exec_ctx_.get_my_session(),
|
|
cp_cast_mode))) {
|
|
LOG_WARN("failed to get default cast mode", K(ret));
|
|
}
|
|
const ObDataTypeCastParams dtc_params
|
|
= ObBasicSessionInfo::create_dtc_params(ctx.exec_ctx_.get_my_session());
|
|
ObCastCtx cast_ctx(&ctx.exec_ctx_.get_allocator(),
|
|
&dtc_params,
|
|
get_cur_time(ctx.exec_ctx_.get_physical_plan_ctx()),
|
|
cp_cast_mode,
|
|
cast_coll_type,
|
|
nullptr);
|
|
if (OB_FAIL(ret)) {
|
|
} else if (OB_FAIL(ObObjCaster::to_type(elem->get_type(), cast_ctx,
|
|
obj1, mem_cast, res_obj1))) {
|
|
LOG_WARN("failed to cast member to collection elem type", K(ret));
|
|
} else {
|
|
LocalNTSHashMap dmap_c;
|
|
int64_t res_cnt = 0;
|
|
FILL_HASH_MAP(dmap_c, c2, res_cnt);
|
|
if (OB_SUCC(ret)) {
|
|
if (OB_NOT_NULL(dmap_c.get(*res_obj1)) ^ (MULTISET_MODIFIER_NOT == info->ms_modifier_)) {
|
|
result.set_tinyint(1);
|
|
} else {
|
|
result.set_tinyint(0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case MULTISET_TYPE_IS_SET: {
|
|
if (obj1.get_meta().is_ext()) {
|
|
pl::ObPLCollection *c1 = reinterpret_cast<pl::ObPLCollection *>(obj1.get_ext());
|
|
if (OB_NOT_NULL(c1)) {
|
|
LocalNTSHashMap dmap_c;
|
|
int64_t count = c1->get_actual_count();
|
|
int res_cnt = 0;
|
|
if (0 == count) {
|
|
// empty nest table is a set
|
|
result.set_tinyint(1);
|
|
} else if (!c1->is_inited()) {
|
|
result.set_null();
|
|
} else {
|
|
FILL_HASH_MAP(dmap_c, c1, res_cnt);
|
|
if (OB_SUCC(ret)) {
|
|
if ((count == res_cnt) ^ (MULTISET_MODIFIER_NOT == info->ms_modifier_)) {
|
|
result.set_tinyint(1);
|
|
} else {
|
|
result.set_tinyint(0);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("get null collection structure", K(ret));
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case MULTISET_TYPE_EMPTY: {
|
|
if (obj1.get_meta().is_ext()) {
|
|
pl::ObPLCollection *c1 = reinterpret_cast<pl::ObPLCollection *>(obj1.get_ext());
|
|
int32_t pred_res = -1;
|
|
if (OB_NOT_NULL(c1)) {
|
|
if (c1->is_nested_table() || c1->is_varray()) {
|
|
if (!c1->is_inited()) {
|
|
result.set_null();
|
|
} else if (0 < c1->get_actual_count()) {
|
|
pred_res = 1;
|
|
} else {
|
|
pred_res = 0;
|
|
}
|
|
} else {
|
|
ret = OB_NOT_SUPPORTED;
|
|
LOG_WARN("not support other type except nest table and varray", K(ret));
|
|
LOG_USER_ERROR(OB_NOT_SUPPORTED, "other type except nest table and varray");
|
|
}
|
|
if (OB_SUCC(ret) && -1 != pred_res) {
|
|
if (pred_res ^ (MULTISET_MODIFIER_NOT == info->ms_modifier_)) {
|
|
result.set_tinyint(0);
|
|
} else {
|
|
result.set_tinyint(1);
|
|
}
|
|
}
|
|
} else {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("get null collection struct", K(ret));
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("unknown collection predicate condition", K(ret));
|
|
break;
|
|
}
|
|
if (OB_SUCC(ret)) {
|
|
OZ(res.from_obj(result, expr.obj_datum_map_));
|
|
OZ(expr.deep_copy_datum(ctx, res));
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
} // namespace sql
|
|
} // namespace oceanbase
|