125 lines
3.7 KiB
C++
125 lines
3.7 KiB
C++
// Copyright 2015-2016 Alibaba Inc. All Rights Reserved.
|
|
// Author:
|
|
// LuoFan
|
|
// Normalizer:
|
|
// LuoFan
|
|
|
|
|
|
#define USING_LOG_PREFIX SQL_QRR
|
|
#include "sql/udr/ob_udr_struct.h"
|
|
|
|
namespace oceanbase
|
|
{
|
|
namespace sql
|
|
{
|
|
|
|
OB_SERIALIZE_MEMBER(FixedParamValue, idx_, raw_text_);
|
|
OB_SERIALIZE_MEMBER(DynamicParamInfo, raw_param_idx_, question_mark_idx_);
|
|
|
|
DEFINE_SERIALIZE(QuestionMarkDefNameCtx)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
const int64_t serialize_size = get_serialize_size();
|
|
if (OB_ISNULL(buf) || OB_UNLIKELY(serialize_size > buf_len - pos)) {
|
|
ret = OB_SIZE_OVERFLOW;
|
|
LOG_WARN("size overflow", K(ret), KP(buf), K(serialize_size), "remain", buf_len - pos);
|
|
} else if (OB_FAIL(serialization::encode_vi64(buf, buf_len, pos, count_))) {
|
|
LOG_WARN("failed to decode count", K(ret));
|
|
} else {
|
|
for (int64_t i = 0; i < count_ && OB_SUCC(ret); ++i) {
|
|
char *ptr = name_[i];
|
|
const int64_t len = strlen(ptr);
|
|
if (OB_FAIL(serialization::encode_vstr(buf, buf_len, pos, ptr, len))) {
|
|
LOG_WARN("string serialize failed", K(ret));
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
DEFINE_DESERIALIZE(QuestionMarkDefNameCtx)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
const int64_t min_needed_size = 1;
|
|
if (OB_ISNULL(buf) || OB_UNLIKELY((data_len - pos) < min_needed_size)) {
|
|
ret = OB_INVALID_ARGUMENT;
|
|
LOG_WARN("invalid argument", K(ret), KP(buf), "remain", data_len - pos);
|
|
} else if (OB_FAIL(serialization::decode_vi64(buf, data_len, pos, &count_))) {
|
|
LOG_WARN("failed to encode count", K(data_len), K(pos), K(count_), K(ret));
|
|
} else if (OB_ISNULL(name_ = (char **)allocator_.alloc(sizeof(char*) * count_))) {
|
|
ret = OB_ALLOCATE_MEMORY_FAILED;
|
|
LOG_WARN("alloc memory failed", K(ret));
|
|
} else {
|
|
for (int64_t i = 0; i < count_ && OB_SUCC(ret); ++i) {
|
|
char *ptr = nullptr;
|
|
int64_t len = 0;
|
|
ptr = const_cast<char *>(common::serialization::decode_vstr(buf, data_len, pos, &len));
|
|
if (OB_ISNULL(ptr)) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("decode NULL string", K(ret));
|
|
} else {
|
|
name_[i] = ptr;
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
DEFINE_GET_SERIALIZE_SIZE(QuestionMarkDefNameCtx)
|
|
{
|
|
int64_t size = 0;
|
|
size += serialization::encoded_length_vi64(count_);
|
|
for (int64_t i = 0; i < count_; ++i) {
|
|
const int64_t len = strlen(name_[i]);
|
|
size += serialization::encoded_length_vstr(len);
|
|
}
|
|
return size;
|
|
}
|
|
|
|
int QuestionMarkDefNameCtx::assign(const char **name, const int64_t count)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
count_ = count;
|
|
if (OB_ISNULL(name_ = (char **)allocator_.alloc(sizeof(char*) * count))) {
|
|
ret = OB_ALLOCATE_MEMORY_FAILED;
|
|
LOG_WARN("alloc memory failed", K(ret));
|
|
} else {
|
|
for (int64_t i = 0; i < count && OB_SUCC(ret); ++i) {
|
|
char *ptr = nullptr;
|
|
const int32_t len = sizeof(strlen(name[i]));
|
|
if (OB_ISNULL(ptr = (char *)allocator_.alloc(len))) {
|
|
ret = OB_ALLOCATE_MEMORY_FAILED;
|
|
LOG_WARN("alloc memory failed", K(ret));
|
|
} else {
|
|
MEMCPY(ptr, name[i], len);
|
|
ptr[len] = '\0';
|
|
name_[i] = ptr;
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObUDRInfo::assign(const ObUDRInfo &other)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
tenant_id_ = other.tenant_id_;
|
|
pattern_digest_ = other.pattern_digest_;
|
|
rule_id_ = other.rule_id_;
|
|
rule_version_ = other.rule_version_;
|
|
rule_status_ = other.rule_status_;
|
|
coll_type_ = other.coll_type_;
|
|
db_name_ = other.db_name_;
|
|
rule_name_ = other.rule_name_;
|
|
pattern_ = other.pattern_;
|
|
replacement_ = other.replacement_;
|
|
normalized_pattern_ = other.normalized_pattern_;
|
|
fixed_param_infos_str_ = other.fixed_param_infos_str_;
|
|
dynamic_param_infos_str_ = other.dynamic_param_infos_str_;
|
|
question_mark_ctx_str_ = other.question_mark_ctx_str_;
|
|
return ret;
|
|
}
|
|
|
|
} // namespace sql end
|
|
} // namespace oceanbase end
|