hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
87f7fda79cf3dc231bbac2fc214c36e68880cea7
oceanbase/src/sql/engine/expr/ob_array_expr_utils.cpp
obdev b6118bde83 [ARRAY] disable set var=array
2024-09-18 08:34:55 +00:00

1196 lines
51 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 ob_array_expr_utils.
*/
#define USING_LOG_PREFIX SQL_ENG
#include "sql/engine/expr/ob_array_expr_utils.h"
#include "sql/engine/expr/ob_expr_result_type_util.h"
using namespace oceanbase::common;
namespace oceanbase
{
namespace sql
{
const char* ObArrayExprUtils::DEFAULT_CAST_TYPE_NAME = "ARRAY(FLOAT)";
const ObString ObArrayExprUtils::DEFAULT_CAST_TYPE_STR = ObString::make_string(DEFAULT_CAST_TYPE_NAME);
int ObArrayExprUtils::get_type_vector(
const ObExpr &expr,
ObEvalCtx &ctx,
ObIAllocator &allocator,
ObIArrayType *&result,
bool &is_null)
{
int ret = OB_SUCCESS;
ObDatum *datum = NULL;
if (OB_FAIL(expr.eval(ctx, datum))) {
LOG_WARN("eval failed", K(ret));
} else if (OB_UNLIKELY(datum->is_null())) {
is_null = true;
} else if (OB_FAIL(get_type_vector(expr, *datum, ctx, allocator, result))) {
LOG_WARN("failed to get vector", K(ret));
}
return ret;
}
// get vector or array(float)
int ObArrayExprUtils::get_type_vector(
const ObExpr &expr,
const ObDatum &datum,
ObEvalCtx &ctx,
ObIAllocator &allocator,
ObIArrayType *&result)
{
int ret = OB_SUCCESS;
ObSubSchemaValue value;
uint16_t subschema_id = expr.obj_meta_.get_subschema_id();
if (!expr.obj_meta_.is_collection_sql_type()) {
ret = OB_NOT_SUPPORTED;
LOG_WARN("not support", K(ret), K(expr.obj_meta_));
} else if (OB_FAIL(ctx.exec_ctx_.get_sqludt_meta_by_subschema_id(subschema_id, value))) {
LOG_WARN("failed to get subschema ctx", K(ret));
} else if (value.type_ >= OB_SUBSCHEMA_MAX_TYPE) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid subschema type", K(ret), K(value));
} else {
ObString blob_data = datum.get_string();
const ObSqlCollectionInfo *coll_info = reinterpret_cast<const ObSqlCollectionInfo *>(value.value_);
ObCollectionArrayType *arr_type = static_cast<ObCollectionArrayType *>(coll_info->collection_meta_);
if (OB_FAIL(ObTextStringHelper::read_real_string_data(&allocator,
ObLongTextType,
CS_TYPE_BINARY,
true,
blob_data))) {
LOG_WARN("fail to get real data.", K(ret), K(blob_data));
} else if (OB_FAIL(ObArrayTypeObjFactory::construct(allocator, *arr_type, result, true))) {
LOG_WARN("construct array obj failed", K(ret), K(*coll_info));
} else if (OB_FAIL(result->init(blob_data))) {
LOG_WARN("failed to init array", K(ret));
}
}
return ret;
}
int ObArrayExprUtils::vector_datum_add(ObDatum &res, const ObDatum &data, ObIAllocator &allocator, bool negative)
{
int ret = OB_SUCCESS;
ObString blob_res = res.get_string();
ObString blob_data = data.get_string();
if (OB_FAIL(ObTextStringHelper::read_real_string_data(&allocator,
ObLongTextType,
CS_TYPE_BINARY,
true,
blob_data))) {
LOG_WARN("fail to get real data.", K(ret), K(blob_data));
} else if (OB_FAIL(ObTextStringHelper::read_real_string_data(&allocator,
ObLongTextType,
CS_TYPE_BINARY,
true,
blob_res))) {
LOG_WARN("fail to get real data.", K(ret), K(blob_data));
} else {
int64_t length = blob_data.length() / sizeof(float);
float *float_data = reinterpret_cast<float *>(blob_data.ptr());
float *float_res = reinterpret_cast<float *>(blob_res.ptr());
for (int64_t i = 0; OB_SUCC(ret) && i < length; ++i) {
negative ? float_res[i] -= float_data[i] : float_res[i] += float_data[i];
if (isinff(float_res[i]) != 0) {
ret = OB_OPERATE_OVERFLOW;
SQL_LOG(WARN, "value overflow", K(ret), K(i), K(float_data[i]), K(float_res[i]));
}
}
}
return ret;
}
// cast any array and varchar to array(float)
int ObArrayExprUtils::calc_cast_type(
ObExprResType &type,
common::ObExprTypeCtx &type_ctx,
const bool only_vector)
{
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();
uint16_t dst_subschema_id = 0;
bool need_cast = false;
if (!type.is_collection_sql_type() && !type.is_string_type() && !type.is_null()) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(ret), K(type));
} else if (type.is_collection_sql_type()) {
ObSubSchemaValue value;
uint16_t src_subschema_id = type.get_subschema_id();
if (OB_FAIL(exec_ctx->get_sqludt_meta_by_subschema_id(src_subschema_id, value))) {
LOG_WARN("failed to get subschema ctx", K(ret));
} else if (value.type_ >= OB_SUBSCHEMA_MAX_TYPE) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid subschema type", K(ret), K(value));
} else {
const ObSqlCollectionInfo *coll_info = NULL;
coll_info = reinterpret_cast<const ObSqlCollectionInfo *>(value.value_);
if (coll_info->collection_meta_->type_id_ == ObNestedType::OB_ARRAY_TYPE) {
ObCollectionArrayType *arr_type = static_cast<ObCollectionArrayType *>(coll_info->collection_meta_);
if (only_vector) {
ret = OB_ERR_INVALID_TYPE_FOR_OP;
LOG_WARN("only support vector type", K(ret));
} else if (arr_type->element_type_->type_id_ != ObNestedType::OB_BASIC_TYPE) {
ret = OB_NOT_SUPPORTED;
LOG_WARN("nested array is not support", K(ret));
} else {
ObCollectionBasicType *elem_type = static_cast<ObCollectionBasicType *>(arr_type->element_type_);
if (ObFloatType != elem_type->basic_meta_.get_obj_type()) {
need_cast = true;
}
}
}
// vector and array(float) don't need to cast
if (OB_SUCC(ret) && !need_cast) {
type.set_calc_type(ObCollectionSQLType);
type.set_calc_subschema_id(src_subschema_id); // avoid cast by set the same subschema_id
}
}
} else if (type.is_string_type()) {
need_cast = true;
}
if (OB_FAIL(ret)) {
} else if (need_cast) {
if (OB_FAIL(exec_ctx->get_subschema_id_by_type_string(DEFAULT_CAST_TYPE_STR, dst_subschema_id))) {
LOG_WARN("failed to get subschema id by type string", K(ret), K(DEFAULT_CAST_TYPE_STR));
} else {
type.set_calc_type(ObCollectionSQLType);
type.set_calc_subschema_id(dst_subschema_id);
}
}
return ret;
}
int ObArrayExprUtils::collect_vector_cast_info(ObExprResType &type, ObExecContext &exec_ctx, ObVectorCastInfo &info)
{
int ret = OB_SUCCESS;
if (type.is_collection_sql_type()) {
ObSubSchemaValue value;
info.subschema_id_ = type.get_subschema_id();
if (OB_FAIL(exec_ctx.get_sqludt_meta_by_subschema_id(info.subschema_id_, value))) {
LOG_WARN("failed to get subschema ctx", K(ret));
} else if (value.type_ >= OB_SUBSCHEMA_MAX_TYPE) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid subschema type", K(ret), K(value));
} else {
const ObSqlCollectionInfo *coll_info = NULL;
coll_info = reinterpret_cast<const ObSqlCollectionInfo *>(value.value_);
if (coll_info->collection_meta_->type_id_ == ObNestedType::OB_VECTOR_TYPE) {
ObCollectionArrayType *arr_type = static_cast<ObCollectionArrayType *>(coll_info->collection_meta_);
info.is_vector_ = true;
info.dim_cnt_ = arr_type->dim_cnt_;
} else if (coll_info->collection_meta_->type_id_ == ObNestedType::OB_ARRAY_TYPE) {
ObCollectionArrayType *arr_type = static_cast<ObCollectionArrayType *>(coll_info->collection_meta_);
ObCollectionBasicType *elem_type = static_cast<ObCollectionBasicType *>(arr_type->element_type_);
if (ObFloatType != elem_type->basic_meta_.get_obj_type()) {
info.need_cast_ = true;
}
}
}
} else if (type.is_string_type()) {
info.need_cast_ = true;
} else if (!type.is_null()) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(ret), K(type));
}
return ret;
}
int ObArrayExprUtils::calc_cast_type2(
ObExprResType &type1,
ObExprResType &type2,
common::ObExprTypeCtx &type_ctx,
uint16_t &res_subschema_id,
const bool only_vector)
{
int ret = OB_SUCCESS;
res_subschema_id = UINT16_MAX;
ObSQLSessionInfo *session = const_cast<ObSQLSessionInfo *>(type_ctx.get_session());
ObExecContext *exec_ctx = OB_ISNULL(session) ? NULL : session->get_cur_exec_ctx();
ObString default_dst_type("ARRAY(FLOAT)");
uint16_t default_dst_subschema_id = UINT16_MAX;
ObVectorCastInfo info1;
ObVectorCastInfo info2;
if (OB_ISNULL(exec_ctx)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("exec ctx is null", K(ret));
} else if (OB_FAIL(collect_vector_cast_info(type1, *exec_ctx, info1))) {
LOG_WARN("failed to collect vector cast info", K(ret));
} else if (OB_FAIL(collect_vector_cast_info(type2, *exec_ctx, info2))) {
LOG_WARN("failed to collect vector cast info", K(ret));
} else if (info1.is_vector_ && info2.is_vector_) {
if (info1.dim_cnt_ != info2.dim_cnt_) {
ret = OB_ERR_INVALID_VECTOR_DIM;
LOG_WARN("check array validty failed", K(ret), K(info1.dim_cnt_), K(info2.dim_cnt_));
}
} else if (info1.is_vector_) {
if (!type2.is_null()) {
type2.set_calc_type(ObCollectionSQLType);
type2.set_calc_subschema_id(info1.subschema_id_);
info2.need_cast_ = true;
}
res_subschema_id = info1.subschema_id_;
} else if (info2.is_vector_) {
if (!type1.is_null()) {
type1.set_calc_type(ObCollectionSQLType);
type1.set_calc_subschema_id(info2.subschema_id_);
info1.need_cast_ = true;
}
res_subschema_id = info2.subschema_id_;
} else if (only_vector) {
ret = OB_NOT_SUPPORTED;
LOG_WARN("no vector in the expr", K(ret));
} else if (info1.need_cast_ || info2.need_cast_) {
if (OB_FAIL(exec_ctx->get_subschema_id_by_type_string(default_dst_type, default_dst_subschema_id))) {
LOG_WARN("failed to get subschema id by type string", K(ret), K(default_dst_type));
} else {
if (info1.need_cast_) {
type1.set_calc_type(ObCollectionSQLType);
type1.set_calc_subschema_id(default_dst_subschema_id);
}
if (info2.need_cast_) {
type2.set_calc_type(ObCollectionSQLType);
type2.set_calc_subschema_id(default_dst_subschema_id);
}
res_subschema_id = default_dst_subschema_id;
}
}
if (OB_SUCC(ret)) {
if (type1.is_collection_sql_type() && !info1.need_cast_) {
type1.set_calc_type(ObCollectionSQLType);
type1.set_calc_subschema_id(type1.get_subschema_id()); // avoid cast by set the same subschema_id
res_subschema_id = type1.get_subschema_id();
}
if (type2.is_collection_sql_type() && !info2.need_cast_) {
type2.set_calc_type(ObCollectionSQLType);
type2.set_calc_subschema_id(type2.get_subschema_id()); // avoid cast by set the same subschema_id
res_subschema_id = type2.get_subschema_id();
}
}
return ret;
}
int ObArrayExprUtils::set_array_res(ObIArrayType *arr_obj, const int32_t res_size, const ObExpr &expr, ObEvalCtx &ctx, ObString &res, const char *data)
{
int ret = OB_SUCCESS;
char *res_buf = nullptr;
int64_t res_buf_len = 0;
ObDatum tmp_res;
ObTextStringDatumResult str_result(expr.datum_meta_.type_, &expr, &ctx, &tmp_res);
if (OB_FAIL(str_result.init(res_size, nullptr))) {
LOG_WARN("fail to init result", K(ret), K(res_size));
} else if (OB_FAIL(str_result.get_reserved_buffer(res_buf, res_buf_len))) {
LOG_WARN("fail to get reserver buffer", K(ret));
} else if (res_buf_len < res_size) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get invalid res buf len", K(ret), K(res_buf_len), K(res_size));
} else if (nullptr != data) {
MEMCPY(res_buf, data, res_size);
} else if (nullptr != arr_obj && OB_FAIL(arr_obj->get_raw_binary(res_buf, res_buf_len))) {
LOG_WARN("get array raw binary failed", K(ret), K(res_buf_len), K(res_size));
}
if (FAILEDx(str_result.lseek(res_size, 0))) {
LOG_WARN("failed to lseek res.", K(ret), K(str_result), K(res_size));
} else {
str_result.get_result_buffer(res);
}
return ret;
}
int ObArrayExprUtils::set_array_res(ObIArrayType *arr_obj, const int32_t res_size, ObIAllocator &allocator, ObString &res, const char *data)
{
int ret = OB_SUCCESS;
bool has_lob_header = !IS_CLUSTER_VERSION_BEFORE_4_1_0_0;
char *res_buf = nullptr;
int64_t res_buf_len = 0;
ObDatum tmp_res;
ObTextStringDatumResult str_result(ObCollectionSQLType, has_lob_header, &tmp_res);
if (OB_FAIL(str_result.init(res_size, &allocator))) {
LOG_WARN("fail to init result", K(ret), K(res_size));
} else if (OB_FAIL(str_result.get_reserved_buffer(res_buf, res_buf_len))) {
LOG_WARN("fail to get reserver buffer", K(ret));
} else if (res_buf_len < res_size) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get invalid res buf len", K(ret), K(res_buf_len), K(res_size));
} else if (nullptr != data) {
MEMCPY(res_buf, data, res_size);
} else if (nullptr != arr_obj && OB_FAIL(arr_obj->get_raw_binary(res_buf, res_buf_len))) {
LOG_WARN("get array raw binary failed", K(ret), K(res_buf_len), K(res_size));
}
if (FAILEDx(str_result.lseek(res_size, 0))) {
LOG_WARN("failed to lseek res.", K(ret), K(str_result), K(res_size));
} else {
str_result.get_result_buffer(res);
}
return ret;
}
template <typename ResVec>
int ObArrayExprUtils::set_array_res(ObIArrayType *arr_obj, const ObExpr &expr, ObEvalCtx &ctx,
ResVec *res_vec, int64_t batch_idx)
{
int ret = OB_SUCCESS;
int32_t res_size = arr_obj->get_raw_binary_len();
char *res_buf = nullptr;
int64_t res_buf_len = 0;
ObTextStringVectorResult<ResVec> str_result(expr.datum_meta_.type_, &expr, &ctx, res_vec, batch_idx);
if (OB_FAIL(str_result.init_with_batch_idx(res_size, batch_idx))) {
LOG_WARN("fail to init result", K(ret), K(res_size));
} else if (OB_FAIL(str_result.get_reserved_buffer(res_buf, res_buf_len))) {
LOG_WARN("fail to get reserver buffer", K(ret));
} else if (res_buf_len < res_size) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get invalid res buf len", K(ret), K(res_buf_len), K(res_size));
} else if (OB_FAIL(arr_obj->get_raw_binary(res_buf, res_buf_len))) {
LOG_WARN("get array raw binary failed", K(ret), K(res_buf_len), K(res_size));
} else if (OB_FAIL(str_result.lseek(res_size, 0))) {
LOG_WARN("failed to lseek res.", K(ret), K(str_result), K(res_size));
} else {
str_result.set_result();
}
return ret;
}
template int ObArrayExprUtils::set_array_res<ObUniformFormat<true>>(
ObIArrayType* arr_obj, const ObExpr& expr, ObEvalCtx& ctx,
ObUniformFormat<true>* res_vec, int64_t batch_idx);
int ObArrayExprUtils::set_array_obj_res(ObIArrayType *arr_obj, ObObjCastParams *params, ObObj *obj)
{
int ret = OB_SUCCESS;
bool has_lob_header = !IS_CLUSTER_VERSION_BEFORE_4_1_0_0;
int32_t res_size = arr_obj->get_raw_binary_len();
char *res_buf = nullptr;
int64_t res_buf_len = 0;
sql::ObTextStringObObjResult text_result(ObCollectionSQLType, params, obj, has_lob_header);
if (OB_FAIL(text_result.init(res_size, params->allocator_v2_))) {
LOG_WARN("init lob result failed");
} else if (OB_FAIL(text_result.get_reserved_buffer(res_buf, res_buf_len))) {
LOG_WARN("fail to get reserver buffer", K(ret));
} else if (res_buf_len < res_size) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get invalid res buf len", K(ret), K(res_buf_len), K(res_size));
} else if (OB_FAIL(arr_obj->get_raw_binary(res_buf, res_buf_len))) {
LOG_WARN("get array raw binary failed", K(ret), K(res_buf_len), K(res_size));
} else if (OB_FAIL(text_result.lseek(res_size, 0))) {
LOG_WARN("failed to lseek res.", K(ret), K(text_result), K(res_size));
} else {
text_result.set_result();
}
return ret;
}
int ObArrayExprUtils::check_array_type_compatibility(ObExecContext *exec_ctx, uint16_t l_subid, uint16_t r_subid, bool &is_compatiable)
{
int ret = OB_SUCCESS;
ObSubSchemaValue l_meta;
ObSubSchemaValue r_meta;
if (OB_FAIL(exec_ctx->get_sqludt_meta_by_subschema_id(l_subid, l_meta))) {
LOG_WARN("failed to get elem meta.", K(ret), K(l_subid));
} else if (OB_FAIL(exec_ctx->get_sqludt_meta_by_subschema_id(r_subid, r_meta))) {
LOG_WARN("failed to get elem meta.", K(ret), K(l_subid));
} else if (l_meta.type_ != ObSubSchemaType::OB_SUBSCHEMA_COLLECTION_TYPE
|| r_meta.type_ != ObSubSchemaType::OB_SUBSCHEMA_COLLECTION_TYPE) {
ret = OB_ERR_INVALID_TYPE_FOR_OP;
LOG_WARN("invalid subschema type", K(ret), K(l_meta.type_), K(r_meta.type_));
} else if (OB_ISNULL(l_meta.value_) || OB_ISNULL(r_meta.value_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("type info is null", K(ret), K(l_meta.value_), K(r_meta.value_));
} else {
is_compatiable =
reinterpret_cast<const ObSqlCollectionInfo *>(l_meta.value_)->has_same_super_type(*reinterpret_cast<const ObSqlCollectionInfo *>(r_meta.value_));
}
return ret;
}
int ObArrayExprUtils::get_array_element_type(ObExecContext *exec_ctx, uint16_t subid, ObDataType &elem_type,
uint32_t &depth, bool &is_vec)
{
int ret = OB_SUCCESS;
ObSubSchemaValue meta;
if (OB_FAIL(exec_ctx->get_sqludt_meta_by_subschema_id(subid, meta))) {
LOG_WARN("failed to get elem meta.", K(ret), K(subid));
} else if (meta.type_ != ObSubSchemaType::OB_SUBSCHEMA_COLLECTION_TYPE) {
ret = OB_ERR_INVALID_TYPE_FOR_OP;
LOG_WARN("invalid subschema type", K(ret), K(meta.type_));
} else if (OB_ISNULL(meta.value_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("type info is null", K(ret));
} else {
const ObSqlCollectionInfo * coll_info = reinterpret_cast<const ObSqlCollectionInfo *>(meta.value_);
elem_type = coll_info->get_basic_meta(depth);
is_vec = coll_info->collection_meta_->type_id_ == ObNestedType::OB_VECTOR_TYPE;
}
return ret;
}
int ObArrayExprUtils::get_array_element_type(ObExecContext *exec_ctx, uint16_t subid, ObObjType &obj_type,
uint32_t &depth, bool &is_vec)
{
int ret = OB_SUCCESS;
ObDataType elem_type;
if (OB_FAIL(get_array_element_type(exec_ctx, subid, elem_type, depth, is_vec))) {
LOG_WARN("failed to get elem meta.", K(ret), K(subid));
} else {
obj_type = elem_type.get_obj_type();
}
return ret;
}
int ObArrayExprUtils::deduce_array_element_type(ObExecContext *exec_ctx, ObExprResType* types_stack, int64_t param_num, ObDataType &elem_type)
{
int ret = OB_SUCCESS;
uint16_t last_subschema_id = ObInvalidSqlType;
ObExprResType coll_calc_type;
ObLength str_len = 0;
bool is_decimal_exist = false;
bool is_bigint_signed_exsit = false;
bool is_all_num_tc = true;
bool is_all_same_type = true;
// scale is zero
bool is_all_int_type = true;
ObObjType last_type = ObNullType;
int64_t elem_idx = 0;
for (int64_t i = 0; i < param_num && OB_SUCC(ret); i++) {
if (!types_stack[i].is_null()) {
elem_idx = i;
}
if (types_stack[i].get_type() == ObDecimalIntType
|| types_stack[i].get_type() == ObNumberType
|| types_stack[i].get_type() == ObUNumberType) {
is_decimal_exist = true;
if (types_stack[i].get_scale() != 0) {
is_all_int_type = false;
}
}
if (!ob_is_numeric_tc(types_stack[i].get_type_class()) && !types_stack[i].is_null()) {
is_all_num_tc = false;
}
if (types_stack[i].get_type() == ObIntType) {
is_bigint_signed_exsit = true;
}
if (ob_is_collection_sql_type(types_stack[i].get_type())) {
// check subschmea id
if (last_subschema_id == ObInvalidSqlType) {
coll_calc_type = types_stack[i];
last_subschema_id = types_stack[i].get_subschema_id();
elem_type.meta_.set_collection(last_subschema_id);
} else if (last_subschema_id != types_stack[i].get_subschema_id()) {
ObExprResType tmp_calc_type;
if (OB_FAIL(ObExprResultTypeUtil::get_array_calc_type(exec_ctx, coll_calc_type, types_stack[i], tmp_calc_type))) {
LOG_WARN("failed to check array compatibilty", K(ret));
} else {
last_subschema_id = tmp_calc_type.get_subschema_id();
coll_calc_type = tmp_calc_type;
elem_type.meta_.set_collection(last_subschema_id);
}
}
} else if (i == 0) {
// do nothing
} else if (types_stack[i - 1].get_type() != types_stack[i].get_type()
&& !types_stack[i].is_null() && !types_stack[i - 1].is_null()) { // null is legal input type
is_all_same_type = false;
if (!is_all_num_tc) {
ret = OB_ERR_ILLEGAL_ARGUMENT_FOR_FUNCTION;
LOG_USER_ERROR(OB_ERR_ILLEGAL_ARGUMENT_FOR_FUNCTION);
}
}
if (OB_SUCC(ret)) {
if (ob_is_string_tc(types_stack[i].get_type())) {
str_len = MAX(str_len, types_stack[i].get_length());
}
}
}
if (OB_SUCC(ret) && last_subschema_id == ObInvalidSqlType) {
if (is_all_same_type && !is_decimal_exist) {
if (param_num == 0) {
// default type
elem_type.meta_.set_tinyint();
} else {
elem_type.set_meta_type(types_stack[elem_idx].get_obj_meta());
elem_type.set_accuracy(types_stack[elem_idx].get_accuracy());
if (ob_is_string_tc(types_stack[elem_idx].get_type())) {
elem_type.set_length(str_len);
for (int64_t i = 0; i < param_num; i++) {
if (!types_stack[i].is_null()) {
if (types_stack[i].get_length() != str_len) {
types_stack[i].set_calc_length(str_len);
}
}
}
}
}
} else if (is_decimal_exist) {
is_all_int_type ? elem_type.meta_.set_int() : elem_type.meta_.set_double();
ObObjType target_type = is_all_int_type ? ObIntType : ObDoubleType;
for (int64_t i = 0; i < param_num; i++) {
if (!types_stack[i].is_null()) {
if (types_stack[i].get_type() != target_type) {
types_stack[i].set_calc_type(target_type);
}
}
}
} else if (is_all_num_tc) {
ObObjType calc_type = ObUInt64Type;
if (is_bigint_signed_exsit) {
elem_type.meta_.set_int();
calc_type = ObIntType;
} else {
elem_type.meta_.set_uint64();
}
for (int64_t i = 0; i < param_num; i++) {
if (!types_stack[i].is_null()) {
if (types_stack[i].get_type() != calc_type) {
types_stack[i].set_calc_type(calc_type);
}
}
}
}
}
return ret;
}
int ObArrayExprUtils::deduce_nested_array_subschema_id(ObExecContext *exec_ctx, ObDataType &elem_type, uint16_t &subschema_id)
{
int ret = OB_SUCCESS;
uint16_t elem_subid = elem_type.meta_.get_subschema_id();
ObSubSchemaValue elem_meta;
if (OB_FAIL(exec_ctx->get_sqludt_meta_by_subschema_id(elem_subid, elem_meta))) {
LOG_WARN("failed to get elem meta.", K(ret), K(elem_subid));
} else if (elem_meta.type_ != ObSubSchemaType::OB_SUBSCHEMA_COLLECTION_TYPE) {
ret = OB_ERR_INVALID_TYPE_FOR_OP;
LOG_WARN("invalid subschema type", K(ret), K(elem_meta.type_));
} else {
const int MAX_LEN = 256;
int64_t pos = 0;
char tmp[MAX_LEN] = {0};
ObString type_info;
const ObSqlCollectionInfo *coll_info = reinterpret_cast<const ObSqlCollectionInfo *>(elem_meta.value_);
if (OB_FAIL(databuff_printf(tmp, MAX_LEN, pos, "ARRAY("))) {
LOG_WARN("failed to convert len to string", K(ret));
} else if (FALSE_IT(STRNCPY(tmp + pos, coll_info->name_def_, coll_info->name_len_))) {
} else if (FALSE_IT(pos += coll_info->name_len_)) {
} else if (OB_FAIL(databuff_printf(tmp, MAX_LEN, pos, ")"))) {
LOG_WARN("failed to add ) to string", K(ret));
} else if (FALSE_IT(type_info.assign_ptr(tmp, static_cast<int32_t>(pos)))) {
} else if (OB_FAIL(exec_ctx->get_subschema_id_by_type_string(type_info, subschema_id))) {
LOG_WARN("failed get subschema id", K(ret), K(type_info));
}
}
return ret;
}
int ObVectorVectorArithFunc::operator()(ObDatum &res, const ObDatum &l, const ObDatum &r, const ObExpr &expr, ObEvalCtx &ctx, ArithType type) const
{
int ret = OB_SUCCESS;
const ObExpr &left_expr = *expr.args_[0];
const ObExpr &right_expr = *expr.args_[1];
ObIArrayType *arr_l = NULL;
ObIArrayType *arr_r = NULL;
ObIArrayType *arr_res = NULL;
ObEvalCtx::TempAllocGuard tmp_alloc_g(ctx);
common::ObArenaAllocator &tmp_allocator = tmp_alloc_g.get_allocator();
ObSubSchemaValue value;
uint16_t subschema_id = expr.obj_meta_.get_subschema_id();
const ObSqlCollectionInfo *coll_info = NULL;
ObCollectionArrayType *arr_type = NULL;
if (OB_FAIL(ctx.exec_ctx_.get_sqludt_meta_by_subschema_id(subschema_id, value))) {
LOG_WARN("failed to get subschema ctx", K(ret));
} else if (OB_FAIL(ObArrayExprUtils::get_type_vector(left_expr, l, ctx, tmp_allocator, arr_l))) {
LOG_WARN("failed to get vector", K(ret));
} else if (OB_FAIL(ObArrayExprUtils::get_type_vector(right_expr, r, ctx, tmp_allocator, arr_r))) {
LOG_WARN("failed to get vector", K(ret));
} else if (OB_ISNULL(arr_l) || OB_ISNULL(arr_r)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected nullptr", K(ret), K(arr_l), K(arr_r));
} else if (OB_UNLIKELY(arr_l->size() != arr_r->size())) {
ret = OB_ERR_INVALID_VECTOR_DIM;
LOG_WARN("check array validty failed", K(ret), K(arr_l->size()), K(arr_r->size()));
} else if (arr_l->contain_null() || arr_r->contain_null()) {
ret = OB_ERR_NULL_VALUE;
LOG_WARN("array with null can't add", K(ret));
} else if (FALSE_IT(coll_info = reinterpret_cast<const ObSqlCollectionInfo *>(value.value_))) {
} else if (OB_ISNULL(coll_info)) {
ret = OB_ERR_NULL_VALUE;
LOG_WARN("collect info is null", K(ret), K(subschema_id));
} else if (OB_ISNULL(arr_type = static_cast<ObCollectionArrayType *>(coll_info->collection_meta_))) {
ret = OB_ERR_NULL_VALUE;
LOG_WARN("array type is null", K(ret), K(subschema_id));
} else if (OB_FAIL(ObArrayTypeObjFactory::construct(tmp_allocator, *arr_type, arr_res))) {
LOG_WARN("construct array obj failed", K(ret), K(subschema_id), K(coll_info));
} else {
const float *data_l = reinterpret_cast<const float*>(arr_l->get_data());
const float *data_r = reinterpret_cast<const float*>(arr_r->get_data());
const uint32_t size = arr_l->size();
ObArrayFixedSize<float> *float_array = static_cast<ObArrayFixedSize<float> *>(arr_res);
for (int64_t i = 0; OB_SUCC(ret) && i < size; ++i) {
const float float_res = type == ADD ? data_l[i] + data_r[i] :
type == MUL ? data_l[i] * data_r[i] :
data_l[i] - data_r[i];
if (isinff(float_res) != 0) {
ret = OB_OPERATE_OVERFLOW;
LOG_WARN("value overflow", K(ret), K(i), K(data_l[i]), K(data_r[i]));
} else if (OB_FAIL(float_array->push_back(float_res))) {
LOG_WARN("failed to push back value", K(ret), K(float_res));
}
}
ObString res_str;
if (OB_FAIL(ret)) {
} else if (OB_FAIL(ObArrayExprUtils::set_array_res(arr_res,
arr_res->get_raw_binary_len(),
ctx.get_expr_res_alloc(),
res_str))) {
LOG_WARN("get array binary string failed", K(ret), K(*coll_info));
// FIXME huhaosheng.hhs: maybe set batch_idx_ before in order to use frame res_buf
// } else if (OB_FAIL(ObArrayExprUtils::set_array_res(arr_res, expr, ctx, res_str))) {
// LOG_WARN("get array binary string failed", K(ret), K(*coll_info));
} else {
res.set_string(res_str);
}
}
return ret;
}
int ObArrayExprUtils::dispatch_array_attrs(ObEvalCtx &ctx, ObIArrayType *arr_obj, ObExpr **attrs, uint32_t attr_count, const int64_t row_idx)
{
int ret = OB_SUCCESS;
ObArrayAttr arr_attrs[attr_count];
uint32_t attr_idx = 0;
if (OB_FAIL(arr_obj->flatten(arr_attrs, attr_count, attr_idx))) {
LOG_WARN("array flatten failed", K(ret));
} else {
for (uint32_t i = 0; i < attr_count; i++) {
ObIVector *vec = attrs[i]->get_vector(ctx);
if (i == 0) {
vec->set_int(row_idx, arr_obj->size());
} else if (arr_attrs[i - 1].ptr_ == NULL && arr_attrs[i - 1].length_ == 0) {
vec->set_payload_shallow(row_idx, NULL, 0); // get ride of random values
vec->set_null(row_idx);
} else {
const char *payload = arr_attrs[i - 1].ptr_;
uint32_t len = arr_attrs[i - 1].length_;
vec->set_payload_shallow(row_idx, payload, len);
}
}
}
return ret;
}
int ObArrayExprUtils::dispatch_array_attrs(ObEvalCtx &ctx, ObExpr &expr, ObString &array_data, const int64_t row_idx)
{
int ret = OB_SUCCESS;
ObEvalCtx::TempAllocGuard tmp_alloc_g(ctx);
// to fix : outrow lob can't use tmp allocator
common::ObArenaAllocator &tmp_allocator = tmp_alloc_g.get_allocator();
ObSubSchemaValue value;
uint16_t subschema_id = expr.obj_meta_.get_subschema_id();
const ObSqlCollectionInfo *coll_info = NULL;
if (OB_FAIL(ctx.exec_ctx_.get_sqludt_meta_by_subschema_id(subschema_id, value))) {
LOG_WARN("failed to get subschema ctx", K(ret));
} else {
ObLobCommon *lob_comm = (ObLobCommon*)(array_data.ptr());
if (lob_comm->is_valid()
&& OB_FAIL(ObTextStringHelper::read_real_string_data(&tmp_allocator,
ObLongTextType,
CS_TYPE_BINARY,
true,
array_data))) {
LOG_WARN("fail to get real data.", K(ret), K(array_data));
} else {
ObIArrayType *arr_obj = NULL;
coll_info = reinterpret_cast<const ObSqlCollectionInfo *>(value.value_);
ObCollectionArrayType *arr_type = static_cast<ObCollectionArrayType *>(coll_info->collection_meta_);
if (OB_ISNULL(coll_info)) {
ret = OB_ERR_NULL_VALUE;
LOG_WARN("collect info is null", K(ret), K(subschema_id));
} else if (OB_FAIL(ObArrayTypeObjFactory::construct(tmp_allocator, *arr_type, arr_obj, true))) {
LOG_WARN("construct array obj failed", K(ret), K(subschema_id), K(coll_info));
} else if (OB_FAIL(arr_obj->init(array_data))) {
LOG_WARN("init array obj failed", K(ret), K(subschema_id), K(coll_info));
} else if (OB_FAIL(dispatch_array_attrs(ctx, arr_obj, expr.attrs_, expr.attrs_cnt_, row_idx))) {
LOG_WARN("dispatch array attributes failed", K(ret), K(subschema_id), K(coll_info));
}
}
}
return ret;
}
int ObVectorFloatArithFunc::operator()(ObDatum &res, const ObDatum &l, const ObDatum &r, const ObExpr &expr, ObEvalCtx &ctx, ArithType type) const
{
UNUSED(type);
int ret = OB_SUCCESS;
const ObExpr &left_expr = *expr.args_[0];
const ObExpr &right_expr = *expr.args_[1];
ObIArrayType *arr_l = NULL;
float data_r = r.get_float();
ObIArrayType *arr_res = NULL;
ObEvalCtx::TempAllocGuard tmp_alloc_g(ctx);
common::ObArenaAllocator &tmp_allocator = tmp_alloc_g.get_allocator();
ObSubSchemaValue value;
uint16_t subschema_id = expr.obj_meta_.get_subschema_id();
const ObSqlCollectionInfo *coll_info = NULL;
ObCollectionArrayType *arr_type = NULL;
if (0 == data_r) {
res.set_null();
} else if (OB_FAIL(ctx.exec_ctx_.get_sqludt_meta_by_subschema_id(subschema_id, value))) {
LOG_WARN("failed to get subschema ctx", K(ret));
} else if (OB_FAIL(ObArrayExprUtils::get_type_vector(left_expr, l, ctx, tmp_allocator, arr_l))) {
LOG_WARN("failed to get vector", K(ret));
} else if (OB_ISNULL(arr_l)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected nullptr", K(ret), K(arr_l));
} else if (arr_l->contain_null()) {
ret = OB_ERR_NULL_VALUE;
LOG_WARN("array with null can't add", K(ret));
} else if (FALSE_IT(coll_info = reinterpret_cast<const ObSqlCollectionInfo *>(value.value_))) {
} else if (OB_ISNULL(coll_info)) {
ret = OB_ERR_NULL_VALUE;
LOG_WARN("collect info is null", K(ret), K(subschema_id));
} else if (OB_ISNULL(arr_type = static_cast<ObCollectionArrayType *>(coll_info->collection_meta_))) {
ret = OB_ERR_NULL_VALUE;
LOG_WARN("array type is null", K(ret), K(subschema_id));
} else if (OB_FAIL(ObArrayTypeObjFactory::construct(tmp_allocator, *arr_type, arr_res))) {
LOG_WARN("construct array obj failed", K(ret), K(subschema_id), K(coll_info));
} else {
const float *data_l = reinterpret_cast<const float*>(arr_l->get_data());
const uint32_t size = arr_l->size();
ObVectorData *float_array = static_cast<ObVectorData *>(arr_res);
for (int64_t i = 0; OB_SUCC(ret) && i < size; ++i) {
const float float_res = data_l[i] / data_r; // only support div now
if (isinff(float_res) != 0) {
ret = OB_OPERATE_OVERFLOW;
LOG_WARN("value overflow", K(ret), K(i), K(data_l[i]), K(data_r));
} else if (OB_FAIL(float_array->push_back(float_res))) {
LOG_WARN("failed to push back value", K(ret), K(float_res));
}
}
ObString res_str;
if (OB_FAIL(ret)) {
} else if (OB_FAIL(ObArrayExprUtils::set_array_res(arr_res,
arr_res->get_raw_binary_len(),
ctx.get_expr_res_alloc(),
res_str))) {
LOG_WARN("get array binary string failed", K(ret), K(*coll_info));
} else {
res.set_string(res_str);
}
}
return ret;
}
int ObArrayExprUtils::batch_dispatch_array_attrs(ObEvalCtx &ctx, ObExpr &expr, int64_t begin, int64_t batch_size, const uint16_t *selector)
{
int ret = OB_SUCCESS;
ObIVector *vec = expr.get_vector(ctx);
ObEvalCtx::TempAllocGuard tmp_alloc_g(ctx);
ObIArrayType *arr_obj = NULL;
// to fix : outrow lob can't use tmp allocator
common::ObArenaAllocator &tmp_allocator = tmp_alloc_g.get_allocator();
if (OB_FAIL(construct_array_obj(tmp_allocator, ctx, expr.obj_meta_.get_subschema_id(), arr_obj))) {
LOG_WARN("fail to construct array obj.", K(ret));
} else {
for (int64_t row_idx = begin; row_idx < begin + batch_size && OB_SUCC(ret); row_idx++) {
int64_t idx = selector != NULL ? selector[row_idx] : row_idx;
ObString raw_data = vec->get_string(idx);
uint32_t attr_idx = 0;
if (vec->is_null(idx)) {
for (uint32_t i = 0; i < expr.attrs_cnt_; i++) {
ObIVector *attr_vec = expr.attrs_[i]->get_vector(ctx);
attr_vec->set_null(row_idx);
}
} else if (OB_FAIL(ObTextStringHelper::read_real_string_data(&tmp_allocator,
ObLongTextType,
CS_TYPE_BINARY,
true,
raw_data))) {
LOG_WARN("fail to get real data.", K(ret), K(raw_data));
} else if (OB_FAIL(arr_obj->init(raw_data))) {
LOG_WARN("init array obj failed", K(ret));
} else if (OB_FAIL(dispatch_array_attrs_rows(ctx, arr_obj, idx, expr.attrs_, expr.attrs_cnt_))) {
LOG_WARN("failed to dispatch array attrs rows", K(ret));
}
}
}
return ret;
}
int ObArrayExprUtils::assemble_array_attrs(ObEvalCtx &ctx, const ObExpr &expr, int64_t row_idx, ObIArrayType *arr_obj)
{
int ret = OB_SUCCESS;
ObDatum attr_val[expr.attrs_cnt_];
for (uint32_t i = 0; i < expr.attrs_cnt_; ++i) {
ObIVector *vec = expr.attrs_[i]->get_vector(ctx);
const char *payload = NULL;
ObLength payload_len = 0;
vec->get_payload(row_idx, payload, payload_len);
attr_val[i].ptr_ = payload;
attr_val[i].pack_ = payload_len;
}
if (OB_FAIL(arr_obj->init(attr_val, expr.attrs_cnt_))) {
LOG_WARN("init array attrs failed", K(ret));
}
return ret;
}
int ObArrayExprUtils::transform_array_to_uniform(ObEvalCtx &ctx, const ObExpr &expr, const int64_t batch_size, const ObBitVector *skip)
{
int ret = OB_SUCCESS;
ObSubSchemaValue value;
uint16_t subschema_id = expr.obj_meta_.get_subschema_id();
const ObBitVector *nulls = NULL;
if (OB_FAIL(ctx.exec_ctx_.get_sqludt_meta_by_subschema_id(subschema_id, value))) {
LOG_WARN("failed to get subschema", K(ret));
} else if (expr.get_vector(ctx)->get_format() == VEC_DISCRETE
&& FALSE_IT(nulls = static_cast<ObDiscreteBase *>(expr.get_vector(ctx))->get_nulls()) ) {
} else if (expr.get_vector(ctx)->get_format() == VEC_CONTINUOUS
&& FALSE_IT(nulls = static_cast<ObContinuousBase *>(expr.get_vector(ctx))->get_nulls()) ) {
} else {
ObIArrayType *arr_obj = NULL;
ObEvalCtx::TempAllocGuard tmp_alloc_g(ctx);
common::ObArenaAllocator &alloc = tmp_alloc_g.get_allocator();
const ObSqlCollectionInfo *coll_info = reinterpret_cast<const ObSqlCollectionInfo *>(value.value_);
ObCollectionArrayType *arr_type = static_cast<ObCollectionArrayType *>(coll_info->collection_meta_);
if (OB_ISNULL(coll_info)) {
ret = OB_ERR_NULL_VALUE;
LOG_WARN("collect info is null", K(ret), K(subschema_id));
} else if (OB_ISNULL(nulls)) {
ret = OB_ERR_NULL_VALUE;
LOG_WARN("failed to get nulls", K(ret), K(expr.get_vector(ctx)->get_format()));
} else if (OB_FAIL(ObArrayTypeObjFactory::construct(alloc, *arr_type, arr_obj, true))) {
LOG_WARN("construct array obj failed", K(ret), K(subschema_id), K(coll_info));
} else {
ret = expr.init_vector(ctx, VEC_UNIFORM, batch_size);
UniformFormat *root_vec = static_cast<UniformFormat *>(expr.get_vector(ctx));
for (int64_t row_idx = 0; OB_SUCC(ret) && row_idx < batch_size; ++row_idx) {
if (expr.attrs_cnt_ <= 0) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected attrs cnt", K(ret), K(expr.attrs_cnt_));
} else if (skip != nullptr && skip->at(row_idx)) {
// skip row
} else if (nulls->at(row_idx) || expr.attrs_[0]->get_vector(ctx)->is_null(row_idx)) {
root_vec->set_null(row_idx);
} else if (OB_FAIL(assemble_array_attrs(ctx, expr, row_idx, arr_obj))) {
LOG_WARN("assemble array attrs failed", K(ret));
} else if (OB_FAIL(set_array_res(arr_obj, expr, ctx, root_vec, row_idx))) {
LOG_WARN("set array res failed", K(ret));
}
}
}
}
return ret;
}
int ObArrayExprUtils::calc_nested_expr_data_size(const ObExpr &expr, ObEvalCtx &ctx, const int64_t batch_idx, int64_t &size)
{
int ret = OB_SUCCESS;
size = 0;
for (uint32_t i = 0; i < expr.attrs_cnt_; ++i) {
ObIVector *vec = expr.attrs_[i]->get_vector(ctx);
VectorFormat format = vec->get_format();
if (VEC_DISCRETE == format) {
ObDiscreteBase *disc_vec = static_cast<ObDiscreteBase *>(vec);
if (!disc_vec->is_null(batch_idx)) {
ObLength *lens = disc_vec->get_lens();
size += lens[batch_idx];
}
} else if (VEC_CONTINUOUS == format) {
ObContinuousBase *cont_vec = static_cast<ObContinuousBase*>(vec);
uint32_t *offsets = cont_vec->get_offsets();
size += (offsets[batch_idx + 1] - offsets[batch_idx]);
} else if (is_uniform_format(format)) {
ObUniformBase *uni_vec = static_cast<ObUniformBase *>(vec);
ObDatum *datums = uni_vec->get_datums();
const uint64_t idx_mask = VEC_UNIFORM_CONST == format ? 0 : UINT64_MAX;
size += datums[batch_idx & idx_mask].len_;
} else if (VEC_FIXED == format) {
// array len
size += sizeof(uint32_t);
}
}
ObTextStringResult blob_res(ObLongTextType, true, nullptr);
if (OB_FAIL(blob_res.calc_buffer_len(size))) {
LOG_WARN("calculate data size failed", K(ret));
} else {
size = blob_res.get_buff_len();
}
return ret;
}
int ObArrayExprUtils::construct_array_obj(ObIAllocator &alloc, ObEvalCtx &ctx, const uint16_t subschema_id, ObIArrayType *&res, bool read_only)
{
int ret = OB_SUCCESS;
ObSubSchemaValue meta;
if (OB_FAIL(ctx.exec_ctx_.get_sqludt_meta_by_subschema_id(subschema_id, meta))) {
LOG_WARN("failed to get subschema meta", K(ret), K(subschema_id));
} else {
const ObSqlCollectionInfo *src_coll_info = reinterpret_cast<const ObSqlCollectionInfo *>(meta.value_);
ObCollectionArrayType *arr_type = static_cast<ObCollectionArrayType *>(src_coll_info->collection_meta_);
if (OB_FAIL(ObArrayTypeObjFactory::construct(alloc, *arr_type, res, read_only))) {
LOG_WARN("construct array obj failed", K(ret), K(src_coll_info));
}
}
return ret;
}
int ObArrayExprUtils::get_array_obj(ObIAllocator &alloc, ObEvalCtx &ctx, const uint16_t subschema_id, const ObString &raw_data, ObIArrayType *&res)
{
int ret = OB_SUCCESS;
ObString data_str = raw_data;
if (res == NULL && OB_FAIL(construct_array_obj(alloc, ctx, subschema_id, res))) {
LOG_WARN("construct array obj failed", K(ret));
} else if (OB_FAIL(ObTextStringHelper::read_real_string_data(&alloc,
ObLongTextType,
CS_TYPE_BINARY,
true,
data_str))) {
LOG_WARN("fail to get real data.", K(ret), K(data_str));
} else if (OB_FAIL(res->init(data_str))) {
LOG_WARN("failed to init array", K(ret));
}
return ret;
}
int ObArrayExprUtils::dispatch_array_attrs_rows(ObEvalCtx &ctx, ObIArrayType *arr_obj, const int64_t row_idx,
ObExpr **attrs, uint32_t attr_count, bool is_shallow)
{
int ret = OB_SUCCESS;
ObArrayAttr arr_attrs[attr_count];
uint32_t attr_idx = 0;
if (OB_FAIL(arr_obj->flatten(arr_attrs, attr_count, attr_idx))) {
LOG_WARN("array flatten failed", K(ret));
} else {
for (uint32_t i = 0; i < attr_count; i++) {
ObIVector *vec = attrs[i]->get_vector(ctx);
if (i == 0) {
vec->set_int(row_idx, arr_obj->size());
} else if (arr_attrs[i - 1].ptr_ == NULL && arr_attrs[i - 1].length_ == 0) {
vec->set_payload_shallow(row_idx, NULL, 0); // get ride of random values
vec->set_null(row_idx);
} else {
const char *payload = arr_attrs[i - 1].ptr_;
uint32_t len = arr_attrs[i - 1].length_;
(is_shallow || payload == NULL) ? vec->set_payload_shallow(row_idx, payload, len) : vec->set_payload(row_idx, payload, len);
}
}
}
return ret;
}
int ObArrayExprUtils::nested_expr_from_rows(const ObExpr &expr, ObEvalCtx &ctx, const sql::RowMeta &row_meta, const sql::ObCompactRow **stored_rows,
const int64_t size, const int64_t col_idx, const int64_t *selector)
{
int ret = OB_SUCCESS;
ObIVector *vec = expr.get_vector(ctx);
VectorFormat format = vec->get_format();
ObEvalCtx::TempAllocGuard tmp_alloc_g(ctx);
// to fix : outrow lob can't use tmp allocator
common::ObArenaAllocator &tmp_allocator = tmp_alloc_g.get_allocator();
ObIArrayType *arr_obj = NULL;
const uint16_t subschema_id = expr.obj_meta_.get_subschema_id();
if (OB_FAIL(construct_array_obj(tmp_allocator, ctx, subschema_id, arr_obj))) {
LOG_WARN("construct array obj failed", K(ret));
}
for (int64_t i = 0; i < size && OB_SUCC(ret); i++) {
int64_t row_idx = i;
if (selector != nullptr) {
row_idx = selector[i];
}
if (stored_rows[i]->is_null(col_idx)) {
vec->set_null(row_idx);
set_expr_attrs_null(expr, ctx, row_idx);
} else {
const char *payload = NULL;
ObLength len = 0;
stored_rows[i]->get_cell_payload(row_meta, col_idx, payload, len);
ObLobCommon *lob_comm = (ObLobCommon*)(payload);
ObString array_data(len, payload);
if (lob_comm->is_valid()) {
if (OB_FAIL(ObTextStringHelper::read_real_string_data(&tmp_allocator,
ObLongTextType,
CS_TYPE_BINARY,
true,
array_data))) {
LOG_WARN("fail to get real data.", K(ret), K(array_data));
}
}
if (OB_FAIL(ret)) {
} else if (OB_FAIL(arr_obj->init(array_data))) {
LOG_WARN("failed to init array", K(ret));
} else if (OB_FAIL(dispatch_array_attrs_rows(ctx, arr_obj, row_idx, expr.attrs_, expr.attrs_cnt_))) {
LOG_WARN("failed to dispatch array attrs rows", K(ret));
}
}
}
return ret;
}
int ObArrayExprUtils::nested_expr_to_rows(const ObExpr &expr, ObEvalCtx &ctx, const sql::RowMeta &row_meta, sql::ObCompactRow **stored_rows,
const uint16_t selector[], const int64_t size, const int64_t col_idx)
{
int ret = OB_SUCCESS;
ObIVector *vec = expr.get_vector(ctx);
VectorFormat format = vec->get_format();
for (int64_t i = 0; i < size; i++) {
int64_t row_idx = selector[i];
if (vec->is_null(row_idx)) {
stored_rows[i]->set_null(row_meta, col_idx);
} else {
int64_t pos = 0;
for (uint32_t i = 0; i < expr.attrs_cnt_ && OB_SUCC(ret); ++i) {
const char *payload = NULL;
ObLength payload_len = 0;
ObIVector *vec = expr.attrs_[i]->get_vector(ctx);
VectorFormat format = vec->get_format();
vec->get_payload(row_idx, payload, payload_len);
stored_rows[i]->append_cell_payload(row_meta, col_idx, payload, payload_len, pos);
}
}
}
return ret;
}
int ObArrayExprUtils::nested_expr_to_row(const ObExpr &expr, ObEvalCtx &ctx, char *row_buf,
const int64_t col_offset, const uint64_t row_idx, int64_t &cell_len,
const int64_t *remain_size)
{
int ret = OB_SUCCESS;
uint32_t data_len = 0;
const uint16_t subschema_id = expr.obj_meta_.get_subschema_id();
ObSubSchemaValue meta;
bool is_vector = false;
if (OB_FAIL(ctx.exec_ctx_.get_sqludt_meta_by_subschema_id(subschema_id, meta))) {
LOG_WARN("failed to get subschema meta", K(ret), K(subschema_id));
} else {
const ObSqlCollectionInfo *src_coll_info = reinterpret_cast<const ObSqlCollectionInfo *>(meta.value_);
ObCollectionArrayType *arr_type = static_cast<ObCollectionArrayType *>(src_coll_info->collection_meta_);
is_vector = arr_type->type_id_ == ObNestedType::OB_VECTOR_TYPE;
if (is_vector) {
ObIVector *vec = expr.attrs_[2]->get_vector(ctx);
data_len += vec->get_length(row_idx);
} else {
for (uint32_t i = 0; i < expr.attrs_cnt_ && OB_SUCC(ret); ++i) {
if (i == 0) {
data_len += sizeof(uint32_t);
} else {
ObIVector *vec = expr.attrs_[i]->get_vector(ctx);
data_len += vec->get_length(row_idx);
}
}
}
ObString res_buf;
ObTextStringResult blob_res(ObLongTextType, true, nullptr);
if (OB_FAIL(blob_res.calc_buffer_len(data_len))) {
LOG_WARN("calc buffer len failed", K(ret), K(data_len));
} else if (remain_size != NULL && blob_res.get_buff_len() > *remain_size) {
ret = OB_BUF_NOT_ENOUGH;
LOG_WARN("row memory isn't enough", K(ret), K(blob_res.get_buff_len()), K(*remain_size));
} else if (FALSE_IT(res_buf.assign_ptr(row_buf + col_offset, blob_res.get_buff_len()))) {
} else if (OB_FAIL(blob_res.init(data_len, res_buf))) {
LOG_WARN("text string init failed", K(ret), K(data_len));
} else if (is_vector) {
const char *payload = NULL;
ObLength payload_len = 0;
ObIVector *vec = expr.attrs_[2]->get_vector(ctx);
vec->get_payload(row_idx, payload, payload_len);
if (OB_FAIL(blob_res.append(payload, payload_len))) {
LOG_WARN("failed to append realdata", K(ret), K(payload_len));
}
} else {
for (uint32_t i = 0; i < expr.attrs_cnt_ && OB_SUCC(ret); ++i) {
const char *payload = NULL;
ObLength payload_len = 0;
ObIVector *vec = expr.attrs_[i]->get_vector(ctx);
uint32_t len = 0;
if (i == 0) {
len = vec->get_uint32(row_idx);
payload = reinterpret_cast<const char *>(&len);
payload_len = sizeof(uint32_t);
} else {
vec->get_payload(row_idx, payload, payload_len);
}
if (OB_FAIL(blob_res.append(payload, payload_len))) {
LOG_WARN("failed to append realdata", K(ret), K(payload_len));
}
}
}
if (OB_SUCC(ret)) {
cell_len = blob_res.get_buff_len();
}
}
return ret;
}
void ObArrayExprUtils::set_expr_attrs_null(const ObExpr &expr, ObEvalCtx &ctx, const int64_t idx)
{
ObIVector *vec = expr.get_vector(ctx);
VectorFormat format = vec->get_format();
if (is_uniform_format(format)) {
// do nothing
} else {
for (uint32_t i = 0; i < expr.attrs_cnt_; ++i) {
ObIVector *vec = expr.attrs_[i]->get_vector(ctx);
vec->set_null(idx);
}
}
}
int ObNestedVectorFunc::construct_attr_param(ObIAllocator &alloc, ObEvalCtx &ctx, ObExpr &param_expr,
const uint16_t meta_id, int64_t row_idx, ObIArrayType *&param_obj)
{
int ret = OB_SUCCESS;
if (param_obj == NULL && OB_FAIL(ObArrayExprUtils::construct_array_obj(alloc, ctx, meta_id, param_obj))) {
LOG_WARN("construct array obj failed", K(ret));
} else if (OB_FAIL(ObArrayExprUtils::assemble_array_attrs(ctx, param_expr, row_idx, param_obj))) {
LOG_WARN("assemble array attrs failed", K(ret));
}
return ret;
}
int ObNestedVectorFunc::construct_param(
ObIAllocator &alloc, ObEvalCtx &ctx, const uint16_t meta_id, ObString &str_data, ObIArrayType *&param_obj)
{
return ObArrayExprUtils::get_array_obj(alloc, ctx, meta_id, str_data, param_obj);
}
int ObNestedVectorFunc::construct_res_obj(
ObIAllocator &alloc, ObEvalCtx &ctx, const uint16_t meta_id, ObIArrayType *&res_obj)
{
return ObArrayExprUtils::construct_array_obj(alloc, ctx, meta_id, res_obj, false);
}
int ObNestedVectorFunc::construct_params(ObIAllocator &alloc, ObEvalCtx &ctx, const uint16_t left_meta_id,
const uint16_t right_meta_id, const uint16_t res_meta_id, ObString &left, ObString right, ObIArrayType *&left_obj,
ObIArrayType *&right_obj, ObIArrayType *&res_obj)
{
int ret = OB_SUCCESS;
if (OB_FAIL(ObArrayExprUtils::get_array_obj(alloc, ctx, left_meta_id, left, left_obj))) {
SQL_ENG_LOG(WARN, "get array failed", K(ret));
} else if (OB_FAIL(ObArrayExprUtils::get_array_obj(alloc, ctx, right_meta_id, right, right_obj))) {
SQL_ENG_LOG(WARN, "get array failed", K(ret));
} else if (OB_FAIL(ObArrayExprUtils::construct_array_obj(alloc, ctx, res_meta_id, res_obj, false))) {
SQL_ENG_LOG(WARN, "construct res array failed", K(ret));
}
return ret;
}
} // sql
} // oceanbase
Reference in New Issue View Git Blame Copy Permalink