TEST(TestLogMysqlAdaptor, init)
{
ObLogConfig config;
ObLogServerSelector server_selector;
ObLogRpcStub rpc_stub;
ObLogSchemaGetter schema_getter;
ObLogMysqlAdaptor mysql_adaptor;
config.init("./liboblog.conf");
server_selector.init(config);
rpc_stub.init();
schema_getter.init(&server_selector, &rpc_stub);
mysql_adaptor.init(config, &schema_getter);
ObObj objs[4];
objs[0].set_int(13490859);
objs[1].set_int(0);
objs[2].set_int(1);
ObString str;
str.assign_ptr((char*)("fenxiao-001"), 11);
objs[3].set_varchar(str);
ObRowkey rk;
rk.assign(objs, 4);
const IObLogColValue *list = NULL;
int ret = mysql_adaptor.query_whole_row(3001, rk, list);
TBSYS_LOG(INFO, "query_whole_row ret=%d", ret);
const IObLogColValue *iter = list;
while (NULL != iter)
{
std::string str;
iter->to_str(str);
TBSYS_LOG(INFO, "[VALUE] [%s]", str.c_str());
iter = iter->get_next();
}
////////////////////
objs[0].set_int(2222504619);
str.assign_ptr((char*)("IC"), 2);
objs[3].set_varchar(str);
list = NULL;
ret = mysql_adaptor.query_whole_row(3001, rk, list);
TBSYS_LOG(INFO, "query_whole_row ret=%d", ret);
iter = list;
while (NULL != iter)
{
std::string str;
iter->to_str(str);
TBSYS_LOG(INFO, "[VALUE] [%s]", str.c_str());
iter = iter->get_next();
}
}
int resolve_set_password_stmt(ResultPlan* result_plan,
ParseNode* node,
uint64_t& query_id)
{
OB_ASSERT(result_plan);
OB_ASSERT(node && node->type_ == T_SET_PASSWORD && node->num_child_ == 2);
int& ret = result_plan->err_stat_.err_code_ = OB_SUCCESS;
ObSetPasswordStmt *stmt = NULL;
if (OB_SUCCESS != (ret = prepare_resolve_stmt(result_plan, query_id, stmt)))
{
}
else
{
ObString user;
if (NULL != node->children_[0])
{
user.assign_ptr(const_cast<char*>(node->children_[0]->str_value_),
static_cast<int32_t>(strlen(node->children_[0]->str_value_)));
}
ObString password = ObString::make_string(node->children_[1]->str_value_);
if (OB_SUCCESS != (ret = stmt->set_user_password(user, password)))
{
PARSER_LOG("Failed to set UserPasswordStmt");
}
}
return ret;
}
uint64_t ObMetaTableColumnSchema::get_cid_by_idx(const int64_t i) const
{
uint64_t ret = OB_INVALID_ID;
if (i >= get_columns_num() || 0 > i)
{
TBSYS_LOG(ERROR, "invalid column index, i=%ld tid=%lu", i, table_schema_.table_id_);
}
else
{
ObString cname;
const int buf_len = meta_table_cname::STARTKEY_OBJ_PREFIX.length() + 8;
char cname_buf[buf_len];
cname_buf[0] = '\0';
if (i < static_cast<int64_t>(ARRAYSIZEOF(COLUMNS_NAME)))
{
cname = COLUMNS_NAME[i];
}
else
{
// start_rowkey_obj1, start_rowkey_obj2, ...
int len = snprintf(cname_buf, buf_len, "%.*s%ld", meta_table_cname::STARTKEY_OBJ_PREFIX.length(),
meta_table_cname::STARTKEY_OBJ_PREFIX.ptr(), i - ARRAYSIZEOF(COLUMNS_NAME) + 1);
cname.assign_ptr(cname_buf, len);
}
if (OB_SUCCESS != get_cid_by_name(cname, ret))
{
TBSYS_LOG(ERROR, "meta table column not found, cname=%.*s tid=%lu",
cname.length(), cname.ptr(), table_schema_.table_id_);
}
}
return ret;
}
TEST_F(ObObjCastTest, varchar_to_xxx)
{
ObExprObj in;
const char* cases[] = {"1970-1-1 8:0:0", "2012-9-24 16:59:60.000000", "-123456", "-123.456", "true", "false"};
int64_t int_expected[ARRAYSIZEOF(cases)] = {1970, 2012, -123456, -123, 0, 0};
float float_expected[ARRAYSIZEOF(cases)] = {1970.0f, 2012.0f, -123456.0f, -123.456f, 0.0f, 0.0f};
double double_expected[ARRAYSIZEOF(cases)] = {1970.0, 2012.0, -123456.0, -123.456, 0.0, 0.0};
int64_t pdt_expected[ARRAYSIZEOF(cases)] = {0, 1348477200000000, 0, 0, 0, 0};
bool bool_expected[ARRAYSIZEOF(cases)] = {false, false, false, false, true, false};
const char *dec_expected[ARRAYSIZEOF(cases)] = {"0", "0", "-123456", "-123.456", "0", "0"};
for (int64_t i = 0; i < static_cast<int64_t>(ARRAYSIZEOF(cases)); ++i)
{
ObString v;
v.assign_ptr(const_cast<char*>(cases[i]), static_cast<int32_t>(strlen(cases[i])));
in.set_varchar(v);
//printf("case %ld: %s\n", i, cases[i]);
MY_EXPECT(ObVarcharType, in, ObNullType, int_expected[i], cases[i]);
MY_EXPECT(ObVarcharType, in, ObIntType, int_expected[i], cases[i]);
MY_EXPECT(ObVarcharType, in, ObFloatType, float_expected[i], cases[i]);
MY_EXPECT(ObVarcharType, in, ObDoubleType, double_expected[i], cases[i]);
MY_EXPECT(ObVarcharType, in, ObDateTimeType, (pdt_expected[i]/1000000L), cases[i]);
MY_EXPECT(ObVarcharType, in, ObPreciseDateTimeType, pdt_expected[i], cases[i]);
MY_EXPECT(ObVarcharType, in, ObVarcharType, int_expected[i], cases[i]);
MY_EXPECT(ObVarcharType, in, ObSeqType, int_expected[i], cases[i]);
MY_EXPECT(ObVarcharType, in, ObCreateTimeType, pdt_expected[i], cases[i]);
MY_EXPECT(ObVarcharType, in, ObModifyTimeType, pdt_expected[i], cases[i]);
MY_EXPECT(ObVarcharType, in, ObExtendType, int_expected[i], cases[i]);
MY_EXPECT(ObVarcharType, in, ObBoolType, bool_expected[i], cases[i]);
MY_EXPECT(ObVarcharType, in, ObDecimalType, int_expected[i], dec_expected[i]);
}
}
int ObUpsRowUtil::convert(const ObUpsRow &row, ObString &compact_row)
{
int ret = OB_SUCCESS;
ObCompactCellWriter cell_writer;
cell_writer.init(compact_row.ptr(), compact_row.size());
const ObObj *cell = NULL;
uint64_t table_id = OB_INVALID_ID;
uint64_t column_id = OB_INVALID_ID;
ObObj cell_clone;
if(row.get_is_delete_row())
{
if(OB_SUCCESS != (ret = cell_writer.row_delete()))
{
TBSYS_LOG(WARN, "append delete row fail:ret[%d]", ret);
}
}
for (int64_t i = 0; (OB_SUCCESS == ret) && i < row.get_column_num(); ++i)
{
if (OB_SUCCESS != (ret = row.raw_get_cell(i, cell, table_id, column_id)))
{
TBSYS_LOG(WARN, "failed to get cell, err=%d", ret);
break;
}
else
{
if(ObExtendType == cell->get_type() && ObActionFlag::OP_NOP == cell->get_ext())
{
//不用处理，OP_NOP不序列化
}
else if (OB_SUCCESS != (ret = cell_writer.append(column_id, *cell)))
{
if (OB_SIZE_OVERFLOW != ret)
{
TBSYS_LOG(WARN, "failed to append cell, err=%d", ret);
}
break;
}
}
} // end for i
if (OB_SUCCESS == ret)
{
if (OB_SUCCESS != (ret = cell_writer.row_finish()))
{
if (OB_SIZE_OVERFLOW != ret)
{
TBSYS_LOG(WARN, "failed to append cell, err=%d", ret);
}
}
else
{
compact_row.assign_ptr(compact_row.ptr(), (int32_t)(cell_writer.size()));
}
}
return ret;
}
ScanConds::ScanConds(const char* column_name, const ObLogicOperator& cond_op, ObString& value)
{
ObString name;
name.assign_ptr(const_cast<char*>(column_name), static_cast<int32_t>(strlen(column_name)));
ObObj obj;
obj.set_varchar(value);
EasyArray<ObSimpleCond>(ObSimpleCond(name, cond_op, obj));
}
int execute_sql(MockClient &client, const char* sql_query)
{
int ret = OB_SUCCESS;
ObString query;
query.assign_ptr(const_cast<char*>(sql_query), static_cast<int32_t>(strlen(sql_query)));
printf("execute_sql, query=[%.*s]...\n", query.length(), query.ptr());
ret = client.execute_sql(query, timeout);
printf("ret=%d\n", ret);
return ret;
}
void create_row_key(
CharArena& allocator,
ObString& rowkey,
const char* sk)
{
int64_t sz = strlen(sk);
char* msk = allocator.alloc(sz);
memcpy(msk, sk, sz);
rowkey.assign_ptr(msk, sz);
}
ScanConds& ScanConds::operator()(const char* column_name, const ObLogicOperator& cond_op, int64_t value)
{
ObString name;
name.assign_ptr(const_cast<char*>(column_name), static_cast<int32_t>(strlen(column_name)));
ObObj obj;
obj.set_int(value);
EasyArray<ObSimpleCond>::operator()(ObSimpleCond(name, cond_op, obj));
return *this;
}
int ObMutatorHelper::add_column(const char* table_name, const ObString& rowkey, const char* column_name, const ObObj& value, ObMutator* mutator)
{
int ret = OB_SUCCESS;
ObString tname;
ObString column;
if(NULL == table_name)
{
ret = OB_INVALID_ARGUMENT;
TBSYS_LOG(WARN, "table_name is null");
}
if(OB_SUCCESS == ret && NULL == column_name)
{
ret = OB_INVALID_ARGUMENT;
TBSYS_LOG(WARN, "column_name is null");
}
if(OB_SUCCESS == ret && NULL == mutator)
{
ret = OB_INVALID_ARGUMENT;
TBSYS_LOG(WARN, "mutator is null");
}
if(OB_SUCCESS == ret)
{
tname.assign_ptr(const_cast<char*>(table_name), static_cast<int32_t>(strlen(table_name)));
column.assign_ptr(const_cast<char*>(column_name), static_cast<int32_t>(strlen(column_name)));
ret = mutator->update(tname, rowkey, column, value);
if(OB_SUCCESS != ret)
{
TBSYS_LOG(WARN, "add value to mutator fail:table_name[%s], column_name[%s]",
table_name, column_name);
}
}
return ret;
}
ObString RowkeyBuilder::get_random_rowkey(const int64_t cur_prefix_end, PageArena<char> &allocer)
{
ObString ret;
int64_t prefix = calc_prefix_(cur_prefix_end);
int64_t suffix = calc_suffix_(prefix);
int32_t length = I64_STR_LENGTH + suffix_length_;
char *ptr = allocer.alloc(length);
if (NULL != ptr)
{
sprintf(ptr, "%020ld", prefix);
build_string(ptr + I64_STR_LENGTH, suffix_length_, suffix);
}
ret.assign_ptr(ptr, length);
return ret;
}
int ObRootInnerTableTask::modify_all_cluster_table(const ObRootAsyncTaskQueue::ObSeqTask & task)
{
int ret = OB_SUCCESS;
// write cluster info to internal table
char buf[OB_MAX_SQL_LENGTH] = "";
if (task.type_ == LMS_ONLINE)
{
char ip_buf[OB_MAX_SERVER_ADDR_SIZE] = "";
if (false == task.server_.ip_to_string(ip_buf, sizeof(ip_buf)))
{
ret = OB_INVALID_ARGUMENT;
TBSYS_LOG(WARN, "convert server ip to string failed:ret[%d]", ret);
}
else
{
const char * sql_temp = "REPLACE INTO %s"
"(cluster_id, cluster_vip, cluster_port)"
"VALUES(%d, \'%s\',%u);";
snprintf(buf, sizeof (buf), sql_temp, OB_ALL_CLUSTER, cluster_id_, ip_buf,
task.server_.get_port());
}
}
else if (task.type_ == OBI_ROLE_CHANGE)
{
const char * sql_temp = "REPLACE INTO %s"
"(cluster_id, cluster_role)"
"VALUES(%d, %d);";
snprintf(buf, sizeof (buf), sql_temp, OB_ALL_CLUSTER, cluster_id_, task.cluster_role_);
}
else
{
ret = OB_INVALID_ARGUMENT;
TBSYS_LOG(WARN, "check input param failed:task_type[%d]", task.type_);
}
if (OB_SUCCESS == ret)
{
ObString sql;
sql.assign_ptr(buf, static_cast<ObString::obstr_size_t>(strlen(buf)));
ret = proxy_->query(true, RETRY_TIMES, TIMEOUT, sql);
if (OB_SUCCESS == ret)
{
TBSYS_LOG(INFO, "process inner task succ:task_id[%lu], timestamp[%ld], sql[%s]",
task.get_task_id(), task.get_task_timestamp(), buf);
}
}
return ret;
}
int read_log_file_by_location(const char* log_dir, const int64_t file_id, const int64_t offset,
char* buf, const int64_t len, int64_t& read_count, const bool dio = true)
{
int err = OB_SUCCESS;
char path[OB_MAX_FILE_NAME_LENGTH];
int64_t path_len = 0;
ObString fname;
ObFileReader file_reader;
read_count = 0;
if (NULL == log_dir || 0 >= file_id || 0 > offset || NULL == buf || 0 >= len)
{
err = OB_INVALID_ARGUMENT;
}
else if (0 >= (path_len = snprintf(path, sizeof(path), "%s/%ld", log_dir, file_id))
|| path_len > (int64_t)sizeof(path))
{
err = OB_ERROR;
}
else
{
fname.assign_ptr(path, static_cast<int32_t>(path_len));
}
if (OB_SUCCESS != err)
{}
else if (OB_SUCCESS != (err = file_reader.open(fname, dio)))
{
if (OB_FILE_NOT_EXIST != err)
{
TBSYS_LOG(WARN, "file_reader.open(%s/%ld)=>%d", path, file_id, err);
}
else
{
err = OB_SUCCESS;
}
}
else if (OB_SUCCESS != (err = file_reader.pread(buf, len, offset, read_count)))
{
TBSYS_LOG(ERROR, "file_reader.pread(buf=%p[%ld], offset=%ld)=>%d", buf, len, offset, err);
}
if (file_reader.is_opened())
{
file_reader.close();
}
return err;
}
TEST(TESTObBufferHelper, reader)
{
ObBufferWriter writer(buf);
ObBufferReader reader(buf);
writer.write<uint16_t>(13);
writer.write<int64_t>(32);
const char* str = "oceanbase test";
ObString varchar;
varchar.assign_ptr(const_cast<char*>(str), (int32_t)strlen(str));
writer.write_varchar(varchar);
writer.write<int64_t>(32);
Foo foo;
foo.k1 = 3;
foo.k2 = 24;
writer.write<Foo>(foo);
writer.write<int64_t>(32);
const uint16_t *int_value = NULL;
OK(reader.get<uint16_t>(int_value));
ASSERT_EQ(13, *int_value);
//ASSERT_EQ(13, reader.get<uint16_t>());
ASSERT_EQ(32, reader.get<int64_t>());
ASSERT_EQ(0, memcmp(str, reader.cur_ptr(), strlen(str)));
reader.skip(strlen(str));
ASSERT_EQ(32, reader.get<int64_t>());
Foo* foo1 = reader.get_ptr<Foo>();
ASSERT_EQ(3, foo1->k1);
ASSERT_EQ(24, foo1->k2);
ASSERT_EQ(32, reader.get<int64_t>());
}
ObString RowkeyBuilder::get_rowkey4apply(PageArena<char> &allocer, int64_t *cur_prefix_end)
{
ObString ret;
// 生成一个新的前缀
int64_t prefix = cur_prefix_;
if (cur_suffix_num_ >= cur_max_suffix_num_)
{
prefix = get_prefix_();
int64_t rand = 0;
lrand48_r(&prefix_rand_seed_, &rand);
cur_max_suffix_num_ = range_rand(1, max_suffix_per_prefix_, rand);
cur_suffix_num_ = 0;
srand48_r(prefix, &suffix_rand_seed_);
}
if (NULL != cur_prefix_end)
{
if (cur_prefix_ + 1 == cur_prefix_end_)
{
*cur_prefix_end = cur_prefix_;
}
else
{
*cur_prefix_end = cur_prefix_end_;
}
}
// 生成后缀
int64_t suffix = 0;
lrand48_r(&suffix_rand_seed_, &suffix);
++cur_suffix_num_;
int32_t length = I64_STR_LENGTH + suffix_length_;
char *ptr = allocer.alloc(length);
if (NULL != ptr)
{
sprintf(ptr, "%020ld", prefix);
build_string(ptr + I64_STR_LENGTH, suffix_length_, suffix);
}
ret.assign_ptr(ptr, length);
return ret;
}
ObString RowkeyBuilder::get_rowkey4checkall(PageArena<char> &allocer, const bool change_prefix, const int64_t *prefix_ptr)
{
ObString ret;
// 生成一个新的前缀
int64_t prefix;
if (NULL == prefix_ptr)
{
prefix = cur_prefix_;
if (change_prefix)
{
prefix = cur_prefix_end_++;
cur_prefix_ = prefix;
cur_suffix_num_ = 0;
srand48_r(prefix, &suffix_rand_seed_);
}
}
else
{
prefix = *prefix_ptr;
if (change_prefix)
{
cur_suffix_num_ = 0;
srand48_r(prefix, &suffix_rand_seed_);
}
}
// 生成后缀
int64_t suffix = 0;
lrand48_r(&suffix_rand_seed_, &suffix);
++cur_suffix_num_;
int32_t length = I64_STR_LENGTH + suffix_length_;
char *ptr = allocer.alloc(length);
if (NULL != ptr)
{
sprintf(ptr, "%020ld", prefix);
build_string(ptr + I64_STR_LENGTH, suffix_length_, suffix);
}
ret.assign_ptr(ptr, length);
return ret;
}
void ObMergeSortTest::SetUp()
{
sort_columns_.clear();
ObSortColumn sort_column;
sort_column.table_id_ = test::ObFakeTable::TABLE_ID;
sort_column.column_id_ = OB_APP_MIN_COLUMN_ID;
sort_column.is_ascending_ = false;
ASSERT_EQ(OB_SUCCESS, sort_columns_.push_back(sort_column));
sort_column.table_id_ = test::ObFakeTable::TABLE_ID;
sort_column.column_id_ = OB_APP_MIN_COLUMN_ID+1;
sort_column.is_ascending_ = true;
ASSERT_EQ(OB_SUCCESS, sort_columns_.push_back(sort_column));
ObString filename;
char* filename_buf = (char *)"ob_merge_sort_test.run";
filename.assign_ptr(filename_buf, strlen(filename_buf));
merge_sort_.set_run_filename(filename);
merge_sort_.set_sort_columns(sort_columns_);
in_mem_sort_.set_sort_columns(sort_columns_);
}
int ObInnerTableOperator::update_all_cluster(ObString & sql, const int64_t cluster_id,
const ObServer & server, const ObiRole role, const int64_t flow_percent)
{
int ret = OB_SUCCESS;
if ((sql.ptr() == NULL) || (0 == sql.size()))
{
ret = OB_INVALID_ARGUMENT;
TBSYS_LOG(WARN, "Check SQL buffer size failed! ptr[%p], size[%d]", sql.ptr(), sql.size());
}
else
{
char buf[OB_MAX_SERVER_ADDR_SIZE];
memset(buf, 0 , sizeof(buf));
if (server.ip_to_string(buf, sizeof(buf)) != true)
{
ret = OB_CONVERT_ERROR;
TBSYS_LOG(ERROR, "server ip is invalid, ret=%d", ret);
}
else
{
const char * format = "REPLACE INTO %s"
"(cluster_id, cluster_role, cluster_vip, cluster_flow_percent, read_strategy, rootserver_port) "
"VALUES(%d,%d,'%s',%d,%d,%d);";
// random read read_strategy
int size = snprintf(sql.ptr(), sql.size(), format, OB_ALL_CLUSTER, cluster_id,
role.get_role() == ObiRole::MASTER ? 1 : 2, buf, flow_percent, 0, server.get_port());
if (size >= sql.size())
{
TBSYS_LOG(ERROR, "SQL buffer size not enough! size: [%d], need: [%d], sql: [%.*s]",
sql.size(), size, sql.length(), sql.ptr());
ret = OB_SIZE_OVERFLOW;
}
else
{
sql.assign_ptr(sql.ptr(), size);
TBSYS_LOG(INFO, "XXX=%.*s", sql.length(), sql.ptr());
}
}
}
return ret;
}
virtual void SetUp()
{
int64_t pos = 0;
range.table_id_ = 1001;
start_key_obj.set_varchar(start_key);
range.start_key_.assign(&start_key_obj, 1);
end_key_obj.set_varchar(end_key);
range.end_key_.assign(&end_key_obj, 1);
range.border_flag_.unset_inclusive_start();
range.border_flag_.set_inclusive_end();
default_range.table_id_ = OB_INVALID_ID;
default_range.set_whole_range();
default_range.border_flag_.unset_inclusive_start();
default_range.border_flag_.unset_inclusive_end();
range.start_key_.serialize(key_stream_buf, 512, pos);
range.end_key_.serialize(key_stream_buf, 512, pos);
key_stream.assign_ptr(key_stream_buf, static_cast<int32_t>(pos));
}
int ObMetaTableColumnSchema::get_cf(const uint64_t cid, CF &cf, int32_t &idx) const
{
int ret = OB_SUCCESS;
const char* cname_cstr = NULL;
ObString cname;
if (OB_SUCCESS != (ret = get_name_by_cid(cid, cname_cstr)))
{
TBSYS_LOG(WARN, "no column found by id, cid=%lu", cid);
}
else
{
cname.assign_ptr(const_cast<char*>(cname_cstr), static_cast<int32_t>(strlen(cname_cstr)));
ret = OB_ENTRY_NOT_EXIST;
for (uint64_t i = 0; i < ARRAYSIZEOF(COLUMNS_NAME); ++i)
{
if (COLUMNS_NAME[i] == cname)
{
ret = OB_SUCCESS;
cf = CID_CF_IDX_MAP[i].cf;
idx = CID_CF_IDX_MAP[i].idx;
break;
}
}
if (OB_SUCCESS != ret)
{
int val = 0;
int len = sscanf(cname_cstr, SCOL_STARTKEY_OBJ_PREFIX_FORMAT, &val);
if (1 == len
&& 1 <= val
&& val <= table_schema_.rowkey_column_num_)
{
ret = OB_SUCCESS;
cf = ObTabletMetaTableColumnSchema::CF_STARTKEY_COL;
idx = val - 1; // index start from 0
}
}
}
return ret;
}
TEST(ObObj, performance)
{
// int64_t start_time = tbsys::CTimeUtil::getTime();
//const int64_t MAX_COUNT = 10 * 1000 * 1000L;
const int64_t MAX_COUNT = 1000L;
ObObj obj;
char buf[2048];
int64_t len = 2048;
int64_t pos = 0;
int64_t data = 0;
for (int64_t i = 0; i < MAX_COUNT; ++i)
{
obj.set_int(i);
pos = 0;
ASSERT_EQ(obj.serialize(buf, len, pos), OB_SUCCESS);
pos = 0;
ASSERT_EQ(obj.deserialize(buf, len, pos), OB_SUCCESS);
ASSERT_EQ(obj.get_int(data), OB_SUCCESS);
ASSERT_EQ(data, i);
}
const char *tmp = "Hello12344556666777777777777545352454254254354354565463241242354345345345235345";
ObObj obj2;
ObString string;
ObString string2;
string.assign_ptr(const_cast<char *>(tmp), 1024);
obj2.set_varchar(string);
for (register int64_t i = 0; i < MAX_COUNT; ++i )
{
pos = 0;
ASSERT_EQ(obj2.serialize(buf, len, pos), OB_SUCCESS);
pos = 0;
ASSERT_EQ(obj2.deserialize(buf, len, pos), OB_SUCCESS);
ASSERT_EQ(obj2.get_varchar(string2), OB_SUCCESS);
}
// int64_t end_time = tbsys::CTimeUtil::getTime();
//printf("using time:%ld\n", end_time - start_time);
}
int ObInnerTableOperator::update_all_trigger_event(ObString & sql, const int64_t timestamp,
const ObServer & server, const int64_t type, const int64_t param)
{
UNUSED(param);
int ret = OB_SUCCESS;
if ((sql.ptr() == NULL) || (0 == sql.size()))
{
TBSYS_LOG(WARN, "Check SQL buffer size failed! ptr[%p], size[%d]", sql.ptr(), sql.size());
ret = OB_INVALID_ARGUMENT;
}
else
{
char buf[OB_MAX_SERVER_ADDR_SIZE] = "";
if (server.ip_to_string(buf, sizeof(buf)) != true)
{
ret = OB_CONVERT_ERROR;
}
else
{
const char * format = "REPLACE INTO %s"
"(event_ts, src_ip, event_type, event_param) "
"values (%ld, '%s', %ld, %ld);";
int size = snprintf(sql.ptr(), sql.size(), format,
OB_ALL_TRIGGER_EVENT_TABLE_NAME, timestamp, buf, type, param);
if (size >= sql.size())
{
TBSYS_LOG(ERROR, "SQL buffer size not enough! size: [%d], need: [%d], sql: [%.*s]",
sql.size(), size, sql.length(), sql.ptr());
ret = OB_SIZE_OVERFLOW;
}
else
{
sql.assign_ptr(sql.ptr(), size);
}
}
}
return ret;
}
int ObInnerTableOperator::update_all_server(ObString & sql, const int64_t cluster_id,
const char * server_type, const ObServer & server, const uint32_t inner_port, const char * version)
{
int ret = OB_SUCCESS;
if ((sql.ptr() == NULL) || (0 == sql.size()))
{
TBSYS_LOG(WARN, "Check SQL buffer size failed! ptr[%p], size[%d]", sql.ptr(), sql.size());
ret = OB_INVALID_ARGUMENT;
}
else
{
char buf[OB_MAX_SERVER_ADDR_SIZE] = "";
if (server.ip_to_string(buf, sizeof(buf)) != true)
{
ret = OB_CONVERT_ERROR;
}
else
{
const char * format = "REPLACE INTO %s"
"(cluster_id, svr_type, svr_ip, svr_port, inner_port, svr_role, svr_version) "
"values (%d, '%s', '%s', %u, %u, %d, '%s');";
int size = snprintf(sql.ptr(), sql.size(), format, OB_ALL_SERVER, cluster_id,
server_type, buf, server.get_port(), inner_port, 0, version);
if (size >= sql.size())
{
TBSYS_LOG(ERROR, "SQL buffer size not enough! size: [%d], need: [%d], sql: [%.*s]",
sql.size(), size, sql.length(), sql.ptr());
ret = OB_SIZE_OVERFLOW;
}
else
{
sql.assign_ptr(sql.ptr(), size);
}
}
}
return ret;
}
int ObInnerTableOperator::delete_all_server(ObString & sql, const int64_t cluster_id,
const char * server_type, const ObServer & server)
{
int ret = OB_SUCCESS;
if ((sql.ptr() == NULL) || (0 == sql.size()))
{
TBSYS_LOG(WARN, "Check SQL buffer size failed! ptr[%p], size[%d]", sql.ptr(), sql.size());
ret = OB_INVALID_ARGUMENT;
}
else
{
char buf[OB_MAX_SERVER_ADDR_SIZE] = "";
if (server.ip_to_string(buf, sizeof (buf)) != true)
{
ret = OB_CONVERT_ERROR;
}
else
{
const char * format = "DELETE FROM %s WHERE cluster_id = %d AND svr_type = '%s' "
"AND svr_ip = '%s' AND svr_port = %u;";
int size = snprintf(sql.ptr(), sql.size(), format, OB_ALL_SERVER,
cluster_id, server_type, buf, server.get_port());
if (size >= sql.size())
{
TBSYS_LOG(ERROR, "SQL buffer size not enough! size: [%d], need: [%d], sql: [%.*s]",
sql.size(), size, sql.length(), sql.ptr());
ret = OB_SIZE_OVERFLOW;
}
else
{
sql.assign_ptr(sql.ptr(), size);
}
}
}
return ret;
}
int ObDelete::delete_by_mutator()
{
int ret = OB_SUCCESS;
OB_ASSERT(child_op_);
const ObRow *row = NULL;
uint64_t cid = OB_INVALID_ID;
const ObObj *cell = NULL;
ObObj rowkey_objs[OB_MAX_ROWKEY_COLUMN_NUMBER];
ObRowkey rowkey;
ObObj data_type;
ObObj casted_cells[OB_MAX_ROWKEY_COLUMN_NUMBER+1];
char *varchar_buff = NULL;
if (NULL == (varchar_buff = (char*)ob_malloc(OB_MAX_VARCHAR_LENGTH*(OB_MAX_ROWKEY_COLUMN_NUMBER), ObModIds::OB_SQL_EXECUTER)))
{
TBSYS_LOG(ERROR, "no memory");
ret = OB_ALLOCATE_MEMORY_FAILED;
}
while(OB_SUCCESS == ret
&& OB_SUCCESS == (ret = child_op_->get_next_row(row)))
{
// construct rowkey
int64_t idx = OB_INVALID_INDEX;
for (int64_t i = 0; i < rowkey_info_.get_size(); ++i)
{
ObString varchar;
varchar.assign_ptr(varchar_buff + OB_MAX_VARCHAR_LENGTH * i, OB_MAX_VARCHAR_LENGTH);
casted_cells[i].set_varchar(varchar);
if (OB_SUCCESS != (ret = rowkey_info_.get_column_id(i, cid)))
{
TBSYS_LOG(WARN, "failed to get primary key column, err=%d cid=%lu", ret, cid);
break;
}
else if (OB_SUCCESS != (ret = row->get_cell(table_id_, cid, cell)))
{
TBSYS_LOG(USER_ERROR, "primary key can not be empty");
ret = OB_ERR_DELETE_NULL_ROWKEY;
break;
}
else if (cell->is_null())
{
TBSYS_LOG(USER_ERROR, "primary key can not be null");
ret = OB_ERR_DELETE_NULL_ROWKEY;
break;
}
else if (OB_SUCCESS != (ret = cols_desc_.get_by_id(table_id_, cid, idx, data_type)))
{
TBSYS_LOG(WARN, "failed to get data type from row desc, err=%d cid=%lu", ret, cid);
break;
}
else
{
const ObObj *res_cell = NULL;
if (OB_SUCCESS != (ret = obj_cast(*cell, data_type, casted_cells[i], res_cell)))
{
TBSYS_LOG(WARN, "failed to cast obj, err=%d", ret);
break;
}
else
{
rowkey_objs[i] = *res_cell;
}
}
} // end for
if (OB_UNLIKELY(OB_SUCCESS != ret))
{
break;
}
else
{
rowkey.assign(rowkey_objs, rowkey_info_.get_size());
}
// We want to get no columns other than primary key.
OB_ASSERT(rowkey_info_.get_size() <= row->get_column_num());
if (OB_SUCCESS != (ret = mutator_.del_row(table_id_, rowkey)))
{
TBSYS_LOG(WARN, "failed to delete cell, err=%d", ret);
break;
}
else
{
TBSYS_LOG(DEBUG, "delete cell, rowkey=%s", to_cstring(rowkey));
}
} // end while
if (OB_ITER_END != ret)
{
TBSYS_LOG(WARN, "failed to cons mutator, err=%d", ret);
}
else
{
ret = OB_SUCCESS;
}
// send mutator
if (OB_SUCCESS == ret)
{
ObScanner scanner; // useless
if (OB_SUCCESS != (ret = rpc_->ups_mutate(mutator_, false, scanner)))
{
TBSYS_LOG(WARN, "failed to send mutator to ups, err=%d", ret);
}
}
if (NULL != varchar_buff)
{
ob_free(varchar_buff, ObModIds::OB_SQL_EXECUTER);
varchar_buff = NULL;
}
return ret;
}
int ObSqlReadStrategy::find_closed_column_range(bool real_val, int64_t idx, uint64_t column_id, bool &found_start, bool &found_end, bool single_row_only)
{
int ret = OB_SUCCESS;
int i = 0;
uint64_t cond_cid = OB_INVALID_ID;
int64_t cond_op = T_MIN_OP;
ObObj cond_val;
ObObj cond_start;
ObObj cond_end;
const ObRowkeyColumn *column = NULL;
found_end = false;
found_start = false;
for (i = 0; i < simple_cond_filter_list_.count(); i++)
{
if (simple_cond_filter_list_.at(i).is_simple_condition(real_val, cond_cid, cond_op, cond_val))
{
if ((cond_cid == column_id) &&
(NULL != (column = rowkey_info_->get_column(idx))))
{
ObObjType target_type = column->type_;
ObObj expected_type;
ObObj promoted_obj;
const ObObj *p_promoted_obj = NULL;
ObObjType source_type = cond_val.get_type();
expected_type.set_type(target_type);
ObString string;
char *varchar_buff = NULL;
if (target_type == ObVarcharType && source_type != ObVarcharType)
{
if (NULL == (varchar_buff = (char*)ob_malloc(OB_MAX_VARCHAR_LENGTH, ObModIds::OB_SQL_READ_STRATEGY)))
{
ret = OB_ALLOCATE_MEMORY_FAILED;
TBSYS_LOG(WARN, "ob_malloc %ld bytes failed, ret=%d", OB_MAX_VARCHAR_LENGTH, ret);
}
else
{
string.assign_ptr(varchar_buff, OB_MAX_VARCHAR_LENGTH);
promoted_obj.set_varchar(string);
if (OB_SUCCESS != (ret = obj_cast(cond_val, expected_type, promoted_obj, p_promoted_obj)))
{
TBSYS_LOG(WARN, "failed to cast object, ret=%d, from_type=%d to_type=%d", ret, source_type, target_type);
ob_free(varchar_buff);
varchar_buff = NULL;
break;
}
else
{
switch (cond_op)
{
case T_OP_LT:
case T_OP_LE:
if (end_key_objs_[idx].is_max_value())
{
end_key_objs_[idx] = *p_promoted_obj;
end_key_mem_hold_[idx] = varchar_buff;
found_end = true;
}
else if (*p_promoted_obj < end_key_objs_[idx])
{
end_key_objs_[idx] = *p_promoted_obj;
if (end_key_mem_hold_[idx] != NULL)
{
ob_free(end_key_mem_hold_[idx]);
end_key_mem_hold_[idx] = varchar_buff;
}
else
{
end_key_mem_hold_[idx] = varchar_buff;
}
}
else
{
ob_free(varchar_buff);
varchar_buff = NULL;
}
break;
case T_OP_GT:
case T_OP_GE:
if (start_key_objs_[idx].is_min_value())
{
start_key_objs_[idx] = *p_promoted_obj;
found_start = true;
start_key_mem_hold_[idx] = varchar_buff;
}
else if (*p_promoted_obj > start_key_objs_[idx])
{
start_key_objs_[idx] = *p_promoted_obj;
if (start_key_mem_hold_[idx] != NULL)
{
ob_free(start_key_mem_hold_[idx]);
start_key_mem_hold_[idx] = varchar_buff;
}
else
{
start_key_mem_hold_[idx] = varchar_buff;
}
}
else
{
ob_free(varchar_buff);
varchar_buff = NULL;
}
break;
case T_OP_EQ:
case T_OP_IS:
if (start_key_objs_[idx].is_min_value() && end_key_objs_[idx].is_max_value())
{
start_key_objs_[idx] = *p_promoted_obj;
end_key_objs_[idx] = *p_promoted_obj;
// when free, we compare this two address, if equals, then release once
start_key_mem_hold_[idx] = varchar_buff;
end_key_mem_hold_[idx] = varchar_buff;
found_start = true;
found_end = true;
}
else if (start_key_objs_[idx] == end_key_objs_[idx])
{
if (*p_promoted_obj != start_key_objs_[idx])
{
TBSYS_LOG(WARN, "two different equal condition on the sanme column, column_id=%lu", column_id);
}
ob_free(varchar_buff);
varchar_buff = NULL;
}
else
{
// actually, if the eq condition is not between the previous range, we also can set range using eq condition,in this case,
// the scan range is actually a single-get, filter will filter-out the record,
// so, here , we set range to a single-get scan uniformly,contact to [email protected]
//if (*p_promoted_obj >= start_key_objs_[idx] && *p_promoted_obj <= end_key_objs_[idx])
//{
start_key_objs_[idx] = *p_promoted_obj;
end_key_objs_[idx] = *p_promoted_obj;
if (start_key_mem_hold_[idx] != NULL)
{
ob_free(start_key_mem_hold_[idx]);
}
start_key_mem_hold_[idx] = varchar_buff;
if (end_key_mem_hold_[idx] != NULL)
{
ob_free(end_key_mem_hold_[idx]);
}
end_key_mem_hold_[idx] = varchar_buff;
//}
}
break;
default:
ob_free(varchar_buff);
varchar_buff = NULL;
TBSYS_LOG(WARN, "unexpected cond op: %ld", cond_op);
ret = OB_ERR_UNEXPECTED;
break;
}
}
}
}
else
{
if (OB_SUCCESS != (ret = obj_cast(cond_val, expected_type, promoted_obj, p_promoted_obj)))
{
TBSYS_LOG(WARN, "failed to cast object, ret=%d, from_type=%d to_type=%d", ret, source_type, target_type);
break;
}
else
{
switch (cond_op)
{
case T_OP_LT:
case T_OP_LE:
if (end_key_objs_[idx].is_max_value())
{
end_key_objs_[idx] = *p_promoted_obj;
found_end = true;
}
else
{
if (*p_promoted_obj < end_key_objs_[idx])
{
end_key_objs_[idx] = *p_promoted_obj;
if (end_key_mem_hold_[idx] != NULL)
{
ob_free(end_key_mem_hold_[idx]);
}
}
}
break;
case T_OP_GT:
case T_OP_GE:
if (start_key_objs_[idx].is_min_value())
{
start_key_objs_[idx] = *p_promoted_obj;
found_start = true;
}
else
{
if (*p_promoted_obj > start_key_objs_[idx])
{
start_key_objs_[idx] = *p_promoted_obj;
if (start_key_mem_hold_[idx] != NULL)
{
ob_free(start_key_mem_hold_[idx]);
}
}
}
break;
case T_OP_EQ:
case T_OP_IS:
if (start_key_objs_[idx].is_min_value() && end_key_objs_[idx].is_max_value())
{
start_key_objs_[idx] = *p_promoted_obj;
end_key_objs_[idx] = *p_promoted_obj;
found_start = true;
found_end = true;
}
else if (start_key_objs_[idx] == end_key_objs_[idx])
{
if (*p_promoted_obj != start_key_objs_[idx])
{
TBSYS_LOG(WARN, "two different equal condition on the same column, column_id=%lu"
" start_key_objs_[idx]=%s, *p_promoted_obj=%s",
column_id, to_cstring(start_key_objs_[idx]), to_cstring(*p_promoted_obj));
}
}
else
{
// actually, if the eq condition is not between the previous range, we also can set range using eq condition,in this case,
// the scan range is actually a single-get, filter will filter-out the record,
// so, here , we set range to a single-get scan uniformly,contact to [email protected]
//if (*p_promoted_obj >= start_key_objs_[idx] && *p_promoted_obj <= end_key_objs_[idx])
//{
start_key_objs_[idx] = *p_promoted_obj;
end_key_objs_[idx] = *p_promoted_obj;
if (start_key_mem_hold_[idx] != NULL)
{
ob_free(start_key_mem_hold_[idx]);
}
if (end_key_mem_hold_[idx] != NULL)
{
ob_free(end_key_mem_hold_[idx]);
}
//}
}
break;
default:
TBSYS_LOG(WARN, "unexpected cond op: %ld", cond_op);
ret = OB_ERR_UNEXPECTED;
break;
}
}
}
if (single_row_only && cond_op != T_OP_EQ)
{
found_end = found_start = false;
}
}
}
else if ((!single_row_only) && simple_cond_filter_list_.at(i).is_simple_between(real_val, cond_cid, cond_op, cond_start, cond_end))
{
if (cond_cid == column_id)
{
OB_ASSERT(T_OP_BTW == cond_op);
column = rowkey_info_->get_column(idx);
ObObjType target_type;
if (column == NULL)
{
TBSYS_LOG(WARN, "get column from rowkey_info failed, column = NULL");
}
else
{
target_type = column->type_;
ObObj expected_type;
expected_type.set_type(target_type);
ObObj start_promoted_obj;
ObString start_string;
ObString end_string;
char *varchar_buff = NULL;
const ObObj *p_start_promoted_obj = NULL;
ObObj end_promoted_obj;
const ObObj *p_end_promoted_obj = NULL;
ObObjType start_source_type = cond_start.get_type();
ObObjType end_source_type = cond_end.get_type();
if (target_type == ObVarcharType && start_source_type != ObVarcharType)
{
if (NULL == (varchar_buff = (char*)ob_malloc(OB_MAX_VARCHAR_LENGTH, ObModIds::OB_SQL_READ_STRATEGY)))
{
ret = OB_ALLOCATE_MEMORY_FAILED;
TBSYS_LOG(WARN, "ob_malloc %ld bytes failed, ret=%d", OB_MAX_VARCHAR_LENGTH, ret);
}
else
{
start_string.assign_ptr(varchar_buff, OB_MAX_VARCHAR_LENGTH);
start_promoted_obj.set_varchar(start_string);
if (OB_SUCCESS != (ret = obj_cast(cond_start, expected_type, start_promoted_obj, p_start_promoted_obj)))
{
TBSYS_LOG(WARN, "failed to cast object, ret=%d, from_type=%d to_type=%d", ret, start_source_type, target_type);
ob_free(varchar_buff);
varchar_buff = NULL;
break;
}
else
{
if (start_key_objs_[idx].is_min_value())
{
start_key_objs_[idx] = *p_start_promoted_obj;
found_start = true;
start_key_mem_hold_[idx] = varchar_buff;
}
else if (*p_start_promoted_obj > start_key_objs_[idx])
{
start_key_objs_[idx] = *p_start_promoted_obj;
if (start_key_mem_hold_[idx] != NULL)
{
ob_free(start_key_mem_hold_[idx]);
start_key_mem_hold_[idx] = varchar_buff;
}
else
{
start_key_mem_hold_[idx] = varchar_buff;
}
}
else
{
ob_free(varchar_buff);
varchar_buff = NULL;
}
}
}
}
else
{
if (OB_SUCCESS != (ret = obj_cast(cond_start, expected_type, start_promoted_obj, p_start_promoted_obj)))
{
TBSYS_LOG(WARN, "failed to cast object, ret=%d, from_type=%d to_type=%d", ret, start_source_type, target_type);
}
else
{
if (start_key_objs_[idx].is_min_value())
{
start_key_objs_[idx] = *p_start_promoted_obj;
found_start = true;
}
else
{
if (*p_start_promoted_obj > start_key_objs_[idx])
{
start_key_objs_[idx] = *p_start_promoted_obj;
if (start_key_mem_hold_[idx] != NULL)
{
ob_free(start_key_mem_hold_[idx]);
start_key_mem_hold_[idx] = NULL;
}
}
}
}
}
varchar_buff = NULL;
if (OB_SUCCESS == ret)
{
if (target_type == ObVarcharType && end_source_type != ObVarcharType)
{
if (NULL == (varchar_buff = (char*)ob_malloc(OB_MAX_VARCHAR_LENGTH, ObModIds::OB_SQL_READ_STRATEGY)))
{
ret = OB_ALLOCATE_MEMORY_FAILED;
TBSYS_LOG(WARN, "ob_malloc %ld bytes failed, ret=%d", OB_MAX_VARCHAR_LENGTH, ret);
}
else
{
end_key_mem_hold_[idx] = varchar_buff;
end_string.assign_ptr(varchar_buff, OB_MAX_VARCHAR_LENGTH);
end_promoted_obj.set_varchar(end_string);
if (OB_SUCCESS != (ret = obj_cast(cond_end, expected_type, end_promoted_obj, p_end_promoted_obj)))
{
TBSYS_LOG(WARN, "failed to cast object, ret=%d, from_type=%d to_type=%d", ret, end_source_type, target_type);
ob_free(varchar_buff);
varchar_buff = NULL;
break;
}
else
{
if (end_key_objs_[idx].is_max_value())
{
end_key_objs_[idx] = *p_end_promoted_obj;
found_end = true;
end_key_mem_hold_[idx] = varchar_buff;
}
else if (*p_end_promoted_obj < end_key_objs_[idx])
{
end_key_objs_[idx] = *p_end_promoted_obj;
if (end_key_mem_hold_[idx] != NULL)
{
ob_free(end_key_mem_hold_[idx]);
end_key_mem_hold_[idx] = varchar_buff;
}
else
{
end_key_mem_hold_[idx] = varchar_buff;
}
}
else
{
ob_free(varchar_buff);
varchar_buff = NULL;
}
}
}
}
else
{
if (OB_SUCCESS != (ret = obj_cast(cond_end, expected_type, end_promoted_obj, p_end_promoted_obj)))
{
TBSYS_LOG(WARN, "failed to cast object, ret=%d, from_type=%d to_type=%d", ret, end_source_type, target_type);
}
else
{
if (end_key_objs_[idx].is_max_value())
{
end_key_objs_[idx] = *p_end_promoted_obj;
found_end = true;
}
else
{
if (*p_end_promoted_obj < end_key_objs_[idx])
{
end_key_objs_[idx] = *p_end_promoted_obj;
if (end_key_mem_hold_[idx] != NULL)
{
ob_free(end_key_mem_hold_[idx]);
end_key_mem_hold_[idx] = NULL;
}
}
}
}
}
}
}
}
}
if (ret != OB_SUCCESS)
{
break;
}
//if (found_start && found_end)
//{
/* we can break earlier here */
//break;
//}
}
return ret;
}
uint64_t ObMetaTableColumnSchema::get_cid(const CF cf, const int32_t i) const
{
uint64_t ret = OB_INVALID_ID;
if (i >= ObTabletMetaTableRow::MAX_REPLICA_COUNT || 0 > i)
{
TBSYS_LOG(ERROR, "BUG invalid index, i=%d", i);
}
else
{
ObString cname;
const int buf_len = meta_table_cname::STARTKEY_OBJ_PREFIX.length() + 8;
char cname_buf[buf_len];
cname_buf[0] = '\0';
int print_len = 0;
switch(cf)
{
case CF_TID:
cname = COLUMNS_NAME[CIDX_TID];
break;
case CF_VERSION:
cname = COLUMNS_NAME[CIDX_REPLICA1_VERSION + i * COLUMNS_PER_REPLICA];
break;
case CF_CHECKSUM:
cname = COLUMNS_NAME[CIDX_REPLICA1_CHECKSUM + i * COLUMNS_PER_REPLICA];
break;
case CF_ROW_COUNT:
cname = COLUMNS_NAME[CIDX_REPLICA1_ROW_COUNT + i * COLUMNS_PER_REPLICA];
break;
case CF_SIZE:
cname = COLUMNS_NAME[CIDX_REPLICA1_SIZE + i * COLUMNS_PER_REPLICA];
break;
case CF_IPV4:
cname = COLUMNS_NAME[CIDX_REPLICA1_IPV4 + i * COLUMNS_PER_REPLICA];
break;
case CF_IPV6_HIGH:
cname = COLUMNS_NAME[CIDX_REPLICA1_IPV6_HIGH + i * COLUMNS_PER_REPLICA];
break;
case CF_IPV6_LOW:
cname = COLUMNS_NAME[CIDX_REPLICA1_IPV6_LOW + i * COLUMNS_PER_REPLICA];
break;
case CF_PORT:
cname = COLUMNS_NAME[CIDX_REPLICA1_IP_PORT + i * COLUMNS_PER_REPLICA];
break;
case CF_STARTKEY_COL:
print_len = snprintf(cname_buf, buf_len, "%.*s%d", meta_table_cname::STARTKEY_OBJ_PREFIX.length(),
meta_table_cname::STARTKEY_OBJ_PREFIX.ptr(), i + 1);
cname.assign_ptr(cname_buf, print_len);
break;
default:
TBSYS_LOG(ERROR, "BUG invalid meta table column, cf=%d", cf);
break;
} // end switch
if (OB_SUCCESS != get_cid_by_name(cname, ret))
{
TBSYS_LOG(ERROR, "meta table column not found, cname=%.*s tid=%lu",
cname.length(), cname.ptr(), table_schema_.table_id_);
}
}
return ret;
}
int ObVariableSet::process_variables_set()
{
int ret = OB_SUCCESS;
bool need_global_change = false;
ObRow val_row;
const ObObj *value_obj = NULL;
ObSQLSessionInfo *session = my_phy_plan_->get_result_set()->get_session();
for (int64_t i = 0; ret == OB_SUCCESS && i < variable_nodes_.count(); i++)
{
VariableSetNode& node = variable_nodes_.at(i);
if ((ret = node.variable_expr_->calc(val_row, value_obj)) != OB_SUCCESS)
{
TBSYS_LOG(WARN, "Calculate variable value failed. ret=%d", ret);
}
else if (!node.is_system_variable_)
{
// user defined tmp variable
if ((ret = session->replace_variable(
node.variable_name_,
*value_obj)) != OB_SUCCESS)
{
TBSYS_LOG(WARN, "set variable to session plan failed. ret=%d, name=%.*s",
ret, node.variable_name_.length(), node.variable_name_.ptr());
}
}
else if (!node.is_global_)
{
// set session system variable
if ((ret = session->update_system_variable(
node.variable_name_,
*value_obj)) != OB_SUCCESS)
{
TBSYS_LOG(WARN, "set variable to session plan failed. ret=%d, name=%.*s",
ret, node.variable_name_.length(), node.variable_name_.ptr());
}
// special case: set autocommit
else if (node.variable_name_ == ObString::make_string("autocommit"))
{
int64_t int_val = 0;
ObObj int_obj;
ObObj obj_type;
obj_type.set_type(ObIntType);
const ObObj *res_obj = NULL;
if (OB_SUCCESS != (ret = obj_cast(*value_obj, obj_type, int_obj, res_obj)))
{
TBSYS_LOG(WARN, "failed to cast to int, obj=%s", to_cstring(*value_obj));
}
else
{
ret = res_obj->get_int(int_val);
OB_ASSERT(OB_SUCCESS == ret);
if (int_val)
{
ret = set_autocommit();
OB_STAT_INC(OBMYSQL, SQL_AUTOCOMMIT_ON_COUNT);
}
else
{
ret = clear_autocommit();
OB_STAT_INC(OBMYSQL, SQL_AUTOCOMMIT_OFF_COUNT);
}
}
}
}
else
{
// set global system variable
char key_varchar_buff[OB_MAX_ROWKEY_COLUMN_NUMBER + 1][OB_MAX_VARCHAR_LENGTH];
ObObj casted_cells[OB_MAX_ROWKEY_COLUMN_NUMBER + 1];
ObObj rowkey_objs[OB_MAX_ROWKEY_COLUMN_NUMBER];
const ObObj *res_cell = NULL;
ObRowkey rowkey;
ObObj value;
// construct rowkey
for (int64_t j = 0; ret == OB_SUCCESS && j < rowkey_info_.get_size(); ++j)
{
uint64_t cid = OB_INVALID_ID;
ObString varchar;
varchar.assign_ptr(key_varchar_buff[j], OB_MAX_VARCHAR_LENGTH);
casted_cells[j].set_varchar(varchar);
const ObRowkeyColumn *rowkey_column = rowkey_info_.get_column(j);
if (rowkey_column == NULL)
{
ret = OB_ERROR;
TBSYS_LOG(ERROR, "Get rowkey error");
break;
}
else if (OB_SUCCESS != (ret = rowkey_info_.get_column_id(j, cid)))
{
TBSYS_LOG(USER_ERROR, "Primary key can not be empty");
ret = OB_ERR_GEN_PLAN;
break;
}
else
{
ObObj data_type;
data_type.set_type(rowkey_column->type_);
if (cid != name_cid_)
{
value.set_int(0);
}
else
{
value.set_varchar(node.variable_name_);
}
if (OB_SUCCESS != (ret = obj_cast(value, data_type, casted_cells[j], res_cell)))
{
TBSYS_LOG(USER_ERROR, "Primary key can not be empty");
ret = OB_ERR_GEN_PLAN;
break;
}
else
{
rowkey_objs[j] = *res_cell;
}
}
}
if (ret == OB_SUCCESS)
{
rowkey.assign(rowkey_objs, rowkey_info_.get_size());
}
else
{
break;
}
// add type and value
if (ret == OB_SUCCESS)
{
ObString varchar;
varchar.assign_ptr(key_varchar_buff[OB_MAX_ROWKEY_COLUMN_NUMBER], OB_MAX_VARCHAR_LENGTH);
ObObj &casted_cell = casted_cells[OB_MAX_ROWKEY_COLUMN_NUMBER];
casted_cell.set_varchar(varchar);
ObObj value_type;
value_type.set_type(value_type_);
if (OB_SUCCESS != (ret = obj_cast(*value_obj, value_type, casted_cell, res_cell)))
{
TBSYS_LOG(WARN, "Failed to cast obj, err=%d", ret);
break;
}
else if (OB_SUCCESS != (ret = mutator_.update(table_id_, rowkey, value_cid_, *res_cell)))
{
TBSYS_LOG(WARN, "Failed to update cell, err=%d", ret);
break;
}
else
{
need_global_change = true;
}
}
}
}
// send mutator
ObScanner scanner;
if (OB_SUCCESS == ret && need_global_change
&& OB_SUCCESS != (ret = rpc_->ups_mutate(mutator_, false, scanner)))
{
TBSYS_LOG(WARN, "failed to send mutator to ups, err=%d", ret);
}
return ret;
}
int DES_crypt::des_decrypt(ObString &user_name, int64_t ×tamp, const int64_t skey, char *buffer, int64_t buffer_length)
{
int err = OB_SUCCESS;
if(buffer == NULL || buffer_length != OB_MAX_TOKEN_BUFFER_LENGTH)
{
err = OB_INVALID_ARGUMENT;
TBSYS_LOG(WARN, "invalid argument.err=%d, buffer=%p,buffer_length =%ld", err, buffer, buffer_length);
}
if(OB_SUCCESS == err)
{
data_.initialized = 0;
err = stringTobyte(keybyte_, OB_ENRYPT_KEY_BYTE, reinterpret_cast<const char*>(&skey), sizeof(int64_t));
if(err != OB_SUCCESS)
{
TBSYS_LOG(WARN, "fail to stringTobyte. err=%d", err);
}
else
{
setkey_r(keybyte_, &data_);
}
}
if(OB_SUCCESS == err)
{
err = stringTobyte(txtbyte_, OB_ENCRYPT_TXT_BYTE, buffer, buffer_length);
if(err != OB_SUCCESS)
{
TBSYS_LOG(WARN, "fail to tranlate to byte. err=%d", err);
}
}
char *ptr = txtbyte_;
if(OB_SUCCESS == err)
{
for(int64_t i = 0; i < buffer_length * OB_BYTE_NUM; i += OB_CRYPT_UNIT)
{
ptr = &txtbyte_[i];
encrypt_r(ptr, DECODE_FLAG, &data_);
}
}
if(OB_SUCCESS == err)
{
err = byteTostring(buffer, buffer_length, txtbyte_, buffer_length * 8);
if(err != OB_SUCCESS)
{
TBSYS_LOG(WARN, "fail to tranlate to string. err=%d", err);
}
}
if(OB_SUCCESS == err)
{
int64_t pos = 0;
int32_t magic_number = *(reinterpret_cast<const int32_t*>(buffer + pos));
if(magic_number != OB_CRYPT_MAGIC_NUM)
{
err = OB_DECRYPT_FAILED;
TBSYS_LOG(WARN, "magic number not legal.maybe the wrong skey,or the wrong data, err = %d", err);
}
else
{
pos += sizeof(int32_t);
int32_t user_name_length = *(reinterpret_cast<const int32_t*>(buffer + pos));
pos += sizeof(int32_t);
user_name.assign_ptr(buffer + pos, user_name_length);
pos += user_name_length;
timestamp = *(reinterpret_cast<const int64_t*>(buffer + pos));
}
}
return err;
}
void CellinfoBuilder::build_cell_(struct drand48_data &rand_data, const ObString &row_key, const ObSchema &schema,
ObObj &obj, int64_t &column_pos, int &op_type,
PageArena<char> &allocer)
{
const ObColumnSchema *column_schema = schema.column_begin();
int64_t column_num = schema.column_end() - schema.column_begin();
int64_t rand = 0;
lrand48_r(&rand_data, &rand);
op_type = calc_op_type_(rand);
//while (true)
//{
// lrand48_r(&rand_data, &rand);
// column_pos = range_rand(0, column_num - 3, rand);
// if (ObIntType <= column_schema[column_pos].get_type()
// && ObVarcharType >= column_schema[column_pos].get_type())
// {
// break;
// }
//}
column_pos=0;
lrand48_r(&rand_data, &rand);
switch (column_schema[column_pos].get_type())
{
case ObIntType:
{
int64_t tmp = rand;
obj.set_int(tmp, ADD == op_type);
break;
}
case ObFloatType:
{
float tmp = static_cast<float>(rand);
obj.set_float(tmp, ADD == op_type);
break;
}
case ObDoubleType:
{
double tmp = static_cast<double>(rand);
obj.set_double(tmp, ADD == op_type);
break;
}
case ObDateTimeType:
{
ObDateTime tmp = static_cast<ObDateTime>(rand);
obj.set_datetime(tmp, ADD == op_type);
break;
}
case ObPreciseDateTimeType:
{
ObPreciseDateTime tmp = static_cast<ObPreciseDateTime>(rand);
obj.set_precise_datetime(tmp, ADD == op_type);
break;
}
case ObVarcharType:
{
int64_t length = range_rand(1, column_schema[column_pos].get_size(), rand);
char *ptr = allocer.alloc(length);
build_string(ptr, length, rand);
ObString str;
str.assign_ptr(ptr, length);
if (ADD == op_type)
{
op_type = UPDATE;
}
obj.set_varchar(str);
break;
}
default:
break;
}
if (DEL_CELL == op_type)
{
obj.set_null();
}
else if (DEL_ROW == op_type)
{
obj.set_ext(ObActionFlag::OP_DEL_ROW);
}
}
