hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
335cda36b46b4ece8975ea11ca45d87027a29e87
oceanbase/src/sql/plan_cache/ob_prepare_stmt_struct.cpp

709 lines
22 KiB
C++
Raw Blame History

/**
* Copyright (c) 2021 OceanBase
* OceanBase CE is licensed under Mulan PubL v2.
* You can use this software according to the terms and conditions of the Mulan PubL v2.
* You may obtain a copy of Mulan PubL v2 at:
* http://license.coscl.org.cn/MulanPubL-2.0
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PubL v2 for more details.
*/
#define USING_LOG_PREFIX SQL_PC
#include "ob_prepare_stmt_struct.h"
#include "lib/utility/utility.h"
#include "lib/utility/ob_print_utils.h"
#include "sql/plan_cache/ob_ps_sql_utils.h"
#include "sql/plan_cache/ob_ps_cache.h"
#include "sql/resolver/cmd/ob_call_procedure_stmt.h"
#include "sql/parser/parse_node.h"
namespace oceanbase
{
using namespace common;
namespace sql
{
int ObPsSqlKey::deep_copy(const ObPsSqlKey &other, common::ObIAllocator &allocator)
{
int ret = OB_SUCCESS;
flag_ = other.flag_;
db_id_ = other.db_id_;
inc_id_ = other.inc_id_;
if (OB_FAIL(ObPsSqlUtils::deep_copy_str(allocator, other.ps_sql_, ps_sql_))) {
LOG_WARN("deep copy str failed", K(other), K(ret));
}
return ret;
}
ObPsSqlKey &ObPsSqlKey::operator=(const ObPsSqlKey &other)
{
if (this != &other) {
flag_ = other.flag_;
db_id_ = other.db_id_;
inc_id_ = other.inc_id_;
ps_sql_ = other.ps_sql_;
}
return *this;
}
bool ObPsSqlKey::operator==(const ObPsSqlKey &other) const
{
return flag_ == other.flag_ &&
db_id_ == other.db_id_ &&
inc_id_ == other.inc_id_ &&
ps_sql_.compare(other.ps_sql_) == 0;
}
int64_t ObPsSqlKey::hash() const
{
uint64_t hash_val = 0;
hash_val = murmurhash(&flag_, sizeof(uint32_t), hash_val);
hash_val = murmurhash(&db_id_, sizeof(uint64_t), hash_val);
hash_val = murmurhash(&inc_id_, sizeof(uint64_t), hash_val);
ps_sql_.hash(hash_val, hash_val);
return hash_val;
}
ObPsStmtItem::ObPsStmtItem()
: ref_count_(1),
stmt_id_(OB_INVALID_STMT_ID),
is_expired_evicted_(false),
allocator_(NULL),
external_allocator_(NULL)
{
}
ObPsStmtItem::ObPsStmtItem(const ObPsStmtId ps_stmt_id)
: ref_count_(1),
stmt_id_(ps_stmt_id),
is_expired_evicted_(false),
allocator_(NULL),
external_allocator_(NULL)
{
}
ObPsStmtItem::ObPsStmtItem(ObIAllocator *inner_allocator,
ObIAllocator *external_allocator)
: ref_count_(1),
stmt_id_(OB_INVALID_STMT_ID),
is_expired_evicted_(false),
allocator_(inner_allocator),
external_allocator_(external_allocator)
{}
int ObPsStmtItem::deep_copy(const ObPsStmtItem &other)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(allocator_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("allocator is invalid", K(ret));
} else {
stmt_id_ = other.stmt_id_;
if (OB_FAIL(ps_key_.deep_copy(other.get_sql_key(), *allocator_))) {
LOG_WARN("deep copy ps key failed", K(other), K(ret));
}
}
return ret;
}
ObPsStmtItem &ObPsStmtItem::operator=(const ObPsStmtItem &other)
{
if (this != &other) {
ref_count_ = other.ref_count_;
ps_key_ = other.get_sql_key();
stmt_id_ = other.get_ps_stmt_id();
is_expired_evicted_ = other.is_expired_evicted_;
}
return *this;
}
bool ObPsStmtItem::is_valid() const
{
bool bret = false;
if (!ps_key_.ps_sql_.empty()
&& OB_INVALID_STMT_ID != stmt_id_) {
bret = true;
}
return bret;
}
int ObPsStmtItem::get_convert_size(int64_t &cv_size) const
{
cv_size = sizeof(ObPsStmtItem);
cv_size += ps_key_.ps_sql_.length() + 1;
return OB_SUCCESS;
}
bool ObPsStmtItem::check_erase_inc_ref_count()
{
bool need_erase = false;
bool cas_ret = false;
do {
need_erase = false;
int64_t cur_ref_cnt = ATOMIC_LOAD(&ref_count_);
int64_t next_ref_cnt = cur_ref_cnt + 1;
if (0 == cur_ref_cnt) {
need_erase = true;
break;
}
cas_ret = ATOMIC_BCAS(&ref_count_, cur_ref_cnt, next_ref_cnt);
LOG_TRACE("ps item check erase inc ref count after cas", K(cur_ref_cnt),
K(next_ref_cnt), K(cas_ret));
} while (!cas_ret);
LOG_TRACE("ps item inc ref count", K(*this), K(need_erase));
return need_erase;
}
void ObPsStmtItem::dec_ref_count_check_erase()
{
int ret = OB_SUCCESS;
LOG_TRACE("ps item dec ref count", K(*this));
int64_t ref_count = ATOMIC_SAF(&ref_count_, 1);
if (ref_count > 0) {
LOG_TRACE("ps item dec ref count", K(ref_count));
} else if (0 == ref_count) {
LOG_INFO("free ps item", K(ref_count), K(*this));
ObPsStmtItem *ps_item = this;
ObIAllocator *allocator = NULL;
if (OB_ISNULL(allocator = get_external_allocator())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(allocator), K(ret));
} else {
ps_item->~ObPsStmtItem();
allocator->free(ps_item);
}
} else if (ref_count < 0) {
BACKTRACE(ERROR, true, "ObPsStmtItem %p ref count < 0, ref_count = %ld", this, ref_count);
}
}
int ObPsSqlMeta::add_param_field(const ObField &field)
{
int ret = OB_SUCCESS;
ObField tmp_field;
if (OB_FAIL(tmp_field.full_deep_copy(field, allocator_))) {
LOG_WARN("deep copy field failed", K(ret));
} else if (OB_FAIL(param_fields_.push_back(tmp_field))) {
LOG_WARN("push back field param failed", K(ret));
} else {
LOG_DEBUG("succ to push back param field", K(field));
}
return ret;
}
int ObPsSqlMeta::add_column_field(const ObField &field)
{
int ret = OB_SUCCESS;
ObField tmp_field;
if (OB_FAIL(tmp_field.full_deep_copy(field, allocator_))) {
LOG_WARN("deep copy field failed", K(ret));
} else if (OB_FAIL(column_fields_.push_back(tmp_field))) {
LOG_WARN("push back field param failed", K(ret));
} else {
LOG_DEBUG("succ to push back column field", K(field));
}
return ret;
}
int ObPsSqlMeta::reverse_fileds(int64_t param_size, int64_t column_size)
{
int64_t ret = OB_SUCCESS;
if (OB_FAIL(param_fields_.init(param_size))) {
LOG_WARN("fail to init param fields", K(ret), K(param_size));
} else if (OB_FAIL(column_fields_.init(column_size))) {
LOG_WARN("fail to init column fields", K(ret), K(column_size));
}
return ret;
}
int ObPsSqlMeta::deep_copy(const ObPsSqlMeta &sql_meta)
{
int ret = OB_SUCCESS;
const int64_t column_size = sql_meta.get_column_size();
const int64_t param_size = sql_meta.get_param_size();
if (OB_FAIL(reverse_fileds(param_size, column_size))) {
LOG_WARN("reserve_fix_size failed", K(column_size), K(param_size));
} else {
for (int64_t i = 0; OB_SUCC(ret) && i < param_size; ++i) {
if (OB_FAIL(add_param_field(sql_meta.get_param_fields().at(i)))) {
LOG_WARN("add column field failed", K(ret));
}
}
for (int64_t i = 0; OB_SUCC(ret) && i < column_size; ++i) {
if (OB_FAIL(add_column_field(sql_meta.get_column_fields().at(i)))) {
LOG_WARN("add column field failed", K(ret));
}
}
}
return ret;
}
int ObPsSqlMeta::get_convert_size(int64_t &cv_size) const
{
int ret = OB_SUCCESS;
cv_size = 0;
int64_t convert_size = sizeof(ObPsSqlMeta);
for (int i = 0 ; OB_SUCC(ret) && i < column_fields_.count(); ++i) {
convert_size += column_fields_.at(i).get_convert_size();
}
for (int i = 0; OB_SUCC(ret) && i < param_fields_.count(); ++i) {
convert_size += param_fields_.at(i).get_convert_size();
}
if (OB_SUCC(ret)) {
cv_size = convert_size;
}
return ret;
}
ObPsStmtInfo::ObPsStmtInfo(ObIAllocator *inner_allocator)
: stmt_type_(stmt::T_NONE),
ps_stmt_checksum_(0),
ps_sql_meta_(inner_allocator),
ref_count_(1),
question_mark_count_(0),
can_direct_use_param_(false),
item_and_info_size_(0),
last_closed_timestamp_(0),
dep_objs_(NULL),
dep_objs_cnt_(0),
ps_item_(NULL),
tenant_version_(OB_INVALID_VERSION),
is_expired_(false),
is_expired_evicted_(false),
allocator_(inner_allocator),
external_allocator_(inner_allocator),
num_of_returning_into_(-1),
no_param_sql_(),
is_sensitive_sql_(false),
raw_sql_(),
raw_params_(inner_allocator),
raw_params_idx_(inner_allocator),
literal_stmt_type_(stmt::T_NONE)
{
}
ObPsStmtInfo::ObPsStmtInfo(ObIAllocator *inner_allocator,
ObIAllocator *external_allocator)
: stmt_type_(stmt::T_NONE),
ps_stmt_checksum_(0),
ps_sql_meta_(inner_allocator),
ref_count_(1),
question_mark_count_(0),
can_direct_use_param_(false),
item_and_info_size_(0),
last_closed_timestamp_(0),
dep_objs_(NULL),
dep_objs_cnt_(0),
ps_item_(NULL),
tenant_version_(OB_INVALID_VERSION),
is_expired_(false),
is_expired_evicted_(false),
allocator_(inner_allocator),
external_allocator_(external_allocator),
num_of_returning_into_(-1),
no_param_sql_(),
is_sensitive_sql_(false),
raw_sql_(),
raw_params_(inner_allocator),
raw_params_idx_(inner_allocator),
literal_stmt_type_(stmt::T_NONE)
{
}
bool ObPsStmtInfo::is_valid() const
{
return !ps_key_.ps_sql_.empty();
}
int ObPsStmtInfo::assign_no_param_sql(const common::ObString &no_param_sql)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(allocator_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("allocator is invalid", K(ret));
} else if (OB_FAIL(ObPsSqlUtils::deep_copy_str(*allocator_, no_param_sql, no_param_sql_))) {
LOG_WARN("deep copy no param sql failed", K(no_param_sql), K(ret));
}
return ret;
}
int ObPsStmtInfo::assign_raw_sql(const common::ObString &raw_sql)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(allocator_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("allocator is invalid", K(ret));
} else if (OB_FAIL(ObPsSqlUtils::deep_copy_str(*allocator_, raw_sql, raw_sql_))) {
LOG_WARN("deep copy raw sql failed", K(raw_sql), K(ret));
}
return ret;
}
int ObPsStmtInfo::add_fixed_raw_param(const ObPCParam &node)
{
int ret = OB_SUCCESS;
char *buf = NULL;
ObPCParam *param = NULL;
int64_t alloc_size = sizeof(ObPCParam) + sizeof(ParseNode);
if (OB_ISNULL(buf = static_cast<char *>(allocator_->alloc(alloc_size)))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_WARN("fail to alloc memory", K(ret));
} else {
MEMSET(buf, 0, alloc_size);
param = reinterpret_cast<ObPCParam *>(buf);
buf += sizeof(ObPCParam);
param->node_ = reinterpret_cast<ParseNode *>(buf);
if (OB_FAIL(deep_copy_parse_node(allocator_, node.node_, param->node_))) {
LOG_WARN("fail to deep copy parse node", K(ret));
} else if (FALSE_IT(param->flag_ = node.flag_)) {
} else {
if (NEG_PARAM == param->flag_) {
int64_t tmp_pos = 0;
if ('-' != param->node_->str_value_[tmp_pos]) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("expected neg sign here", K(tmp_pos), K(ObString(param->node_->str_len_,
param->node_->str_value_)));
} else {
tmp_pos += 1;
for (; tmp_pos < param->node_->str_len_ && isspace(param->node_->str_value_[tmp_pos]); tmp_pos++);
const_cast<char *>(param->node_->str_value_)[tmp_pos - 1] = '-';
param->node_->str_value_ += (tmp_pos - 1);
param->node_->str_len_ -= (tmp_pos - 1);
}
}
OZ (raw_params_.push_back(param));
}
}
return ret;
}
int ObPsStmtInfo::assign_fixed_raw_params(const common::ObIArray<int64_t> &param_idxs,
const common::ObIArray<ObPCParam *> &raw_params)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(allocator_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("allocator is invalid", K(ret));
} else if (OB_FAIL(raw_params_.reserve(param_idxs.count()))) {
LOG_WARN("failed to reserve array", K(ret));
} else {
for (int64_t i = 0; OB_SUCC(ret) && i < param_idxs.count(); ++i) {
ObPCParam *tmp_param = NULL;
const int64_t idx = param_idxs.at(i);
if (idx >= raw_params.count()) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid idx", K(ret), K(idx), K(raw_params.count()));
} else if (OB_ISNULL(tmp_param = raw_params.at(idx)) || OB_ISNULL(tmp_param->node_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("node is null", K(idx), K(tmp_param));
} else if (OB_FAIL(add_fixed_raw_param(*tmp_param))) {
LOG_WARN("fail to add fixed raw param", K(ret));
}
}
}
if (OB_SUCC(ret)) {
if (OB_FAIL(raw_params_idx_.assign(param_idxs))) {
LOG_WARN("failed to assign raw params idx", K(ret));
}
}
return ret;
}
int ObPsStmtInfo::deep_copy_fixed_raw_params(const common::ObIArray<int64_t> &param_idxs,
const common::ObIArray<ObPCParam *> &raw_params)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(allocator_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("allocator is invalid", K(ret));
} else if (OB_FAIL(raw_params_.reserve(raw_params.count()))) {
LOG_WARN("failed to reserve array", K(ret));
} else {
for (int64_t i = 0; OB_SUCC(ret) && i < raw_params.count(); ++i) {
if (OB_FAIL(add_fixed_raw_param(*raw_params.at(i)))) {
LOG_WARN("fail to add fixed raw param", K(ret), K(i));
}
}
}
if (OB_SUCC(ret)) {
if (OB_FAIL(raw_params_idx_.assign(param_idxs))) {
LOG_WARN("failed to assign raw params idx", K(ret));
}
}
return ret;
}
int ObPsStmtInfo::deep_copy(const ObPsStmtInfo &other)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(allocator_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("allocator is invalid", K(ret));
} else {
stmt_type_ = other.stmt_type_;
ps_stmt_checksum_ = other.ps_stmt_checksum_;
question_mark_count_ = other.question_mark_count_;
num_of_returning_into_ = other.num_of_returning_into_;
is_sensitive_sql_ = other.is_sensitive_sql_;
can_direct_use_param_ = other.can_direct_use_param();
item_and_info_size_ = other.item_and_info_size_;
ps_item_ = other.ps_item_;
tenant_version_ = other.tenant_version_;
is_expired_ = other.is_expired_;
is_expired_evicted_ = other.is_expired_evicted_;
literal_stmt_type_ = other.literal_stmt_type_;
if (other.get_dep_objs_cnt() > 0) {
dep_objs_cnt_ = other.get_dep_objs_cnt();
if (NULL == (dep_objs_ = reinterpret_cast<ObSchemaObjVersion *>
(allocator_->alloc(dep_objs_cnt_ * sizeof(ObSchemaObjVersion))))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_WARN("fail to alloc memory", K(ret), K(dep_objs_cnt_));
} else {
MEMCPY(dep_objs_, other.get_dep_objs(), dep_objs_cnt_*sizeof(ObSchemaObjVersion));
}
}
if (OB_FAIL(ret)) {
// do nothing
} else if (OB_FAIL(ps_key_.deep_copy(other.get_sql_key(), *allocator_))) {
LOG_WARN("failed to deep copy ps key", K(ret), K(other));
} else if (OB_FAIL(ObPsSqlUtils::deep_copy_str(*allocator_, other.get_no_param_sql(),
no_param_sql_))) {
LOG_WARN("deep copy str failed", K(other), K(ret));
} else if (OB_FAIL(ObPsSqlUtils::deep_copy_str(*allocator_, other.get_raw_sql(),
raw_sql_))) {
LOG_WARN("deep copy str failed", K(other), K(ret));
} else if (OB_FAIL(deep_copy_fixed_raw_params(other.raw_params_idx_, other.raw_params_))) {
LOG_WARN("deep copy fixed raw params failed", K(other), K(ret));
} else if (OB_FAIL(ps_sql_meta_.deep_copy(other.get_ps_sql_meta()))) {
LOG_WARN("deep copy ps sql meta faield", K(ret));
}
}
return ret;
}
int ObPsStmtInfo::add_column_field(const ObField &field)
{
int ret = OB_SUCCESS;
if (OB_FAIL(ps_sql_meta_.add_column_field(field))) {
LOG_WARN("add column field failed", K(ret));
}
return ret;
}
int ObPsStmtInfo::add_param_field(const ObField &param)
{
int ret = OB_SUCCESS;
if (OB_FAIL(ps_sql_meta_.add_param_field(param))) {
LOG_WARN("add param field failed", K(ret));
}
return ret;
}
int ObPsStmtInfo::get_convert_size(int64_t &cv_size) const
{
int ret = OB_SUCCESS;
cv_size = 0;
int64_t convert_size = sizeof(ObPsStmtInfo);
convert_size += ps_key_.ps_sql_.length() + 1;
convert_size += no_param_sql_.length() + 1;
convert_size += raw_sql_.length() + 1;
int64_t meta_convert_size = 0;
int64_t raw_params_size = 0;
if (OB_FAIL(ps_sql_meta_.get_convert_size(meta_convert_size))) {
LOG_WARN("get sql meta convert size failed", K(ret));
}
for (int i = 0; OB_SUCC(ret) && i < raw_params_.count(); ++i) {
const ObPCParam *param = raw_params_.at(i);
if (OB_ISNULL(param)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("is null", K(ret));
} else if (OB_FAIL(get_deep_copy_size(param->node_, &raw_params_size))) {
LOG_WARN("failed to get deeps copy size", K(ret));
} else {
raw_params_size += sizeof(ObPCParam);
}
}
if (OB_SUCC(ret)) {
raw_params_size += (raw_params_.count() * sizeof(ObPCParam*));
raw_params_size += (raw_params_idx_.count() * sizeof(int64_t));
convert_size += meta_convert_size;
convert_size += raw_params_size;
convert_size += dep_objs_cnt_ * sizeof(share::schema::ObSchemaObjVersion);
cv_size = convert_size;
}
return ret;
}
/*
对于ps cache并发场景:
A线程接收到close请求,B线程接收到prepare_command请求, 且在接收请求前ref_cnt=1
ps cache中, ps_id->stmt_info这个map:
1. A线程在close stmt时, 会先将引用计数减1, 如果发现为0, 则将stmt_info从map
上摘除, 并释放stmt_info资源
2. B线程在获取stmt_info时(prepare), 会先判定stmt_info是否为0, 如果为0则表示
该stmt_info即将被删除, 则直接退出并进行获取重试; 不为0则将引用计数加1;
3. 上面的两个操作, 操作a. 减引用计数,并判断是否删除, 操作b. 判断是否已删除,
以及加引用计数, 这两个操作是需要互斥执行的, 否则会出现下图的并发问题:
A线程(close_command) B线程(prepare_command)
| read_atomic
(ref_cnt<=0判断为false)
read_atomic
(ref_cnt-1 = 0, is_erase=true)
read_atomic_end
|
|
| (ref_cnt+1=1)
read_atomic_end
|
stmt_info_map_.erase
free(stmt_info_)
此时stmt_info_内存已释放,
当再访问时可能core,
或者继续进行execute时,
会报-4201(NOT_EXIST)
4. 从面的过程可以看到, 其实操作a和操作b是在hash_map中read_atomic中执行的,
但read_atomic这个接口加的是读锁,并不互斥,上面两个操作的互斥性需要另外保障,
因此加入了如下处理方式, 使用这两个接口, 确保操作a和操作b的原子性:
1) check_erase_inc_ref_count: 使用cas确保操作b在判断完是否erase和加引用
计数过程是中间没有修改引用计数的, 如果修改了, 则重新进行操作b的原子处理;
2) dec_ref_count_check_erase: 原子减引用计数, 并返回减引用计数后结果,
判断是否已erase
*/
bool ObPsStmtInfo::check_erase_inc_ref_count()
{
bool need_erase = false;
bool cas_ret = false;
do {
need_erase = false;
int64_t cur_ref_cnt = ATOMIC_LOAD(&ref_count_);
int64_t next_ref_cnt = cur_ref_cnt + 1;
if (0 == cur_ref_cnt) {
need_erase = true;
break;
}
cas_ret = ATOMIC_BCAS(&ref_count_, cur_ref_cnt, next_ref_cnt);
LOG_TRACE("ps info check erase inc ref count after cas", K(cur_ref_cnt),
K(next_ref_cnt), K(cas_ret));
} while (!cas_ret);
LOG_TRACE("ps info inc ref count", K(*this), K(need_erase));
return need_erase;
}
bool ObPsStmtInfo::dec_ref_count_check_erase()
{
bool need_erase = false;
LOG_TRACE("ps info dec ref count", K(*this));
int64_t ref_count = ATOMIC_SAF(&ref_count_, 1);
if (ref_count > 0) {
if (ref_count == 1) {
last_closed_timestamp_ = common::ObTimeUtility::current_time();
}
LOG_TRACE("ps info dec ref count", K(ref_count), K(*this));
} else if (0 == ref_count) {
need_erase = true;
LOG_INFO("free ps info", K(ref_count), K(*this), K(need_erase));
} else if (ref_count < 0) {
BACKTRACE_RET(ERROR, OB_ERR_UNEXPECTED, true, "ObPsStmtInfo %p ref count < 0, ref_count = %ld", this, ref_count);
}
return need_erase;
}
int64_t ObPsStmtInfo::to_string(char *buf, const int64_t buf_len) const
{
int64_t pos = 0;
int ret = OB_SUCCESS;
J_OBJ_START();
J_KV(K_(ps_key),
K_(ref_count),
K_(can_direct_use_param),
K_(question_mark_count),
K_(last_closed_timestamp),
K_(tenant_version),
K_(no_param_sql),
K_(num_of_returning_into));
J_COMMA();
J_NAME("columns");
J_COLON();
J_ARRAY_START();
for (int64_t i = 0 ; OB_SUCC(ret) && i < ps_sql_meta_.get_column_fields().count(); ++i) {
J_KV("column", ps_sql_meta_.get_column_fields().at(i));
}
J_ARRAY_END();
J_COMMA();
J_NAME("params");
J_COLON();
J_ARRAY_START();
for (int64_t i = 0 ; OB_SUCC(ret) && i < ps_sql_meta_.get_param_fields().count(); ++i) {
J_KV("params", ps_sql_meta_.get_param_fields().at(i));
}
J_ARRAY_END();
J_OBJ_END();
return pos;
}
ObPsStmtInfoGuard::~ObPsStmtInfoGuard()
{
int ret = OB_SUCCESS;
if (NULL != ps_cache_) {
if (NULL != stmt_info_) {
if (OB_FAIL(ps_cache_->deref_stmt_info(stmt_id_))) {
LOG_WARN("deref stmt item faield", K(ret), K(*stmt_info_), K_(stmt_id));
}
LOG_TRACE("destroy PsStmtInfo Guard", K_(stmt_id));
} else {
LOG_WARN("stmt info is null", K(stmt_id_));
}
} else {
LOG_WARN("ps_cache is null", K(stmt_id_), K(stmt_info_));
}
}
int ObPsStmtInfoGuard::get_ps_sql(ObString &ps_sql)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(stmt_info_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("stmt info is null", K(ret));
} else {
ps_sql = stmt_info_->get_ps_sql();
}
return ret;
}
int TypeInfo::deep_copy(common::ObIAllocator *allocator,
const TypeInfo* other)
{
int ret = OB_SUCCESS;
if (this != other) {
CK (OB_NOT_NULL(allocator));
CK (OB_NOT_NULL(other));
OZ (ob_write_string(*allocator, other->relation_name_, relation_name_));
OZ (ob_write_string(*allocator, other->package_name_, package_name_));
OZ (ob_write_string(*allocator, other->type_name_, type_name_));
OX (elem_type_ = other->elem_type_);
OX (is_elem_type_ = other->is_elem_type_);
OX (is_basic_type_ = other->is_basic_type_);
}
return ret;
}
} // end of sql
} // end of oceanbase
Reference in New Issue View Git Blame Copy Permalink