hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

patch 4.0

Browse Source
This commit is contained in:
wangzelin.wzl
2022-10-24 10:34:53 +08:00
parent 4ad6e00ec3
commit 93a1074b0c
10533 changed files with 2588271 additions and 2299373 deletions
Download Patch File Download Diff File Expand all files Collapse all files

366
src/sql/engine/expr/ob_expr_obj_access.cpp
View File

@ -14,36 +14,100 @@
#include "sql/engine/expr/ob_expr_obj_access.h"
#include "sql/engine/ob_physical_plan_ctx.h"
#include "sql/engine/ob_exec_context.h"
#include "sql/ob_spi.h"
#include "pl/ob_pl.h"
namespace oceanbase {
namespace oceanbase
{
using namespace common;
namespace sql {
OB_SERIALIZE_MEMBER(
(ObExprObjAccess, ObExprOperator), get_attr_func_, param_idxs_, access_idx_cnt_, for_write_, coll_idx_);
namespace sql
{
ObExprObjAccess::ObExprObjAccess(ObIAllocator& alloc)
: ObExprOperator(alloc, T_OBJ_ACCESS_REF, N_OBJ_ACCESS, PARAM_NUM_UNKNOWN, NOT_ROW_DIMENSION),
get_attr_func_(0),
param_idxs_(alloc),
access_idx_cnt_(0),
for_write_(false),
coll_idx_(OB_INVALID_INDEX)
{}
ObExprObjAccess::ExtraInfo::ExtraInfo(common::ObIAllocator &alloc, ObExprOperatorType type)
: ObIExprExtraInfo(alloc, type),
get_attr_func_(0),
param_idxs_(alloc),
access_idx_cnt_(0),
for_write_(false),
property_type_(pl::ObCollectionType::INVALID_PROPERTY),
coll_idx_(OB_INVALID_INDEX),
extend_size_(0)
{
}
OB_SERIALIZE_MEMBER(ObExprObjAccess::ExtraInfo,
get_attr_func_,
param_idxs_,
access_idx_cnt_,
for_write_,
property_type_,
coll_idx_,
extend_size_);
OB_SERIALIZE_MEMBER((ObExprObjAccess, ObExprOperator),
info_.get_attr_func_,
info_.param_idxs_,
info_.access_idx_cnt_,
info_.for_write_,
info_.property_type_,
info_.coll_idx_);
// extend_size_ is not needed here, we got extend size from result_type_
ObExprObjAccess::ObExprObjAccess(ObIAllocator &alloc)
: ObExprOperator(alloc, T_OBJ_ACCESS_REF, N_OBJ_ACCESS, PARAM_NUM_UNKNOWN, NOT_ROW_DIMENSION,
INTERNAL_IN_MYSQL_MODE, INTERNAL_IN_ORACLE_MODE),
info_(alloc, T_OBJ_ACCESS_REF)
{
}
ObExprObjAccess::~ObExprObjAccess()
{}
{
}
void ObExprObjAccess::reset()
void ObExprObjAccess::ExtraInfo::reset()
{
get_attr_func_ = 0;
param_idxs_.reset();
access_idx_cnt_ = 0;
for_write_ = false;
property_type_ = pl::ObCollectionType::INVALID_PROPERTY;
coll_idx_ = OB_INVALID_INDEX;
extend_size_ = 0;
}
void ObExprObjAccess::reset()
{
info_.reset();
ObExprOperator::reset();
}
int ObExprObjAccess::assign(const ObExprOperator& other)
int ObExprObjAccess::ExtraInfo::deep_copy(common::ObIAllocator &allocator,
const ObExprOperatorType type,
ObIExprExtraInfo *&copied_info) const
{
int ret = OB_SUCCESS;
OZ(ObExprExtraInfoFactory::alloc(allocator, type, copied_info));
ExtraInfo &other = *static_cast<ExtraInfo *>(copied_info);
if (OB_SUCC(ret)) {
OZ(other.assign(*this));
}
return ret;
}
int ObExprObjAccess::ExtraInfo::assign(const ObExprObjAccess::ExtraInfo &other)
{
int ret = OB_SUCCESS;
get_attr_func_ = other.get_attr_func_;
access_idx_cnt_ = other.access_idx_cnt_;
for_write_ = other.for_write_;
property_type_ = other.property_type_;
coll_idx_ = other.coll_idx_;
extend_size_ = other.extend_size_;
OZ(param_idxs_.assign(other.param_idxs_));
return ret;
}
int ObExprObjAccess::assign(const ObExprOperator &other)
{
int ret = OB_SUCCESS;
if (other.get_type() != T_OBJ_ACCESS_REF) {
@ -52,105 +116,164 @@ int ObExprObjAccess::assign(const ObExprOperator& other)
} else if (OB_FAIL(ObExprOperator::assign(other))) {
LOG_WARN("assign parent expr failed", K(ret));
} else {
const ObExprObjAccess& other_expr = static_cast<const ObExprObjAccess&>(other);
get_attr_func_ = other_expr.get_attr_func_;
access_idx_cnt_ = other_expr.access_idx_cnt_;
for_write_ = other_expr.for_write_;
coll_idx_ = other_expr.coll_idx_;
const ObExprObjAccess &other_expr = static_cast<const ObExprObjAccess &>(other);
OZ(info_.assign(other_expr.info_));
}
return ret;
}
#define GET_VALID_INT64_PARAM(obj) \
do { \
if (OB_SUCC(ret)) { \
int64_t param_value = 0; \
if (obj.is_integer_type() || obj.is_ext()) { \
param_value = obj.get_int(); \
} else if (obj.is_number()) { \
if (!obj.get_number().is_valid_int64(param_value)) { \
number::ObNumber number = obj.get_number(); \
if (OB_FAIL(number.round(0))) { \
LOG_WARN("failed to round number", K(ret), K(number)); \
} else if (!number.is_valid_int64(param_value)) { \
ret = OB_ARRAY_OUT_OF_RANGE; \
LOG_WARN("array index is out of range", K(ret), K(number)); \
} \
} \
} else { \
ret = OB_ERR_UNEXPECTED; \
LOG_WARN("obj param is invalid type", K(obj), K(i)); \
} \
#define GET_VALID_INT64_PARAM(obj) \
do { \
if (OB_SUCC(ret)) { \
int64_t param_value = 0; \
if (obj.is_integer_type() || obj.is_ext()) { \
param_value = obj.get_int(); \
} else if (obj.is_number()) { \
if (!obj.get_number().is_valid_int64(param_value)) { \
number::ObNumber number = obj.get_number(); \
if (OB_FAIL(number.round(0))) { \
LOG_WARN("failed to round number", K(ret), K(number)); \
} else if (!number.is_valid_int64(param_value)) { \
ret = OB_ARRAY_OUT_OF_RANGE; \
LOG_WARN("array index is out of range", K(ret), K(number)); \
} \
} \
} else if (obj.is_null()) { \
ret = OB_ERR_NUMERIC_OR_VALUE_ERROR; \
LOG_WARN("ORA-06502: PL/SQL: numeric or value error: NULL index table key value",\
K(ret), K(obj), K(i)); \
} else { \
ret = OB_ERR_UNEXPECTED; \
LOG_WARN("obj param is invalid type", K(obj), K(i)); \
} \
if (OB_SUCC(ret) && OB_FAIL(param_array.push_back(param_value))) { \
LOG_WARN("store param array failed", K(ret), K(i)); \
} \
} \
LOG_WARN("store param array failed", K(ret), K(i)); \
} \
} \
} while (0)
int ObExprObjAccess::init_param_array(
const ParamStore& param_store, const ObObj* objs_stack, int64_t param_num, ParamArray& param_array) const
int ObExprObjAccess::ExtraInfo::init_param_array(const ParamStore &param_store,
const ObObj *objs_stack,
int64_t param_num,
ParamArray &param_array) const
{
int ret = OB_SUCCESS;
for (int64_t i = 0; OB_SUCC(ret) && i < param_idxs_.count(); ++i) {
CK(param_idxs_.at(i) >= 0 && param_idxs_.at(i) < param_store.count());
CK (param_idxs_.at(i) >= 0 && param_idxs_.at(i) < param_store.count());
if (OB_SUCC(ret)) {
const ObObjParam& obj_param = param_store.at(param_idxs_.at(i));
const ObObjParam &obj_param = param_store.at(param_idxs_.at(i));
GET_VALID_INT64_PARAM(obj_param);
}
}
for (int64_t i = 0; OB_SUCC(ret) && i < param_num; ++i) {
const ObObj& obj = objs_stack[i];
const ObObj &obj = objs_stack[i];
GET_VALID_INT64_PARAM(obj);
}
return ret;
}
#define SET_RESULT(res, is_null) \
do { \
if (OB_SUCC(ret)) { \
if (is_null) { \
result.set_null(); \
} else { \
result.set_int(res); \
} \
} \
} while (0)
int ObExprObjAccess::calc_result(
ObObj& result, const ObObj* objs_stack, int64_t param_num, const ParamStore& param_store) const
int ObExprObjAccess::ExtraInfo::update_coll_first_last(
const ParamStore &param_store, const ObObj *objs_stack, int64_t param_num) const
{
int ret = OB_SUCCESS;
typedef int32_t (*GetAttr)(int64_t, int64_t[], int64_t*);
bool found = false;
#define SEARCH_AND_UPDATE_COLL(get_elem, count) \
for (int64_t i = 0; OB_SUCC(ret) && !found && i < count; ++i) { \
const ObObj &obj = get_elem; \
if (obj.is_pl_extend() \
&& (pl::PL_NESTED_TABLE_TYPE == obj.get_meta().get_extend_type() \
|| pl::PL_VARRAY_TYPE == obj.get_meta().get_extend_type())) { \
found = true; \
pl::ObPLCollection *coll = reinterpret_cast<pl::ObPLCollection *>(obj.get_ext()); \
CK (OB_NOT_NULL(coll)); \
OX (coll->set_first(OB_INVALID_INDEX)); \
OX (coll->set_last(OB_INVALID_INDEX)); \
OX (found = true); \
} \
}
SEARCH_AND_UPDATE_COLL(objs_stack[i], param_num);
SEARCH_AND_UPDATE_COLL(param_store.at(i), param_store.count());
#undef SEARCH_AND_UPDATE_COLL
return ret;
}
int ObExprObjAccess::calc_result(ObObj &result,
const ObObj *objs_stack,
int64_t param_num,
const ParamStore &param_store) const
{
return info_.calc(result,
get_result_type(),
get_result_type().get_extend_size(),
param_store,
objs_stack,
param_num);
}
int ObExprObjAccess::ExtraInfo::calc(ObObj &result,
const ObObjMeta &res_type,
const int32_t extend_size,
const ParamStore &param_store,
const common::ObObj *params,
int64_t param_num) const
{
int ret = OB_SUCCESS;
typedef int32_t (*GetAttr)(int64_t, int64_t [], int64_t *);
GetAttr get_attr = reinterpret_cast<GetAttr>(get_attr_func_);
ParamArray param_array;
CK(OB_NOT_NULL(get_attr));
OZ(init_param_array(param_store, objs_stack, param_num, param_array));
CK (OB_NOT_NULL(get_attr));
OZ (init_param_array(param_store, params, param_num, param_array));
if (OB_SUCC(ret)) {
int64_t* param_ptr = const_cast<int64_t*>(param_array.head());
int64_t *param_ptr = const_cast<int64_t *>(param_array.head());
int64_t attr_addr = 0;
if (OB_FAIL(get_attr(param_array.count(), param_ptr, &attr_addr))) {
LOG_WARN("failed to get attr", K(ret));
} else if (OB_UNLIKELY(0 == attr_addr)) {
OZ (get_attr(param_array.count(), param_ptr, &attr_addr));
if (OB_FAIL(ret)) {
if (OB_NOT_INIT == ret && pl::ObCollectionType::EXISTS_PROPERTY == property_type_) {
ret = OB_SUCCESS;
result.set_tinyint(0);
}
} else if (OB_UNLIKELY(0 >= attr_addr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get attribute failed", K(ret), K(attr_addr));
} else if (for_write_ || get_result_type().is_ext()) {
result.set_extend(attr_addr, get_result_type().get_extend_type());
} else if (for_write_ || res_type.is_ext()) {
// 当对collection元素赋值的时候，强制设置collection的first和last为invalid
// 在获取first，last的时候，会根据这个标记进行更新。
// 主要是因为collection有删除操作的时候，而又赋值了，需要一个地方给出提示
// 这儿就是一个标记，需要明确的，这可能会导致first last暂时不准确。但get_first会自动更新
// 所有需要使用first，last的地方应该调用get_first这样的函数，而不能直接使用first的值
// assoc array 不需要处理，因为在accociative_index里面更新了first，last
if (for_write_ && OB_INVALID_INDEX != coll_idx_) {
if (0 != param_array.at(coll_idx_)) {
pl::ObPLCollection *coll = reinterpret_cast<pl::ObPLCollection*>(param_array.at(coll_idx_));
if (pl::PL_NESTED_TABLE_TYPE == coll->get_type()
|| pl::PL_VARRAY_TYPE == coll->get_type()) {
OX (coll->set_first(OB_INVALID_INDEX));
OX (coll->set_last(OB_INVALID_INDEX));
}
}
}
OX(result.set_extend(attr_addr, res_type.get_extend_type(), extend_size));
} else {
ObObj* datum = reinterpret_cast<ObObj*>(attr_addr);
if (OB_FAIL(result.apply(*datum))) {
LOG_WARN("apply failed", K(ret), KPC(datum), K(result), K(get_result_type().get_obj_meta()));
ObObj *datum = reinterpret_cast<ObObj*>(attr_addr);
if (ObMaxType == datum->get_type()) { //means has been deleted
ret = OB_READ_NOTHING;
LOG_WARN("accessing deleted element, no data found", K(ret), KPC(datum), K(result));
} else if (OB_FAIL(result.apply(*datum))) {
LOG_WARN("apply failed", K(ret), KPC(datum), K(result), K(res_type));
}
if (OB_SUCC(ret)) {
if ((ObLongTextType == result.get_meta().get_type() && get_result_type().get_obj_meta().is_lob_locator()) ||
(result.get_meta().is_lob_locator() && ObLongTextType == get_result_type().get_type())) {
} else if (!result.is_null() && result.get_meta().get_type() != get_result_type().get_obj_meta().get_type()) {
if ((ObLongTextType == result.get_meta().get_type()
&& res_type.is_lob_locator())
|| (result.get_meta().is_lob_locator() && ObLongTextType == res_type.get_type())) {
} else if (!result.is_null()
&& result.get_meta().get_type() != res_type.get_type()) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("obj access result meta not equel to expr type",
K(ret),
KPC(datum),
K(result),
K(get_result_type().get_obj_meta()));
K(ret), KPC(datum), K(result), K(res_type));
}
}
}
@ -158,17 +281,88 @@ int ObExprObjAccess::calc_result(
return ret;
}
int ObExprObjAccess::calc_resultN(ObObj& result, const ObObj* objs_stack, int64_t param_num, ObExprCtx& expr_ctx) const
int ObExprObjAccess::ExtraInfo::from_raw_expr(const ObObjAccessRawExpr &raw_access)
{
int ret = 0;
CK(0 != raw_access.get_get_attr_func_addr());
if (OB_SUCC(ret)) {
extend_size_ = raw_access.get_result_type().get_extend_size();
get_attr_func_ = raw_access.get_get_attr_func_addr();
for_write_ = raw_access.for_write();
property_type_ = raw_access.get_property();
access_idx_cnt_ = raw_access.get_access_idxs().count();
coll_idx_ = OB_INVALID_INDEX;
if (raw_access.get_access_idxs().at(0).elem_type_.is_collection_type()) {
coll_idx_ = raw_access.get_access_idxs().at(0).var_index_;
}
OZ(param_idxs_.init(raw_access.get_var_indexs().count()));
OZ(param_idxs_.assign(raw_access.get_var_indexs()));
}
return ret;
}
int ObExprObjAccess::cg_expr(ObExprCGCtx &op_cg_ctx,
const ObRawExpr &raw_expr, ObExpr &rt_expr) const
{
int ret = OB_SUCCESS;
CK(OB_NOT_NULL(expr_ctx.phy_plan_ctx_));
if (OB_SUCC(ret)) {
const ParamStore& param_store = expr_ctx.phy_plan_ctx_->get_param_store();
if (OB_FAIL(calc_result(result, objs_stack, param_num, param_store))) {
LOG_WARN("failed to calc result inner", K(ret));
ObIAllocator &alloc = *op_cg_ctx.allocator_;
ExtraInfo *info = OB_NEWx(ExtraInfo, (&alloc), alloc, T_OBJ_ACCESS_REF);
if (NULL == info) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_WARN("allocate memory failed", K(ret));
} else {
const ObObjAccessRawExpr &raw_access = static_cast<const ObObjAccessRawExpr &>(raw_expr);
CK(0 != raw_access.get_get_attr_func_addr());
if (OB_SUCC(ret)) {
info->extend_size_ = raw_expr.get_result_type().get_extend_size();
info->get_attr_func_ = raw_access.get_get_attr_func_addr();
info->for_write_ = raw_access.for_write();
info->property_type_ = raw_access.get_property();
info->access_idx_cnt_ = raw_access.get_access_idxs().count();
int64_t coll_idx = OB_INVALID_INDEX;
if (raw_access.get_access_idxs().at(0).elem_type_.is_collection_type()) {
coll_idx = raw_access.get_access_idxs().at(0).var_index_;
}
info->coll_idx_ = coll_idx;
OZ(info->param_idxs_.init(raw_access.get_var_indexs().count()));
OZ(info->param_idxs_.assign(raw_access.get_var_indexs()));
}
if (OB_SUCC(ret)) {
rt_expr.extra_info_ = info;
rt_expr.eval_func_ = eval_obj_access;
}
}
return ret;
}
int ObExprObjAccess::eval_obj_access(const ObExpr &expr,
ObEvalCtx &ctx,
ObDatum &expr_datum)
{
int ret = OB_SUCCESS;
const ExtraInfo *info = static_cast<const ExtraInfo *>(expr.extra_info_);
const ParamStore &param_store = ctx.exec_ctx_.get_physical_plan_ctx()->get_param_store();
OZ(expr.eval_param_value(ctx));
ObObj params[expr.arg_cnt_];
for (int64_t i = 0; OB_SUCC(ret) && i < expr.arg_cnt_; i++) {
const ObExpr *e = expr.args_[i];
const ObDatum &d = e->locate_expr_datum(ctx);
OZ(d.to_obj(params[i], e->obj_meta_, e->obj_datum_map_));
}
ObObj result;
OZ(info->calc(result,
expr.obj_meta_,
info->extend_size_,
param_store,
params,
expr.arg_cnt_));
OZ(expr_datum.from_obj(result, expr.obj_datum_map_));
return ret;
}
} // namespace sql
} // namespace oceanbase