int ObMergerTabletLocationCache::update(const uint64_t table_id, const ObString & rowkey,
const ObMergerTabletLocationList & location)
{
int ret = OB_SUCCESS;
if (!init_)
{
TBSYS_LOG(ERROR, "%s", "check init failed");
ret = OB_INNER_STAT_ERROR;
}
else if ((0 == rowkey.length()) || (NULL == rowkey.ptr()))
{
TBSYS_LOG(ERROR, "%s", "check rowkey length failed");
ret = OB_INPUT_PARAM_ERROR;
}
else
{
char * temp = (char *)ob_malloc(sizeof(table_id) + rowkey.length(),ObModIds::OB_MS_LOCATION_CACHE);
if (NULL == temp)
{
TBSYS_LOG(ERROR, "check ob malloc failed:size[%lu], pointer[%p]",
sizeof(table_id) + rowkey.length(), temp);
ret = OB_ALLOCATE_MEMORY_FAILED;
}
else
{
ObRange range;
ObString CacheKey;
// encode table_id + rowkey as CacheKey
*((uint64_t *) temp) = table_id;
memcpy(temp + sizeof(uint64_t), rowkey.ptr(), rowkey.length());
CacheKey.assign(temp, static_cast<int32_t>(sizeof(table_id) + rowkey.length()));
// get the pair according to the key
ObCachePair pair;
ret = tablet_cache_.get(CacheKey, pair);
if (OB_SUCCESS != ret)
{
TBSYS_LOG(DEBUG, "find tablet from cache failed:table_id[%lu], length[%d]",
table_id, rowkey.length());
}
else
{
int64_t pos = 0;
// TODO double check pair.key whether as equal with CacheKey
ret = range.deserialize(pair.get_key().ptr(), pair.get_key().length(), pos);
if (OB_SUCCESS != ret)
{
TBSYS_LOG(ERROR, "deserialize tablet range failed:table_id[%lu], ret[%d]",
table_id, ret);
}
else
{
ret = set(range, location);
}
}
// destory the temp buffer
ob_free(temp);
}
}
return ret;
}
int64_t ObStringSearch::fast_search(const ObString & pattern, const ObString & text)
{
const char* pat = pattern.ptr();
const int64_t pat_len = pattern.length();
const char* txt = text.ptr();
const int64_t txt_len = text.length();
return fast_search(pat, pat_len, txt, txt_len);
}
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;
}
int ObFileService::check_dir(const ObString& local_dir, const int64_t file_size)
{
int ret = OB_SUCCESS;
char path_buf[OB_MAX_FILE_NAME_LENGTH];
if (OB_SUCCESS == ret)
{
// check if the dir is allowed to write
struct stat dir_stat;
int n = snprintf(path_buf, OB_MAX_FILE_NAME_LENGTH, "%.*s",
local_dir.length(), local_dir.ptr());
if (n<0 || n>=OB_MAX_FILE_NAME_LENGTH)
{
ret = OB_SIZE_OVERFLOW;
TBSYS_LOG(ERROR, "local_dir length is overflow, length[%d] str[%.*s]",
local_dir.length(), local_dir.length(), local_dir.ptr());
}
else if (stat(path_buf, &dir_stat) != 0)
{
TBSYS_LOG(WARN, "get local directory[%s] stat fail: %s",
path_buf, strerror(errno));
ret = OB_IO_ERROR;
}
else if (!(S_IWUSR & dir_stat.st_mode))
{
TBSYS_LOG(WARN, "local dir[%s] cannot be written", path_buf);
ret = OB_IO_ERROR;
}
}
if (OB_SUCCESS == ret)
{
// check the free space
struct statvfs dir_statvfs;
if (statvfs(path_buf, &dir_statvfs) != 0)
{
TBSYS_LOG(WARN, "get disk free space of %s info fail: %s",
path_buf, strerror(errno));
ret = OB_IO_ERROR;
}
else
{
int64_t free_space = dir_statvfs.f_bavail * dir_statvfs.f_bsize;
if(file_size > free_space)
{
TBSYS_LOG(WARN, "free disk space of %s is not enough: file_size[%ld]"
" free_space[%ld]", path_buf, file_size, free_space);
ret = OB_CS_OUTOF_DISK_SPACE;
}
}
}
return ret;
}
int ObStringBuf :: write_string(const ObString& str, ObString* stored_str)
{
int err = OB_SUCCESS;
if (0 == str.length() || NULL == str.ptr())
{
if (NULL != stored_str)
{
stored_str->assign(NULL, 0);
}
}
else
{
int64_t str_length = str.length();
if (NULL == block_tail_ ||
(NULL != block_tail_ &&
block_tail_->block_size - block_tail_->cur_pos <= str_length))
{
err = alloc_a_block_();
if (OB_SUCCESS != err)
{
TBSYS_LOG(WARN, "failed to alloc_a_block_, err=%d", err);
}
}
if (OB_SUCCESS == err)
{
if (NULL == block_tail_ ||
(NULL != block_tail_ &&
block_tail_->block_size - block_tail_->cur_pos <= str_length))
{
// buffer still not enough
err = OB_ERROR;
}
else
{
memcpy(block_tail_->data + block_tail_->cur_pos, str.ptr(), str.length());
if (NULL != stored_str)
{
stored_str->assign(block_tail_->data + block_tail_->cur_pos, str.length());
}
block_tail_->cur_pos += str_length;
total_res_ += str_length;
}
}
}
return err;
}
int ObUserInfoKey::set_user_name(ObString name)
{
int ret = OB_SUCCESS;
if (NULL == name.ptr())
{
TBSYS_LOG(WARN, "illegal argument name[%p]", name.ptr());
ret = OB_ERROR;
}
else
{
user_name_ = name.ptr();
length_ = name.length();
}
return ret;
}
int ObUserInfoValue::set_passwd(ObString pass)
{
int ret = OB_SUCCESS;
if (NULL == pass.ptr())
{
TBSYS_LOG(WARN, "illegal argument passwd[%p]", pass.ptr());
ret = OB_ERROR;
}
else
{
passwd_ = pass.ptr();
length_ = pass.length();
}
return ret;
}
int ObSKeyInfoValue::set_skey(ObString key)
{
int ret = OB_SUCCESS;
if (NULL == key.ptr())
{
TBSYS_LOG(WARN, "illegal argument skey[%p]", key.ptr());
ret = OB_ERROR;
}
else
{
skey_ = key.ptr();
length_ = key.length();
}
return ret;
}
int ObBlockIndexCache::get_block_position_info(
const ObBlockIndexPositionInfo& block_index_info,
const uint64_t table_id,
const uint64_t column_group_id,
const ObString& key,
const SearchMode search_mode,
ObBlockPositionInfos& pos_info)
{
int ret = OB_SUCCESS;
bool revert_handle = false;
ObSSTableBlockIndexV2 block_index;
Handle handle;
if (OB_SUCCESS != (ret =
check_param(block_index_info, table_id, column_group_id)))
{
TBSYS_LOG(ERROR, "check_param error, table_id=%ld, column_group_id=%ld",
table_id, column_group_id);
}
else if ( is_regular_mode(search_mode)
&& (NULL == key.ptr() || key.length() <= 0) )
{
TBSYS_LOG(WARN, "invalid param, key_ptr=%p, key_len=%d",
key.ptr(), key.length());
ret = OB_INVALID_ARGUMENT;
}
else if ( OB_SUCCESS != (ret =
load_block_index(block_index_info, block_index, table_id, handle)) )
{
TBSYS_LOG(ERROR, "load block index error, ret=%d, table_id=%ld"
"column_group_id=%ld, mode=%d, pos=%ld",
ret, table_id, column_group_id, search_mode, pos_info.block_count_);
}
else
{
revert_handle = true;
ret = block_index.search_batch_blocks_by_key(
table_id, column_group_id, key, search_mode, pos_info);
}
if (revert_handle && OB_SUCCESS != kv_cache_.revert(handle))
{
//must revert the handle
TBSYS_LOG(WARN, "failed to revert block index cache handle");
}
return ret;
}
int get_rowkey_info_from_sm(const ObSchemaManagerV2* schema_mgr,
const uint64_t table_id, const ObString& table_name, ObRowkeyInfo& rowkey_info)
{
int ret = OB_SUCCESS;
const ObTableSchema* tbl = NULL;
if (NULL == schema_mgr)
{
ret = OB_INVALID_ARGUMENT;
}
else if (table_id > 0 && table_id != OB_INVALID_ID)
{
tbl = schema_mgr->get_table_schema(table_id);
}
else if (NULL != table_name.ptr())
{
tbl = schema_mgr->get_table_schema(table_name);
}
if (NULL == tbl)
{
ret = OB_INVALID_ARGUMENT;
}
else
{
rowkey_info = tbl->get_rowkey_info();
}
return ret;
}
TEST_F(ObSqlExpressionTest, copy_operator_test)
{
ObString stdstring;
stdstring.assign((char*)"hello world", 11);
ObSqlExpression p;
ExprItem item_b;
item_b.type_ = T_STRING;
item_b.string_.assign((char*)"hello world", 11);
p.add_expr_item(item_b);
ObRow row;
const ObObj *result = NULL;
p.add_expr_item_end();
p.calc(row, result);
//int64_t re;
ObString mystring;
EXPECT_EQ(OB_SUCCESS, result->get_varchar(mystring));
EXPECT_EQ(mystring, stdstring);
// test deep copy
ObSqlExpression q;
q = p;
p.~ObSqlExpression();
memset(&p, 0, sizeof(p));
EXPECT_EQ(OB_SUCCESS, q.calc(row, result));
EXPECT_EQ(OB_SUCCESS, result->get_varchar(mystring));
EXPECT_EQ(mystring, stdstring);
TBSYS_LOG(INFO, "%.*s", mystring.length(), mystring.ptr());
//ASSERT_EQ();
}
int ObSystemConfigKey::set_varchar(const ObString &key, const char * strvalue)
{
int ret = OB_SUCCESS;
if (NULL == strvalue)
{
TBSYS_LOG(WARN, "check varchar value failed");
ret = OB_INVALID_ARGUMENT;
}
else if (key == ObString::make_string("svr_type"))
{
strncpy(server_type_, strvalue, sizeof (server_type_));
server_type_[OB_SERVER_TYPE_LENGTH - 1] = '\0';
}
else if (key == ObString::make_string("svr_ip"))
{
strncpy(server_ip_, strvalue, sizeof (server_ip_));
server_ip_[OB_MAX_SERVER_ADDR_SIZE - 1] = '\0';
}
else
{
ret = OB_INVALID_ARGUMENT;
TBSYS_LOG(ERROR, "unknow sys config column name: %.*s",
key.length(), key.ptr());
}
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;
}
int CellinfoBuilder::get_mutator(const ObString &row_key, const ObSchema &schema, int64_t &cur_seed,
ObMutator &mutator, PageArena<char> &allocer)
{
int ret = OB_SUCCESS;
int64_t sign = ob_crc64(row_key.ptr(), row_key.length());
uint64_t table_id = schema.get_table_id();
sign = ob_crc64(sign, &table_id, sizeof(uint64_t));
struct drand48_data rand_data;
cur_seed += 1;
srand48_r(sign + cur_seed, &rand_data);
int64_t rand = 0;
lrand48_r(&rand_data, &rand);
int64_t op_num = range_rand(1, max_op_num_, rand);
for (int64_t i = 0; i < op_num; i++)
{
ret = build_operator_(rand_data, row_key, schema, mutator, allocer);
if (OB_SUCCESS != ret)
{
break;
}
}
ObString table_name;
table_name.assign_ptr(const_cast<char*>(schema.get_table_name()), strlen(schema.get_table_name()));
ObString column_name;
column_name.assign_ptr(SEED_COLUMN_NAME, strlen(SEED_COLUMN_NAME));
ObObj obj;
obj.set_int(cur_seed);
mutator.update(table_name, row_key, column_name, obj);
return ret;
}
int ObAlterTableStmt::set_new_table_name(ResultPlan& result_plan, const ObString& table_name)
{
int& ret = result_plan.err_stat_.err_code_ = OB_SUCCESS;
ObSchemaChecker* schema_checker = NULL;
if (name_pool_ == NULL)
{
ret = OB_NOT_INIT;
snprintf(result_plan.err_stat_.err_msg_, MAX_ERROR_MSG,
"Name pool need to be set, ret=%d", ret);
}
else if ((schema_checker = static_cast<ObSchemaChecker*>(result_plan.schema_checker_)) == NULL)
{
ret = OB_ERR_SCHEMA_UNSET;
snprintf(result_plan.err_stat_.err_msg_, MAX_ERROR_MSG,
"Schema(s) are not set");
}
else if(schema_checker->get_table_id(table_name) != OB_INVALID_ID)
{
ret = OB_ERR_TABLE_UNKNOWN;
snprintf(result_plan.err_stat_.err_msg_, MAX_ERROR_MSG,
"Table '%.*s' already exist", table_name.length(), table_name.ptr());
}
else if ((ret = ob_write_string(*name_pool_, table_name, new_table_name_)) != OB_SUCCESS)
{
snprintf(result_plan.err_stat_.err_msg_, MAX_ERROR_MSG,
"Allocate memory for table name failed");
}
return ret;
}
int ObSSTableBlockIndexBuilder::add_entry(const uint64_t table_id,
const uint64_t column_group_id,
const ObString &key,
const int32_t record_size)
{
int ret = OB_SUCCESS;
ObSSTableBlockIndexItem index_item;
if (record_size < 0 || key.length() <= 0 || NULL == key.ptr()
|| table_id == OB_INVALID_ID || table_id == 0 || OB_INVALID_ID == column_group_id)
{
TBSYS_LOG(WARN, "invalid param, table_id=%lu, key_len=%d,"
"key_ptr=%p, record_size=%d, column_group_id=%lu",
table_id, key.length(), key.ptr(), record_size, column_group_id);
ret = OB_ERROR;
}
if (OB_SUCCESS == ret)
{
index_item.rowkey_column_count_ = 0;
index_item.column_group_id_ = static_cast<uint16_t>(column_group_id);
index_item.table_id_ = static_cast<uint32_t>(table_id);
index_item.block_record_size_ = record_size;
index_item.block_end_key_size_ = static_cast<int16_t>(key.length());
index_item.reserved_ = 0;
ret = index_items_buf_.add_index_item(index_item);
if (OB_SUCCESS == ret)
{
ret = end_keys_buf_.add_key(key);
if (OB_ERROR == ret)
{
TBSYS_LOG(WARN, "failed to add end key");
}
else
{
index_block_header_.sstable_block_count_++;
}
}
else
{
TBSYS_LOG(WARN, "failed to add index item");
ret = OB_ERROR;
}
}
return ret;
}
bool RowChecker::is_prefix_changed(const ObString &row_key)
{
bool bret = false;
if (NULL == last_row_key_.ptr() && NULL != row_key.ptr())
{
bret = true;
}
else if (NULL != last_row_key_.ptr() && NULL == row_key.ptr())
{
bret = true;
}
else if (0 != memcmp(last_row_key_.ptr(), row_key.ptr(), RowkeyBuilder::I64_STR_LENGTH))
{
bret = true;
}
return bret;
}
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;
}
TEST_F(ObRowkeyTest, cast)
{
// (1, '2013-1-7', 'yes', true) ==> (varchar, datetime, bool, varchar)
ObRowkeyInfo rowkey_info;
ObRowkeyColumn rowkey_col;
rowkey_col.length_ = 0;
rowkey_col.column_id_ = 0;
rowkey_col.type_ = ObVarcharType;
ASSERT_EQ(OB_SUCCESS, rowkey_info.add_column(rowkey_col));
rowkey_col.type_ = ObPreciseDateTimeType;
ASSERT_EQ(OB_SUCCESS, rowkey_info.add_column(rowkey_col));
rowkey_col.type_ = ObBoolType;
ASSERT_EQ(OB_SUCCESS, rowkey_info.add_column(rowkey_col));
rowkey_col.type_ = ObVarcharType;
ASSERT_EQ(OB_SUCCESS, rowkey_info.add_column(rowkey_col));
ASSERT_EQ(4, rowkey_info.get_size());
// cons rowkey
ObObj rowkey_objs[4];
rowkey_objs[0].set_int(1234);
rowkey_objs[1].set_varchar(ObString::make_string("2013-1-7"));
rowkey_objs[2].set_varchar(ObString::make_string("yes"));
rowkey_objs[3].set_bool(true);
ObRowkey rowkey;
rowkey.assign(rowkey_objs, 4);
// cast
char buff[1024];
memset(buff, 0, 1024);
int64_t used_len = 0;
ASSERT_EQ(OB_SUCCESS, ob_cast_rowkey(rowkey_info, rowkey, buff, 1024, used_len));
// verify
ObString varchar;
ObPreciseDateTime dt;
bool bool_val = false;
ASSERT_EQ(OB_SUCCESS, rowkey.get_obj_ptr()[0].get_varchar(varchar));
ASSERT_STREQ("1234", varchar.ptr());
ASSERT_EQ(OB_SUCCESS, rowkey.get_obj_ptr()[1].get_precise_datetime(dt));
ASSERT_EQ(OB_SUCCESS, rowkey.get_obj_ptr()[2].get_bool(bool_val));
ASSERT_EQ(true, bool_val);
ASSERT_EQ(OB_SUCCESS, rowkey.get_obj_ptr()[3].get_varchar(varchar));
ASSERT_STREQ("true", varchar.ptr());
ASSERT_EQ(8, used_len);
}
bool ObSchemaChecker::is_rowkey_column(const ObString& table_name, const ObString& column_name) const
{
bool is_rowkey = false;
const ObTableSchema *table_schema = NULL;
uint64_t column_id = OB_INVALID_ID;
if ((table_schema = get_table_schema(table_name)) == NULL)
{
TBSYS_LOG(DEBUG, "Get table '%.*s' schema failed", table_name.length(), table_name.ptr());
}
else if ((column_id = get_column_id(table_name, column_name)) == OB_INVALID_ID)
{
TBSYS_LOG(DEBUG, "Get column id failed, column name = %.*s",
column_name.length(), column_name.ptr());
}
else if (table_schema->get_rowkey_info().is_rowkey_column(column_id))
{
is_rowkey = true;
}
return is_rowkey;
}
void print(const ObString& p)
{
char str[1024];
int i = 0;
for (; i < p.length() && i < 1023; ++i)
{
str[i] = *(p.ptr() + i);
}
str[i]=0;
TBSYS_LOG(INFO, "%s", str);
}
int ObSSTableBlockIndexBuffer::add_key(const ObString& key)
{
int ret = OB_SUCCESS;
if (0 >= key.length() || NULL == key.ptr())
{
TBSYS_LOG(WARN, "invalid argument key_len=%d, key_ptr=%p", key.length(), key.ptr());
ret = OB_ERROR;
}
if (OB_SUCCESS == ret)
{
if (NULL == block_tail_ ||
(NULL != block_tail_ && block_tail_->block_size_ - block_tail_->cur_pos_ <= key.length()))
{
ret = alloc_block();
if (OB_ERROR == ret)
{
TBSYS_LOG(WARN, "failed to alloc mem block ret=%d",ret);
}
}
if (OB_SUCCESS == ret)
{
if (NULL == block_tail_ ||
(NULL != block_tail_ && block_tail_->block_size_ - block_tail_->cur_pos_ <= key.length()))
{
ret = OB_ERROR;
}
else
{
memcpy(block_tail_->data_ + block_tail_->cur_pos_, key.ptr(), key.length());
data_size_ += key.length();
block_tail_->cur_pos_ += key.length();
}
}
}
return ret;
}
int64_t MutatorBuilder::get_schema_pos(const ObString &table_name) const
{
int64_t ret = -1;
for (int64_t i = 0; i < table_num_; i++)
{
if (0 == memcmp(schema_mgr_.begin()[i].get_table_name(), table_name.ptr(), table_name.length()))
{
ret = i;
break;
}
}
return ret;
}
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 ObAlterTableStmt::set_table_name(ResultPlan& result_plan, const ObString& table_name)
{
int& ret = result_plan.err_stat_.err_code_ = OB_SUCCESS;
ObSchemaChecker* schema_checker = NULL;
const ObTableSchema* table_schema = NULL;
if ((schema_checker = static_cast<ObSchemaChecker*>(result_plan.schema_checker_)) == NULL)
{
ret = OB_ERR_SCHEMA_UNSET;
snprintf(result_plan.err_stat_.err_msg_, MAX_ERROR_MSG,
"Schema(s) are not set");
}
else if ((table_schema = schema_checker->get_table_schema(table_name)) == NULL)
{
ret = OB_ERR_TABLE_UNKNOWN;
snprintf(result_plan.err_stat_.err_msg_, MAX_ERROR_MSG,
"Table '%.*s' doesn't exist", table_name.length(), table_name.ptr());
}
else if((table_id_ = table_schema->get_table_id()) == OB_INVALID_ID)
{
ret = OB_ERR_TABLE_UNKNOWN;
snprintf(result_plan.err_stat_.err_msg_, MAX_ERROR_MSG,
"Table '%.*s' doesn't exist", table_name.length(), table_name.ptr());
}
else if ((max_column_id_ = table_schema->get_max_column_id()) == OB_INVALID_ID)
{
ret = OB_ERROR;
snprintf(result_plan.err_stat_.err_msg_, MAX_ERROR_MSG,
"Get max column id of Table '%.*s' failed", table_name.length(), table_name.ptr());
}
else if ((ret = ob_write_string(*name_pool_, table_name, table_name_)) != OB_SUCCESS)
{
snprintf(result_plan.err_stat_.err_msg_, MAX_ERROR_MSG,
"Allocate memory for table name failed");
}
return ret;
}
int64_t ObFakeSqlUpsRpcProxy2::get_int(ObRowkey rowkey)
{
int64_t ret = 0;
int num = strlen("rowkey_");
ObString key;
rowkey.ptr()[0].get_varchar(key);
int pow = 1;
for(int i=5-1; i>=0; i--)
{
char c = key.ptr()[i+num];
ret += (c - '0') * pow;
pow *= 10;
}
return ret;
}
int TaskFactory::init_new_task(const ObString & table_name, const ObString & start_key,
const ObString & end_key, ObScanParam & scan_param, TaskInfo & task) const
{
int ret = OB_SUCCESS;
if (!check_string(table_name) || !check_string(end_key))
{
TBSYS_LOG(WARN, "check table name or end key failed:name[%.*s], end_key[%.*s]",
table_name.length(), table_name.ptr(), end_key.length(), end_key.ptr());
ret = OB_ERROR;
}
else
{
ObRange range;
range.border_flag_.unset_inclusive_start();
range.border_flag_.set_inclusive_end();
if (NULL == start_key.ptr())
{
range.border_flag_.set_min_value();
}
else
{
range.start_key_ = start_key;
range.border_flag_.unset_min_value();
}
range.border_flag_.unset_max_value();
range.end_key_ = end_key;
scan_param.set(OB_INVALID_ID, table_name, range);
ret = task.set_param(scan_param);
if (ret != OB_SUCCESS)
{
TBSYS_LOG(ERROR, "set param failed:ret[%d]", ret);
}
}
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;
}
void print_rowkey(FILE *fd, ObString &rowkey)
{
char* pchar = rowkey.ptr();
for (int i = 0; i < rowkey.length(); ++i, pchar++)
{
if (isprint(*pchar))
{
fprintf(fd, "%c", *pchar);
}
else
{
fprintf(fd, "\\%hhu", *pchar);
}
}
}
