TEST_F(TestObStringSearch, test_kr_fast_print)
{
const char *pattern[8]={"Free softw","d be free "," socially ","bjects—su"," that it c","y. These p","abcdefghigklmnopqrstuvwxyzABCDEFGIJKLMNOPQRSTUVWXYZ", "hellohello"};
const char *text = "Free software is a matter of freedom: people should be free to use software in all the ways that are socially useful. Software differs from material objects—such as chairs, sandwiches, and gasoline—in that it can be copied and changed much more easily. These possibilities make software as useful as abcdefghigklmnopqrstuvwxyzABCDEFGIJKLMNOPQRSTUVWXYZabcdefghigklmnopqrstuvwxyz it is; we believe software use";
ObString txt;
txt.assign(const_cast<char*>(text), strlen(text));
for (int i = 0; i < 8; ++i)
{
ObString pat(strlen(pattern[i]), strlen(pattern[i]), const_cast<char*>(pattern[i]));
uint64_t pat_print = ObStringSearch::cal_print(pat);
if ( 7 == i)
{
EXPECT_EQ(-1, ObStringSearch::kr_search(pat, pat_print, txt));
EXPECT_EQ(-1, ObStringSearch::kr_search(pat, txt));
EXPECT_EQ(-1, ObStringSearch::fast_search(pat, txt));
}
else
{
EXPECT_EQ(0, memcmp(pattern[i], text+ObStringSearch::kr_search(pat, pat_print, txt), strlen(pattern[i])));
EXPECT_TRUE(0 == memcmp(pattern[i], text+ObStringSearch::kr_search(pat, txt), strlen(pattern[i])));
EXPECT_TRUE(0 == memcmp(pattern[i], text+ObStringSearch::fast_search(pat, txt), strlen(pattern[i])));
}
EXPECT_TRUE(ObStringSearch::kr_search(pat, pat_print, txt) == ObStringSearch::kr_search(pat, txt));
EXPECT_TRUE(ObStringSearch::kr_search(pat, txt) == ObStringSearch::fast_search(pat, txt));
}
}
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 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;
}
int TaskFactory::add_columns_conf(const uint64_t table_id, common::ObScanParam & param, const TableConf *conf)
{
int ret = OB_SUCCESS;
TableConf::ColumnIterator itr = conf->column_begin();
ObString column;
while (itr != conf->column_end())
{
const char *column_name = *itr;
if (conf->is_null_column(column_name) || conf->is_rowkey(column_name))
{
itr++;
continue;
}
TBSYS_LOG(DEBUG, "columns with conf, column = %s", column_name);
column.assign(const_cast<char *>(*itr), (int32_t)strlen(column_name));
ret = param.add_column(column);
if (ret != OB_SUCCESS)
{
TBSYS_LOG(ERROR, "add column failed:table[%lu], column[%s], ret[%d]",
table_id, column_name, ret);
ret = OB_ERROR;
break;
}
itr++;
}
return ret;
}
/* only support integer and string */
void ObScannerLoader::auto_set_val(ObObj &val, char *buf)
{
if (NULL == buf)
{
TBSYS_LOG(ERROR, "invalid scanner data input");
}
else
{
int len = static_cast<int32_t>(strlen(buf));
int i = 0;
ObString tmpstr;
bool is_num = true;
for(i = 0; i < len; i++)
{
if (!isdigit(buf[i]))
{
is_num = false;
break;
}
}
if (is_num)
{
val.set_int(atoi(buf));
}
else
{
tmpstr.assign(buf, static_cast<int32_t>(strlen(buf)));
val.set_varchar(tmpstr);
}
//val.dump();
}
}
TEST_F(TestCacheTable, test_compare)
{
char temp[100];
char temp_end[100];
ObRange range;
sprintf(temp, "%d", 1001);
sprintf(temp_end, "%d", 100100);
ObString start_key(100, static_cast<int32_t>(strlen(temp)), temp);
ObString end_key(100, static_cast<int32_t>(strlen(temp_end)), temp_end);
range.start_key_ = start_key;
range.end_key_ = end_key;
range.table_id_ = 100;
ObCBtreeTable<int, int>::MapKey key;
ObString rowkey;
// bad case bug
char * cmp_key = (char*)"100";
rowkey.assign(cmp_key, static_cast<int32_t>(strlen(cmp_key)));
ObBorderFlag row_key_flag;
int ret = key.compare_range_with_key(100, rowkey, row_key_flag, ObCBtreeTable<int, int>::OB_SEARCH_MODE_EQUAL, range);
// bug fix EXPECT_TRUE(ret == 0);
EXPECT_TRUE(ret < 0);
// good case
cmp_key = (char*)"10010";
rowkey.assign(cmp_key, static_cast<int32_t>(strlen(cmp_key)));
ret = key.compare_range_with_key(100, rowkey, row_key_flag, ObCBtreeTable<int, int>::OB_SEARCH_MODE_EQUAL, range);
EXPECT_TRUE(ret == 0);
cmp_key = (char*)"101";
rowkey.assign(cmp_key, static_cast<int32_t>(strlen(cmp_key)));
ret = key.compare_range_with_key(100, rowkey, row_key_flag, ObCBtreeTable<int, int>::OB_SEARCH_MODE_EQUAL, range);
EXPECT_TRUE(ret > 0);
cmp_key = (char*)"1001002";
rowkey.assign(cmp_key, static_cast<int32_t>(strlen(cmp_key)));
ret = key.compare_range_with_key(100, rowkey, row_key_flag, ObCBtreeTable<int, int>::OB_SEARCH_MODE_EQUAL, range);
EXPECT_TRUE(ret > 0);
// bad case bug
cmp_key = (char*)"10010002";
rowkey.assign(cmp_key, static_cast<int32_t>(strlen(cmp_key)));
ret = key.compare_range_with_key(100, rowkey, row_key_flag, ObCBtreeTable<int, int>::OB_SEARCH_MODE_EQUAL, range);
// buf fix EXPECT_TRUE(ret == 0);
EXPECT_TRUE(ret > 0);
}
int ObPermInfoKey::build_get_param(ObGetParam & get_param)
{
int ret = OB_SUCCESS;
ObCellInfo cell_info;
ObString rowkey;
ObVersionRange ver_range;
int64_t pos = 0;
if (NULL == buffer_)
{
buffer_ = reinterpret_cast<char*>(ob_malloc(BUF_SIZE));
}
if (NULL != buffer_)
{
int64_t encode_pos = pos;
ret = serialization::encode_i64(buffer_, BUF_SIZE, encode_pos, table_id_);
if (OB_SUCCESS != ret)
{
TBSYS_LOG(ERROR, "encode failed table_id=%ld", table_id_);
}
else
{
memcpy(buffer_ + encode_pos, user_name_, length_);
encode_pos += length_;
rowkey.assign(buffer_ + pos, static_cast<int32_t>(encode_pos - pos));
get_param.set_is_result_cached(true);
cell_info.table_id_ = PERM_TABLE_ID;
cell_info.row_key_ = rowkey;
cell_info.column_id_ = PERM_COL_ID;
ret = get_param.add_cell(cell_info);
if (OB_SUCCESS != ret)
{
TBSYS_LOG(ERROR, "Get param add cell failed table_id[%lu]", cell_info.table_id_);
}
else
{
ver_range.start_version_ = 0;
ver_range.end_version_ = INT64_MAX - 1;
ver_range.border_flag_.set_inclusive_start();
ver_range.border_flag_.set_inclusive_end();
get_param.set_version_range(ver_range);
}
}
}
else
{
TBSYS_LOG(ERROR, "malloc key buffer failed");
ret = OB_ERROR;
}
return ret;
}
int write_cg_sstable(const ObCellInfo** cell_infos,
const int64_t row_num, const int64_t col_num, const char* sstable_file_path )
{
int err = OB_SUCCESS;
EXPECT_TRUE(NULL != cell_infos);
EXPECT_TRUE(row_num > 0);
EXPECT_TRUE(col_num > 0);
if (sstable_file_path) unlink(sstable_file_path);
ObSSTableSchema sstable_schema;
generate_cg_schema(sstable_schema, cell_infos, 12, 0, 1);
generate_cg_schema(sstable_schema, cell_infos, 13, 1, 3);
generate_cg_schema(sstable_schema, cell_infos, 15, 3, col_num);
ObString path;
ObString compress_name;
const char* path_str = NULL;
if (NULL != sstable_file_path)
{
path_str = sstable_file_path;
}
else
{
path_str = DEF_SSTABLE_PATH;
}
path.assign((char*) path_str, static_cast<int32_t>(strlen(path_str)));
compress_name.assign((char*)"lzo", static_cast<int32_t>(strlen("lzo")));
ObSSTableWriter writer;
uint64_t table_id = cell_infos[0][0].table_id_;
err = writer.create_sstable(sstable_schema, path, compress_name, table_id);
EXPECT_EQ(0, err);
err = append_cg_rows(writer, cell_infos, 12, row_num, 0, 1);
EXPECT_EQ(0, err);
err = append_cg_rows(writer, cell_infos, 13, row_num, 1, 3);
EXPECT_EQ(0, err);
err = append_cg_rows(writer, cell_infos, 15, row_num, 3, col_num);
EXPECT_EQ(0, err);
int64_t offset = 0;
err = writer.close_sstable(offset);
EXPECT_EQ(0, err);
return err;
}
int TaskFactory::add_all_columns(const uint64_t table_id, ObScanParam & param)
{
int ret = OB_SUCCESS;
int32_t count = 0;
const ObColumnSchemaV2 * column_schema = schema_->get_table_schema(table_id, count);
if ((NULL == column_schema) || (0 == count))
{
ret = OB_ERROR;
TBSYS_LOG(ERROR, "check column schema or schema count failed:column[%p], count[%d]",
column_schema, count);
}
else
{
ObString column;
const char * column_name = NULL;
for (int32_t i = 0; i < count; ++i)
{
column_name = column_schema->get_name();
if (column_name != NULL)
{
TBSYS_LOG(DEBUG, "TableId:%ld, COLUMN=%s", table_id, column_name);
column.assign(const_cast<char *>(column_name), (int32_t)strlen(column_name));
ret = param.add_column(column);
if (ret != OB_SUCCESS)
{
TBSYS_LOG(ERROR, "add column failed:table[%lu], column[%s], ret[%d]",
table_id, column_name, ret);
ret = OB_ERROR;
break;
}
}
else
{
ret = OB_ERROR;
TBSYS_LOG(ERROR, "check column name failed:table[%lu], name[%s]", table_id, column_name);
break;
}
++column_schema;
}
}
return ret;
}
ObCellInfo *callback_func_get_cell_info(const char* column_name)
{
TBSYS_LOG(INFO, "%s", column_name);
if (0 == strcmp(column_name, "name"))
{
ObString str;
str.assign(config_item_1, (int32_t)strlen(config_item_1));
my_cell_info[0].value_.set_varchar(str);
return &my_cell_info[0];
}
else if (0 == strcmp(column_name, "value"))
{
my_cell_info[1].value_.set_int(102);
return &my_cell_info[1];
}
else
{
return NULL;
}
}
int ObSKeyInfoKey::build_get_param(ObGetParam& get_param)
{
int ret = OB_SUCCESS;
ObCellInfo cell_info;
ObString rowkey;
ObVersionRange ver_range;
int64_t pos = 0;
if (NULL == buffer_)
{
buffer_ = reinterpret_cast<char*>(ob_malloc(BUF_SIZE));
}
ret = serialization::encode_i64(buffer_, BUF_SIZE, pos, skey_version_);
if (OB_SUCCESS != ret)
{
TBSYS_LOG(ERROR, "encode failed pkey_version=%ld", skey_version_);
}
else
{
rowkey.assign(buffer_, static_cast<int32_t>(pos));
get_param.reset();
get_param.set_is_result_cached(true);
cell_info.table_id_ = SKEY_TABLE_ID;
cell_info.row_key_ = rowkey;
cell_info.column_id_ = SKEY_COL_ID;
ret = get_param.add_cell(cell_info);
if (OB_SUCCESS != ret)
{
TBSYS_LOG(ERROR, "Get param add cell failed table_id[%lu]", cell_info.table_id_);
}
else
{
ver_range.start_version_ = 0;
ver_range.end_version_ = INT64_MAX - 1;
ver_range.border_flag_.set_inclusive_start();
ver_range.border_flag_.set_inclusive_end();
get_param.set_version_range(ver_range);
}
}
return ret;
}
int ObMergerTabletLocationCache::del(const uint64_t table_id, const ObString & rowkey)
{
int ret = OB_SUCCESS;
if (!init_)
{
TBSYS_LOG(ERROR, "%s", "check init failed");
ret = OB_INNER_STAT_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
{
// construct table_id + rowkey to CacheKey as cache key
ObString CacheKey;
*(reinterpret_cast<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()));
ret = tablet_cache_.remove(CacheKey);
if (OB_SUCCESS != ret)
{
TBSYS_LOG(DEBUG, "find this row tablet failed:table_id[%lu], length[%d]",
table_id, rowkey.length());
}
else
{
TBSYS_LOG(DEBUG, "%s", "del this location from cache succ");
}
// destory the temp buffer
ob_free(temp);
}
}
return ret;
}
int main(int argc, char ** argv)
{
UNUSED(argc);
UNUSED(argv);
int ret = OB_SUCCESS;
//char * test = "00596331192663719";
char * test = "00912219024438372";
ObString rowkey;
rowkey.assign(test, strlen(test));
char temp[1024];
hex_to_str(rowkey.ptr(), rowkey.length(), temp, 1024);
printf("test2str:test[%s], str[%s]\n", test, temp);
int64_t ip = 539289610; //488957962; //522512394;
ObServer server;
server.set_ipv4_addr(ip, 1024);
static const int32_t MAX_SERVER_ADDR_SIZE = 128;
char server_addr[MAX_SERVER_ADDR_SIZE];
server.to_string(server_addr, MAX_SERVER_ADDR_SIZE);
printf("server:[%ld], server[%s]\n", ip, server_addr);
return ret;
}
TEST(get_next_param, orderby)
{
ObStringBuf buf;
ObScanParam scan_param;
ObRange q_range;
ObScanner prev_result;
int64_t prev_limit_offset = 0;
ObRange prev_tablet_range;
ObRange cur_range;
int64_t cur_limit_offset = 0;
uint64_t table_id = 1001;
/// last tablet and full fill
q_range.border_flag_.set_max_value();
q_range.border_flag_.set_min_value();
EXPECT_EQ(scan_param.set(table_id, ObString(),q_range), OB_SUCCESS);
//scan_param.set_scan_direction(ObScanParam::BACKWARD);
prev_tablet_range.border_flag_.set_max_value();
prev_tablet_range.border_flag_.set_min_value();
EXPECT_EQ(scan_param.add_orderby_column(0),OB_SUCCESS);
const char *c_ptr = "9";
ObString str;
ObCellInfo cell;
str.assign((char*)c_ptr, static_cast<int32_t>(strlen(c_ptr)));
EXPECT_EQ(buf.write_string(str, &cell.row_key_),OB_SUCCESS);
EXPECT_EQ(prev_result.add_cell(cell),OB_SUCCESS);
EXPECT_EQ(prev_result.set_is_req_fullfilled(false,1), OB_SUCCESS);
EXPECT_EQ(prev_result.set_range(prev_tablet_range), OB_SUCCESS);
EXPECT_EQ(get_next_range(scan_param, prev_result,prev_limit_offset,cur_range,cur_limit_offset,buf), OB_SUCCESS);
EXPECT_EQ(cur_limit_offset, 1);
EXPECT_TRUE(cur_range.border_flag_.is_min_value());
EXPECT_TRUE(cur_range.border_flag_.is_max_value());
}
TEST(get_next_param, trivial_scan_backward)
{
ObStringBuf buf;
ObScanParam scan_param;
ObRange q_range;
ObScanner prev_result;
int64_t prev_limit_offset = 0;
ObRange prev_tablet_range;
ObRange cur_range;
int64_t cur_limit_offset = 0;
uint64_t table_id = 1001;
/// last tablet and full fill
q_range.border_flag_.set_max_value();
q_range.border_flag_.set_min_value();
EXPECT_EQ(scan_param.set(table_id, ObString(),q_range), OB_SUCCESS);
scan_param.set_scan_direction(ObScanParam::BACKWARD);
prev_tablet_range.border_flag_.set_max_value();
prev_tablet_range.border_flag_.set_min_value();
EXPECT_EQ(prev_result.set_range(prev_tablet_range), OB_SUCCESS);
EXPECT_EQ(prev_result.set_is_req_fullfilled(true,0), OB_SUCCESS);
EXPECT_EQ(get_next_range(scan_param, prev_result,prev_limit_offset,cur_range,cur_limit_offset,buf), OB_ITER_END);
/// last tablet but not fullfill
ObCellInfo cell;
ObString str;
const char *c_ptr = "8";
str.assign((char*)c_ptr, static_cast<int32_t>(strlen(c_ptr)));
EXPECT_EQ(buf.write_string(str, &cell.row_key_),OB_SUCCESS);
EXPECT_EQ(prev_result.add_cell(cell),OB_SUCCESS);
EXPECT_EQ(prev_result.set_is_req_fullfilled(false,1), OB_SUCCESS);
EXPECT_EQ(get_next_range(scan_param, prev_result,prev_limit_offset,cur_range,cur_limit_offset,buf), OB_SUCCESS);
EXPECT_EQ(cur_limit_offset, 0);
EXPECT_TRUE(cur_range.border_flag_.is_min_value());
EXPECT_FALSE(cur_range.border_flag_.is_max_value());
EXPECT_TRUE(cur_range.end_key_ == cell.row_key_);
EXPECT_TRUE(cur_range.border_flag_.is_min_value());
EXPECT_FALSE(cur_range.border_flag_.inclusive_end());
/// middle table and full fill
prev_tablet_range.reset();
cur_range.reset();
prev_result.clear();
prev_tablet_range.start_key_ = cell.row_key_;
c_ptr = "9";
str.assign((char*)c_ptr, static_cast<int32_t>(strlen(c_ptr)));
EXPECT_EQ(buf.write_string(str, &cell.row_key_),OB_SUCCESS);
EXPECT_EQ(prev_result.add_cell(cell),OB_SUCCESS);
EXPECT_EQ(prev_result.set_is_req_fullfilled(true,1), OB_SUCCESS);
EXPECT_EQ(prev_result.set_range(prev_tablet_range), OB_SUCCESS);
EXPECT_EQ(get_next_range(scan_param, prev_result,prev_limit_offset,cur_range,cur_limit_offset,buf), OB_SUCCESS);
EXPECT_EQ(cur_limit_offset, 0);
EXPECT_TRUE(cur_range.border_flag_.is_min_value());
EXPECT_FALSE(cur_range.border_flag_.is_max_value());
EXPECT_TRUE(cur_range.end_key_ == prev_tablet_range.start_key_);
EXPECT_TRUE(cur_range.border_flag_.inclusive_end());
/// middle table and not full fill
cur_range.reset();
prev_result.clear();
c_ptr = "9";
str.assign((char*)c_ptr, static_cast<int32_t>(strlen(c_ptr)));
EXPECT_EQ(buf.write_string(str, &cell.row_key_),OB_SUCCESS);
EXPECT_EQ(prev_result.add_cell(cell),OB_SUCCESS);
EXPECT_EQ(prev_result.set_is_req_fullfilled(false,1), OB_SUCCESS);
EXPECT_EQ(prev_result.set_range(prev_tablet_range), OB_SUCCESS);
EXPECT_EQ(get_next_range(scan_param, prev_result,prev_limit_offset,cur_range,cur_limit_offset,buf), OB_SUCCESS);
EXPECT_EQ(cur_limit_offset, 0);
EXPECT_TRUE(cur_range.border_flag_.is_min_value());
EXPECT_FALSE(cur_range.border_flag_.is_max_value());
EXPECT_TRUE(cur_range.end_key_ == cell.row_key_);
EXPECT_FALSE(cur_range.border_flag_.inclusive_end());
}
TEST(ObGroupByParam, function)
{
char serialize_buf[2048];
int64_t buf_len = sizeof(serialize_buf);
int64_t pos = 0;
int64_t data_len = 0;
/// row width 7;
/// 0, not used int
/// 1, groupby int
/// 2, return int
/// 3, group str
/// 4, group int
/// 5, aggregate column int
/// 6. not used string
ObCellArray org_cell_array;
/// row width 6
/// 0, group int
/// 1, group str
/// 2, return int
/// 3, return str
/// 4, aggregate sum
/// 5, aggregate count
/// ObCellArray agg_cell_array;
ObGroupByOperator agg_operator;
/// ObCellArray all_in_one_group_agg_cell_array;
ObGroupByOperator all_in_one_group_agg_operator;
ObStringBuf buffer;
ObGroupByParam param;
ObGroupByParam all_in_one_group_param;
ObGroupByParam decoded_param;
int64_t basic_column_num = 4;
for (int64_t i = 0; i <= basic_column_num; i++)
{
/// 1, 3
if (i%2)
{
EXPECT_EQ(param.add_groupby_column(i),OB_SUCCESS);
}
}
for (int64_t i = 0; i <= basic_column_num; i++)
{
/// 2, 4
if (i%2 == 0 && i > 0)
{
EXPECT_EQ(param.add_return_column(i),OB_SUCCESS);
}
}
/// 5
EXPECT_EQ(param.add_aggregate_column(basic_column_num+1,SUM),OB_SUCCESS);
EXPECT_EQ(param.add_aggregate_column(basic_column_num+1,COUNT),OB_SUCCESS);
EXPECT_EQ(all_in_one_group_param.add_aggregate_column(basic_column_num + 1, SUM), OB_SUCCESS);
EXPECT_EQ(all_in_one_group_param.add_aggregate_column(basic_column_num + 1, COUNT), OB_SUCCESS);
pos = 0;
EXPECT_EQ(param.serialize(serialize_buf,buf_len,pos), OB_SUCCESS);
data_len = pos;
pos = 0;
EXPECT_EQ(decoded_param.deserialize(serialize_buf,data_len,pos),OB_SUCCESS);
EXPECT_EQ(pos,data_len);
EXPECT_TRUE(decoded_param == param);
EXPECT_EQ(agg_operator.init(param, 1024*1024*1024),OB_SUCCESS);
EXPECT_EQ(all_in_one_group_agg_operator.init(all_in_one_group_param, 1024*1024*1024),OB_SUCCESS);
int64_t agg_sum = 0;
int64_t agg_count = 0;
ObCellInfo cell;
ObInnerCellInfo *cell_out = NULL;
ObString str;
ObObj return_str_obj;
ObObj groupby_str_obj;
const int64_t no_int_value = -1;
const int64_t return_int_value = 0;
ObObj return_int_obj;
return_int_obj.set_int(return_int_value);
const int64_t groupby_int_value = 1;
ObObj groupby_int_obj;
groupby_int_obj.set_int(groupby_int_value);
ObObj agg_sum_obj;
ObObj agg_count_obj;
/// prepare first row in org cell array
/// cell not used, 0
cell.value_.set_int(no_int_value);
EXPECT_EQ(org_cell_array.append(cell, cell_out),OB_SUCCESS);
/// groupby cell, 1
cell.value_.set_int(groupby_int_value);
EXPECT_EQ(org_cell_array.append(cell, cell_out),OB_SUCCESS);
/// return cell, 2
cell.value_.set_int(return_int_value);
EXPECT_EQ(org_cell_array.append(cell, cell_out),OB_SUCCESS);
/// groupby cell, 3
str.assign(const_cast<char*>("groupby"),static_cast<int32_t>(strlen("groupby")));
cell.value_.set_varchar(str);
EXPECT_EQ(org_cell_array.append(cell, cell_out),OB_SUCCESS);
groupby_str_obj = cell_out->value_;
/// return cell, 4
str.assign(const_cast<char*>("return"),static_cast<int32_t>(strlen("return")));
cell.value_.set_varchar(str);
EXPECT_EQ(org_cell_array.append(cell, cell_out),OB_SUCCESS);
return_str_obj = cell_out->value_;
/// aggregate value, 5
cell.value_.set_int(5);
EXPECT_EQ(org_cell_array.append(cell, cell_out),OB_SUCCESS);
agg_count += 1;
agg_sum += 5;
/// cell not used, 6
str.assign(const_cast<char*>("nouse"),static_cast<int32_t>(strlen("nouse")));
cell.value_.set_varchar(str);
EXPECT_EQ(org_cell_array.append(cell, cell_out),OB_SUCCESS);
/// aggregate first cell
EXPECT_EQ(agg_operator.add_row(org_cell_array,0,6), OB_SUCCESS);
agg_sum_obj.set_int(agg_sum);
agg_count_obj.set_int(agg_count);
EXPECT_TRUE(agg_operator[0].value_== groupby_int_obj);
EXPECT_TRUE(agg_operator[1].value_== groupby_str_obj);
EXPECT_TRUE(agg_operator[2].value_== return_int_obj);
EXPECT_TRUE(agg_operator[3].value_== return_str_obj);
EXPECT_TRUE(agg_operator[4].value_== agg_sum_obj);
EXPECT_TRUE(agg_operator[5].value_== agg_count_obj);
EXPECT_EQ(all_in_one_group_agg_operator.add_row(org_cell_array,0,6), OB_SUCCESS);
EXPECT_TRUE(all_in_one_group_agg_operator[0].value_== agg_sum_obj);
EXPECT_TRUE(all_in_one_group_agg_operator[1].value_== agg_count_obj);
/// prepare second row in org cell, only change return column value
/// cell not used, 0
cell.value_.set_int(no_int_value + 5);
EXPECT_EQ(org_cell_array.append(cell, cell_out),OB_SUCCESS);
/// groupby cell, 1
cell.value_.set_int(groupby_int_value);
EXPECT_EQ(org_cell_array.append(cell, cell_out),OB_SUCCESS);
/// return cell, 2
cell.value_.set_int(return_int_value + 6);
EXPECT_EQ(org_cell_array.append(cell, cell_out),OB_SUCCESS);
/// groupby cell, 3
str.assign(const_cast<char*>("groupby"),static_cast<int32_t>(strlen("groupby")));
cell.value_.set_varchar(str);
EXPECT_EQ(org_cell_array.append(cell, cell_out),OB_SUCCESS);
groupby_str_obj = cell_out->value_;
/// return cell, 4
str.assign(const_cast<char*>("return1"),static_cast<int32_t>(strlen("return1")));
cell.value_.set_varchar(str);
EXPECT_EQ(org_cell_array.append(cell, cell_out),OB_SUCCESS);
/// aggregate value, 5
cell.value_.set_int(-8);
EXPECT_EQ(org_cell_array.append(cell, cell_out),OB_SUCCESS);
agg_count += 1;
agg_sum += -8;
/// cell not used, 6
str.assign(const_cast<char*>("nouse1"),static_cast<int32_t>(strlen("nouse1")));
cell.value_.set_varchar(str);
EXPECT_EQ(org_cell_array.append(cell, cell_out),OB_SUCCESS);
/// aggregate second cell
EXPECT_EQ(agg_operator.add_row(org_cell_array,7,13), OB_SUCCESS);
agg_sum_obj.set_int(agg_sum);
agg_count_obj.set_int(agg_count);
EXPECT_TRUE(agg_operator[0].value_== groupby_int_obj);
EXPECT_TRUE(agg_operator[1].value_== groupby_str_obj);
EXPECT_TRUE(agg_operator[2].value_== return_int_obj);
EXPECT_TRUE(agg_operator[3].value_== return_str_obj);
EXPECT_TRUE(agg_operator[4].value_== agg_sum_obj);
EXPECT_TRUE(agg_operator[5].value_== agg_count_obj);
EXPECT_EQ(all_in_one_group_agg_operator.add_row(org_cell_array,7,13), OB_SUCCESS);
EXPECT_TRUE(all_in_one_group_agg_operator[0].value_== agg_sum_obj);
EXPECT_TRUE(all_in_one_group_agg_operator[1].value_== agg_count_obj);
/// prepare third org row, change groupby column value
/// cell not used, 0
cell.value_.set_int(no_int_value + 5);
EXPECT_EQ(org_cell_array.append(cell, cell_out),OB_SUCCESS);
/// groupby cell, 1
cell.value_.set_int(groupby_int_value);
EXPECT_EQ(org_cell_array.append(cell, cell_out),OB_SUCCESS);
/// return cell, 2
cell.value_.set_int(return_int_value + 6);
EXPECT_EQ(org_cell_array.append(cell, cell_out),OB_SUCCESS);
/// groupby cell, 3
str.assign(const_cast<char*>("groupby1"),static_cast<int32_t>(strlen("groupby1")));
cell.value_.set_varchar(str);
EXPECT_EQ(org_cell_array.append(cell, cell_out),OB_SUCCESS);
groupby_str_obj = cell_out->value_;
/// return cell, 4
str.assign(const_cast<char*>("return1"),static_cast<int32_t>(strlen("return1")));
cell.value_.set_varchar(str);
EXPECT_EQ(org_cell_array.append(cell, cell_out),OB_SUCCESS);
/// aggregate value, 5
cell.value_.set_int(-8);
EXPECT_EQ(org_cell_array.append(cell, cell_out),OB_SUCCESS);
agg_count += 1;
agg_sum += -8;
/// cell not used, 6
str.assign(const_cast<char*>("nouse1"),static_cast<int32_t>(strlen("nouse1")));
cell.value_.set_varchar(str);
EXPECT_EQ(org_cell_array.append(cell, cell_out),OB_SUCCESS);
/// aggregate third row
agg_sum_obj.set_int(agg_sum);
agg_count_obj.set_int(agg_count);
EXPECT_EQ(all_in_one_group_agg_operator.add_row(org_cell_array,14,20), OB_SUCCESS);
EXPECT_TRUE(all_in_one_group_agg_operator[0].value_== agg_sum_obj);
EXPECT_TRUE(all_in_one_group_agg_operator[1].value_== agg_count_obj);
}
TEST(ObGroupByParam, row_change)
{
ObGroupByParam param;
ObGroupByOperator groupby_operator;
int64_t groupby_idx = 0;
int64_t agg_idx = 1;
ObAggregateFuncType agg_func = SUM;
EXPECT_EQ(param.add_groupby_column(groupby_idx), OB_SUCCESS);
EXPECT_EQ(param.add_aggregate_column(agg_idx, agg_func),OB_SUCCESS);
ObStringBuf buffer;
ObString str;
const char *c_str = NULL;
ObRowkey rowkey;
ObCellInfo org_cell_info;
ObCellArray org_cells;
ObInnerCellInfo *cell_out;
ObString table_name;
c_str = "table";
str.assign((char*)c_str, static_cast<int32_t>(strlen(c_str)));
EXPECT_EQ(buffer.write_string(str,&(table_name)), OB_SUCCESS);
org_cell_info.table_name_ = table_name;
c_str = "abc";
rowkey = make_rowkey(c_str, &allocator_);
EXPECT_EQ(buffer.write_string(rowkey,&(org_cell_info.row_key_)), OB_SUCCESS);
int groupby_one_val = 1;
org_cell_info.value_.set_int(groupby_one_val);
EXPECT_EQ(org_cells.append(org_cell_info, cell_out),OB_SUCCESS);
EXPECT_EQ(org_cells.append(org_cell_info, cell_out),OB_SUCCESS);
int groupby_two_val = 2;
c_str = "def";
rowkey = make_rowkey(c_str, &allocator_);
EXPECT_EQ(buffer.write_string(rowkey,&(org_cell_info.row_key_)), OB_SUCCESS);
org_cell_info.value_.set_int(groupby_two_val);
EXPECT_EQ(org_cells.append(org_cell_info, cell_out),OB_SUCCESS);
EXPECT_EQ(org_cells.append(org_cell_info, cell_out),OB_SUCCESS);
EXPECT_EQ(groupby_operator.init(param,1024*1024*10), OB_SUCCESS);
EXPECT_EQ(groupby_operator.add_row(org_cells,0,1), OB_SUCCESS);
EXPECT_EQ(groupby_operator.add_row(org_cells, 2,3), OB_SUCCESS);
EXPECT_EQ(groupby_operator.get_cell_size(), 4);
bool is_row_changed = false;
EXPECT_EQ(groupby_operator.next_cell(), OB_SUCCESS);
EXPECT_EQ(groupby_operator.get_cell(&cell_out, &is_row_changed), OB_SUCCESS);
EXPECT_TRUE(is_row_changed);
EXPECT_EQ(groupby_operator.next_cell(), OB_SUCCESS);
EXPECT_EQ(groupby_operator.get_cell(&cell_out, &is_row_changed), OB_SUCCESS);
EXPECT_FALSE(is_row_changed);
EXPECT_EQ(groupby_operator.next_cell(), OB_SUCCESS);
EXPECT_EQ(groupby_operator.get_cell(&cell_out, &is_row_changed), OB_SUCCESS);
EXPECT_TRUE(is_row_changed);
EXPECT_EQ(groupby_operator.next_cell(), OB_SUCCESS);
EXPECT_EQ(groupby_operator.get_cell(&cell_out, &is_row_changed), OB_SUCCESS);
EXPECT_FALSE(is_row_changed);
EXPECT_EQ(groupby_operator.next_cell(), OB_ITER_END);
}
// maybe not find a merge server
int TaskFactory::get_table_tablet(const char * table_name, const uint64_t table_id, uint64_t & count)
{
int ret = OB_SUCCESS;
ObScanParam scan_param;
uint64_t max_len = 0;
if (NULL == table_name)
{
TBSYS_LOG(ERROR, "check table name failed:table[%s], id[%lu]", table_name, table_id);
ret = OB_ERROR;
}
else
{
ret = init_scan_param(table_name, table_id, max_len, scan_param);
if (ret != OB_SUCCESS)
{
TBSYS_LOG(ERROR, "init scan param failed:table[%s], ret[%d]", table_name, ret);
}
}
if (OB_SUCCESS == ret)
{
// for the first table tablet
ObRowkey row_key;
ObObj temp_buffer[common::OB_MAX_ROWKEY_COLUMN_NUMBER];
row_key.assign(temp_buffer, common::OB_MAX_ROWKEY_COLUMN_NUMBER);
ObGetParam param;
ObScanner scanner;
ObServer server;
ObRowkey start_key;
ObRowkey end_key;
ObCellInfo * cell = NULL;
ObScannerIterator iter;
bool row_change = false;
ObString name;
name.assign(const_cast<char*>(table_name), (int32_t)strlen(table_name));
ObCellInfo temp_cell;
temp_cell.table_id_ = table_id;
temp_cell.column_id_ = 0;
common::ModuleArena allocator;
while ((OB_SUCCESS == ret) && (!row_key.is_max_row()))
{
param.reset();
param.set_is_read_consistency(false);
temp_cell.row_key_ = row_key;
ret = param.add_cell(temp_cell);
if (ret != OB_SUCCESS)
{
TBSYS_LOG(ERROR, "add cell failed:ret[%d]", ret);
break;
}
ret = rpc_->get(root_server_, timeout_, param, scanner);
if (ret != OB_SUCCESS)
{
TBSYS_LOG(ERROR, "get root table for tablet failed:table[%lu], ret[%d]", table_id, ret);
break;
}
else
{
// skip the first row
iter = scanner.begin();
++iter;
while ((iter != scanner.end())
&& (OB_SUCCESS == (ret = iter.get_cell(&cell, &row_change))) && !row_change)
{
if (NULL == cell)
{
TBSYS_LOG(ERROR, "%s", "check cell failed");
ret = OB_INNER_STAT_ERROR;
break;
}
ret = cell->row_key_.deep_copy(start_key, allocator);
if (ret != OB_SUCCESS)
{
TBSYS_LOG(WARN, "deep copy the rowkey failed:ret[%d]", ret);
}
++iter;
}
}
// scanner iter end
if (ret == OB_SUCCESS)
{
int64_t ip = 0;
int64_t port = 0;
int64_t version = 0;
TabletLocation list;
for (++iter; iter != scanner.end(); ++iter)
{
ret = iter.get_cell(&cell, &row_change);
if (ret != OB_SUCCESS)
{
TBSYS_LOG(ERROR, "get cell from scanner iterator failed:ret[%d]", ret);
break;
}
else if (row_change) // && (iter != last_iter))
{
TaskInfo task;
task.set_table_id(table_id);
task.set_table_name(table_name);
ret = init_new_task(name, start_key, end_key, scan_param, task);
if (ret != OB_SUCCESS)
{
TBSYS_LOG(ERROR, "init new task failed:ret[%d]", ret);
break;
}
else
{
ret = insert_new_task(list, task);
if (ret != OB_SUCCESS)
{
TBSYS_LOG(ERROR, "insert new task failed:ret[%d]", ret);
break;
}
++count;
}
list.clear();
start_key = end_key;
}
else
{
cell->row_key_.deep_copy(end_key, allocator);
if ((cell->column_name_.compare("1_ms_port") == 0)
|| (cell->column_name_.compare("2_ms_port") == 0)
|| (cell->column_name_.compare("3_ms_port") == 0))
{
ret = cell->value_.get_int(port);
}
else if ((cell->column_name_.compare("1_ipv4") == 0)
|| (cell->column_name_.compare("2_ipv4") == 0)
|| (cell->column_name_.compare("3_ipv4") == 0))
{
ret = cell->value_.get_int(ip);
}
else if ((cell->column_name_.compare("1_tablet_version") == 0)
|| (cell->column_name_.compare("2_tablet_version") == 0)
|| (cell->column_name_.compare("3_tablet_version") == 0))
{
ret = cell->value_.get_int(version);
if (OB_SUCCESS == ret)
{
if (0 == port || port == 0)
{
TBSYS_LOG(WARN, "%s", "check port or ip failed");
}
else
{
server.set_ipv4_addr(int32_t(ip), int32_t(port));
ObTabletLocation addr(version, server);
if (OB_SUCCESS != (ret = list.add(addr)))
{
TBSYS_LOG(ERROR, "add addr failed:server[%d], port[%d], ret[%d]",
server.get_ipv4(), server.get_port(), ret);
}
else
{
TBSYS_LOG(DEBUG, "add addr succ:server[%s], version:%ld", server.to_cstring(), version);
}
}
ip = port = version = 0;
}
}
if (ret != OB_SUCCESS)
{
TBSYS_LOG(ERROR, "check get value failed:ret[%d]", ret);
break;
}
}
}
// for the last row
if ((OB_SUCCESS == ret) && (start_key != end_key))
{
TaskInfo task;
task.set_table_id(table_id);
task.set_table_name(table_name);
ret = init_new_task(name, start_key, end_key, scan_param, task);
if (ret != OB_SUCCESS)
{
TBSYS_LOG(ERROR, "init new task failed:ret[%d]", ret);
}
else
{
ret = insert_new_task(list, task);
if (ret != OB_SUCCESS)
{
TBSYS_LOG(ERROR, "insert new task failed:ret[%d]", ret);
}
++count;
}
if (OB_SUCCESS == ret)
{
// copy all the end key objs to row_key
for (int64_t i = 0; i < end_key.length(); ++i)
{
const_cast<ObObj *> (row_key.ptr())[i] = end_key.ptr()[i];
row_key.assign(const_cast<ObObj *> (row_key.ptr()), end_key.length());
}
// modify last row key for next get root table
if (!end_key.is_max_row())
{
const_cast<ObObj *>(row_key.ptr())[end_key.length()].set_max_value();
row_key.assign(const_cast<ObObj *> (row_key.ptr()), end_key.length() + 1);
}
}
}
list.clear();
}
}
}
return ret;
}
// maybe not find a merge server
int TaskFactory::get_table_tablet(const char * table_name, const uint64_t table_id, uint64_t & count)
{
int ret = OB_SUCCESS;
ObScanParam scan_param;
uint64_t max_len = 0;
if (NULL == table_name)
{
TBSYS_LOG(ERROR, "check table name failed:table[%s], id[%lu]", table_name, table_id);
ret = OB_ERROR;
}
else
{
ret = init_scan_param(table_name, table_id, max_len, scan_param);
if (ret != OB_SUCCESS)
{
TBSYS_LOG(ERROR, "init scan param failed:table[%s], ret[%d]", table_name, ret);
}
}
if (OB_SUCCESS == ret)
{
TaskInfo task;
task.set_table_id(table_id);
task.set_table_name(table_name);
// for the first table tablet
ObString row_key;
char temp_buffer[1];
memset(temp_buffer, 0, sizeof(temp_buffer));
row_key.assign(temp_buffer, sizeof(temp_buffer));
ObGetParam param;
ObScanner scanner;
ObServer server;
ObString start_key;
ObString end_key;
ObCellInfo * cell = NULL;
ObScannerIterator iter;
bool row_change = false;
ObString name;
name.assign(const_cast<char*>(table_name), strlen(table_name));
ObCellInfo temp_cell;
temp_cell.table_id_ = table_id;
temp_cell.column_id_ = 0;
const uint64_t MAX_LEN = 1024;
char last_tablet_rowkey[MAX_LEN] = "";
const int32_t MAX_SERVER_ADDR_SIZE = 128;
char server_addr[MAX_SERVER_ADDR_SIZE];
while ((OB_SUCCESS == ret)
&& (!is_max_rowkey(max_len, row_key.ptr(), row_key.length() - 1)))
{
param.reset();
param.set_is_read_consistency(false);
temp_cell.row_key_ = row_key;
ret = param.add_cell(temp_cell);
if (ret != OB_SUCCESS)
{
TBSYS_LOG(ERROR, "add cell failed:ret[%d]", ret);
break;
}
ret = rpc_->get(root_server_, timeout_, param, scanner);
if (ret != OB_SUCCESS)
{
TBSYS_LOG(ERROR, "get root table for tablet failed:table[%lu], ret[%d]", table_id, ret);
break;
}
else
{
// skip the first row
iter = scanner.begin();
++iter;
while ((iter != scanner.end())
&& (OB_SUCCESS == (ret = iter.get_cell(&cell, &row_change))) && !row_change)
{
if (NULL == cell)
{
TBSYS_LOG(ERROR, "%s", "check cell failed");
ret = OB_INNER_STAT_ERROR;
break;
}
start_key.assign(cell->row_key_.ptr(), cell->row_key_.length());
++iter;
}
}
if (ret == OB_SUCCESS)
{
int64_t ip = 0;
int64_t port = 0;
int64_t version = 0;
TabletLocation list;
for (++iter; iter != scanner.end(); ++iter)
{
ret = iter.get_cell(&cell, &row_change);
if (ret != OB_SUCCESS)
{
TBSYS_LOG(ERROR, "get cell from scanner iterator failed:ret[%d]", ret);
break;
}
else if (row_change) // && (iter != last_iter))
{
ret = init_new_task(name, start_key, end_key, scan_param, task);
if (ret != OB_SUCCESS)
{
TBSYS_LOG(ERROR, "init new task failed:ret[%d]", ret);
break;
}
else
{
ret = insert_new_task(list, task);
if (ret != OB_SUCCESS)
{
TBSYS_LOG(ERROR, "insert new task failed:ret[%d]", ret);
break;
}
++count;
}
list.clear();
start_key = end_key;
end_key.assign(cell->row_key_.ptr(), cell->row_key_.length());
}
else
{
end_key.assign(cell->row_key_.ptr(), cell->row_key_.length());
if ((cell->column_name_.compare("1_ms_port") == 0)
|| (cell->column_name_.compare("2_ms_port") == 0)
|| (cell->column_name_.compare("3_ms_port") == 0))
{
ret = cell->value_.get_int(port);
}
else if ((cell->column_name_.compare("1_ipv4") == 0)
|| (cell->column_name_.compare("2_ipv4") == 0)
|| (cell->column_name_.compare("3_ipv4") == 0))
{
ret = cell->value_.get_int(ip);
}
else if ((cell->column_name_.compare("1_tablet_version") == 0)
|| (cell->column_name_.compare("2_tablet_version") == 0)
|| (cell->column_name_.compare("3_tablet_version") == 0))
{
ret = cell->value_.get_int(version);
if (OB_SUCCESS == ret)
{
if (0 == port || port == 0)
{
TBSYS_LOG(WARN, "%s", "check port or ip failed");
}
else
{
server.set_ipv4_addr(ip, port);
ObTabletLocation addr(version, server);
if (OB_SUCCESS != (ret = list.add(addr)))
{
TBSYS_LOG(ERROR, "add addr failed:server[%d], port[%d], ret[%d]",
server.get_ipv4(), server.get_port(), ret);
}
else
{
server.to_string(server_addr, MAX_SERVER_ADDR_SIZE);
TBSYS_LOG(DEBUG, "add addr succ:server[%s], version:%ld", server_addr, version);
}
}
ip = port = version = 0;
}
}
if (ret != OB_SUCCESS)
{
TBSYS_LOG(ERROR, "check get value failed:ret[%d]", ret);
break;
}
}
}
// for the last row
if ((OB_SUCCESS == ret) && (start_key != end_key))
{
ret = init_new_task(name, start_key, end_key, scan_param, task);
if (ret != OB_SUCCESS)
{
TBSYS_LOG(ERROR, "init new task failed:ret[%d]", ret);
}
else
{
ret = insert_new_task(list, task);
if (ret != OB_SUCCESS)
{
TBSYS_LOG(ERROR, "insert new task failed:ret[%d]", ret);
}
++count;
}
if (OB_SUCCESS == ret)
{
// modify last row key for next get root table
uint64_t len = end_key.length();
if (MAX_LEN > len + 1)
{
memcpy(last_tablet_rowkey, end_key.ptr(), len);
last_tablet_rowkey[len] = 0;
row_key.assign(last_tablet_rowkey, len + 1);
}
else
{
TBSYS_LOG(ERROR, "check end key failed:len[%lu]", len);
}
}
}
list.clear();
}
}
}
return ret;
}
TEST(ObObj,NOP)
{
ObObj src_obj;
ObObj mut_obj;
int64_t val = 0;
int64_t mutation = 5;
///create time
src_obj.set_ext(ObActionFlag::OP_NOP);
mut_obj.set_createtime(mutation);
ASSERT_EQ(src_obj.apply(mut_obj),OB_SUCCESS);
ASSERT_EQ(src_obj.get_createtime(val),OB_SUCCESS);
ASSERT_EQ(val, mutation);
ASSERT_FALSE(src_obj.get_add());
///create time
src_obj.set_ext(ObActionFlag::OP_NOP);
mut_obj.set_modifytime(mutation);
ASSERT_EQ(src_obj.apply(mut_obj),OB_SUCCESS);
ASSERT_EQ(src_obj.get_modifytime(val),OB_SUCCESS);
ASSERT_EQ(val, mutation);
ASSERT_FALSE(src_obj.get_add());
///precise time
src_obj.set_ext(ObActionFlag::OP_NOP);
mut_obj.set_precise_datetime(mutation);
ASSERT_EQ(src_obj.apply(mut_obj),OB_SUCCESS);
ASSERT_EQ(src_obj.get_precise_datetime(val),OB_SUCCESS);
ASSERT_EQ(val, mutation);
ASSERT_FALSE(src_obj.get_add());
src_obj.set_ext(ObActionFlag::OP_NOP);
mut_obj.set_precise_datetime(mutation, true);
ASSERT_EQ(src_obj.apply(mut_obj),OB_SUCCESS);
ASSERT_EQ(src_obj.get_precise_datetime(val),OB_SUCCESS);
ASSERT_EQ(val, mutation);
ASSERT_TRUE(src_obj.get_add());
///date time
src_obj.set_ext(ObActionFlag::OP_NOP);
mut_obj.set_datetime(mutation);
ASSERT_EQ(src_obj.apply(mut_obj),OB_SUCCESS);
ASSERT_EQ(src_obj.get_datetime(val),OB_SUCCESS);
ASSERT_EQ(val, mutation);
ASSERT_FALSE(src_obj.get_add());
src_obj.set_ext(ObActionFlag::OP_NOP);
mut_obj.set_datetime(mutation, true);
ASSERT_EQ(src_obj.apply(mut_obj),OB_SUCCESS);
ASSERT_EQ(src_obj.get_datetime(val),OB_SUCCESS);
ASSERT_EQ(val, mutation);
ASSERT_TRUE(src_obj.get_add());
/// int
src_obj.set_ext(ObActionFlag::OP_NOP);
mut_obj.set_int(mutation);
ASSERT_EQ(src_obj.apply(mut_obj),OB_SUCCESS);
ASSERT_EQ(src_obj.get_int(val),OB_SUCCESS);
ASSERT_EQ(val, mutation);
ASSERT_FALSE(src_obj.get_add());
src_obj.set_ext(ObActionFlag::OP_NOP);
mut_obj.set_int(mutation, true);
ASSERT_EQ(src_obj.apply(mut_obj),OB_SUCCESS);
ASSERT_EQ(src_obj.get_int(val),OB_SUCCESS);
ASSERT_EQ(val, mutation);
ASSERT_TRUE(src_obj.get_add());
/// obstring
const char * cname = "cname";
ObString str;
ObString res;
str.assign((char*)cname, static_cast<int32_t>(strlen(cname)));
src_obj.set_ext(ObActionFlag::OP_NOP);
mut_obj.set_varchar(str);
ASSERT_EQ(src_obj.apply(mut_obj),OB_SUCCESS);
ASSERT_EQ(src_obj.get_varchar(res),OB_SUCCESS);
ASSERT_EQ((uint64_t)res.length(), strlen(cname));
ASSERT_EQ(memcmp(res.ptr(),cname, res.length()), 0);
ASSERT_FALSE(src_obj.get_add());
}
void init_decode_param(ObStringBuf &buf, ObScanParam &org_scan_param)
{
UNUSED(buf);
const char *c_ptr;
ObString str;
ObNewRange q_range;
q_range.set_whole_range();
q_range.border_flag_.set_inclusive_start();
q_range.border_flag_.set_inclusive_end();
c_ptr = "collect_info";
str.assign((char*)c_ptr, static_cast<int32_t>(strlen(c_ptr)));
org_scan_param.reset();
EXPECT_EQ(org_scan_param.set(OB_INVALID_ID, str,q_range), OB_SUCCESS);
/// basic columns
bool is_return = false;
c_ptr = "item_collect_count";
str.assign((char*)c_ptr, static_cast<int32_t>(strlen(c_ptr)));
EXPECT_EQ(org_scan_param.add_column(str,is_return), OB_SUCCESS );
is_return = false;
c_ptr = "item_category";
str.assign((char*)c_ptr, static_cast<int32_t>(strlen(c_ptr)));
EXPECT_EQ(org_scan_param.add_column(str,is_return), OB_SUCCESS );
is_return = true;
c_ptr = "item_price";
str.assign((char*)c_ptr, static_cast<int32_t>(strlen(c_ptr)));
EXPECT_EQ(org_scan_param.add_column(str,is_return), OB_SUCCESS );
/// composite columns
c_ptr = "`item_collect_count`*`item_price`";
str.assign((char*)c_ptr, static_cast<int32_t>(strlen(c_ptr)));
EXPECT_EQ(org_scan_param.add_column(str,str, is_return), OB_SUCCESS );
/// where condition
c_ptr = "`item_price` > 10";
str.assign((char*)c_ptr, static_cast<int32_t>(strlen(c_ptr)));
EXPECT_EQ(org_scan_param.add_where_cond(str), OB_SUCCESS );
/// groupby::group by columns
is_return = false;
c_ptr = "item_category";
str.assign((char*)c_ptr, static_cast<int32_t>(strlen(c_ptr)));
EXPECT_EQ(org_scan_param.get_group_by_param().add_groupby_column(str,is_return), OB_SUCCESS);
/// aggregate columns
is_return = true;
c_ptr = "item_price";
str.assign((char*)c_ptr, static_cast<int32_t>(strlen(c_ptr)));
EXPECT_EQ(org_scan_param.get_group_by_param().add_aggregate_column(str,str, SUM, is_return), OB_SUCCESS);
/// aggregate columns
is_return = false;
c_ptr = "item_collect_count";
str.assign((char*)c_ptr, static_cast<int32_t>(strlen(c_ptr)));
EXPECT_EQ(org_scan_param.get_group_by_param().add_aggregate_column(str,str, SUM, is_return), OB_SUCCESS);
/// composite columns
c_ptr = "`item_collect_count`*`item_price`";
str.assign((char*)c_ptr, static_cast<int32_t>(strlen(c_ptr)));
EXPECT_EQ(org_scan_param.get_group_by_param().add_column(str, str,is_return), OB_SUCCESS );
/// having condtion
c_ptr = "`item_price` > 10";
str.assign((char*)c_ptr, static_cast<int32_t>(strlen(c_ptr)));
EXPECT_EQ(org_scan_param.get_group_by_param().add_having_cond(str), OB_SUCCESS );
/// orderby
c_ptr = "item_price";
str.assign((char*)c_ptr, static_cast<int32_t>(strlen(c_ptr)));
EXPECT_EQ(org_scan_param.add_orderby_column(str),OB_SUCCESS);
}
TEST(ParamModifier, get_param)
{
ObGetParam org_param;
ObReadParam &org_read_param = org_param;
ObScanner cur_result;
ObGetParam cur_param;
ObReadParam &cur_read_param = cur_param;
int64_t got_num = 0;
int64_t cell_num = 1024;
char rowkey_val = 'a';
ObString rowkey;
bool is_cached = false;
rowkey.assign(&rowkey_val,sizeof(rowkey_val));
ObVersionRange version_range;
version_range.border_flag_.set_max_value();
version_range.border_flag_.set_min_value();
org_param.set_version_range(version_range);
org_param.set_is_result_cached(is_cached);
for (int i = 0; i < cell_num; i ++)
{
ObCellInfo cur_cell;
cur_cell.table_id_ = i+5;
cur_cell.column_id_ = i + 6;
cur_cell.row_key_ = rowkey;
EXPECT_EQ(org_param.add_cell(cur_cell), OB_SUCCESS);
}
ObMSGetCellArray org_get_cells(org_param);
EXPECT_EQ(org_param.get_cell_size(), cell_num);
/// first time
while (got_num < cell_num)
{
TBSYS_LOG(WARN,"got_num:%ld", got_num);
cur_param.reset();
EXPECT_EQ(get_next_param(org_read_param,org_get_cells,got_num, &cur_param),OB_SUCCESS);
EXPECT_TRUE(org_read_param==cur_read_param);
EXPECT_EQ(cur_param.get_cell_size() + got_num, org_param.get_cell_size());
for (int64_t cell_idx = got_num; cell_idx < cell_num; cell_idx ++)
{
ASSERT_EQ(cur_param[cell_idx - got_num]->column_id_, org_param[cell_idx]->column_id_);
ASSERT_EQ(cur_param[cell_idx - got_num]->table_id_, org_param[cell_idx]->table_id_);
ASSERT_TRUE(cur_param[cell_idx - got_num]->row_key_ == org_param[cell_idx]->row_key_);
}
int64_t fullfilled_item_num = random()%(cell_num - got_num) + 1;
int64_t memtable_version = random()%1024;
EXPECT_EQ(cur_result.set_is_req_fullfilled(true, fullfilled_item_num), OB_SUCCESS);
cur_result.set_data_version(memtable_version);
int64_t rollback_num = cur_param.get_cell_size() - fullfilled_item_num;
EXPECT_EQ(get_ups_param(cur_param,cur_result),OB_SUCCESS);
EXPECT_EQ(cur_param.get_cell_size() + got_num + rollback_num, org_param.get_cell_size());
EXPECT_EQ(cur_param.get_version_range().start_version_ , memtable_version + 1);
EXPECT_TRUE(cur_param.get_version_range().border_flag_.is_max_value());
EXPECT_TRUE(cur_param.get_version_range().border_flag_.inclusive_start());
for (int64_t cell_idx = got_num; cell_idx < cell_num - rollback_num; cell_idx ++)
{
ASSERT_EQ(cur_param[cell_idx - got_num]->column_id_, org_param[cell_idx]->column_id_);
ASSERT_EQ(cur_param[cell_idx - got_num]->table_id_, org_param[cell_idx]->table_id_);
ASSERT_TRUE(cur_param[cell_idx - got_num]->row_key_ == org_param[cell_idx]->row_key_);
}
got_num += fullfilled_item_num;
}
EXPECT_EQ(get_next_param(org_read_param,org_get_cells,got_num, &cur_param), OB_ITER_END);
}
TEST_F(ObRunFileTest, test_all)
{
static const int64_t BUFFER_SIZE = 1024;
char compact_row_buff_[BUFFER_SIZE];
ObRunFile run_file;
char* fname = (char*)"ob_run_file_test.run";
ObString filename;
ASSERT_EQ(false, run_file.is_opened());
ASSERT_NE(OB_SUCCESS, run_file.open(filename));
filename.assign(fname, strlen(fname));
ASSERT_EQ(OB_SUCCESS, run_file.open(filename));
ASSERT_EQ(true, run_file.is_opened());
const int64_t bucket_count = 4;
const int64_t run_count_per_bucket = 8;
for (int64_t j = 0; j < run_count_per_bucket; ++j)
{
for (int64_t i = 0; i < bucket_count; ++i)
{
ASSERT_EQ(OB_SUCCESS, run_file.begin_append_run(i));
const ObRow *row = NULL;
ObString compact_row;
compact_row.assign_buffer(compact_row_buff_, BUFFER_SIZE);
ASSERT_EQ(OB_SUCCESS, input_data_.open());
while (OB_SUCCESS == input_data_.get_next_row(row))
{
compact_row.assign_buffer(compact_row_buff_, BUFFER_SIZE);
ASSERT_EQ(OB_SUCCESS, ObRowUtil::convert(*row, compact_row));
ASSERT_EQ(OB_SUCCESS, run_file.append_row(compact_row));
} // end for
ASSERT_EQ(OB_SUCCESS, input_data_.close());
ASSERT_EQ(OB_SUCCESS, run_file.end_append_run());
} // end for
}
// read and check
ObRow row;
const ObObj *cell = NULL;
uint64_t table_id;
uint64_t column_id;
ASSERT_EQ(OB_SUCCESS, input_data_.open());
row.set_row_desc(input_data_.get_row_desc());
for (int64_t i = 0; i < bucket_count; ++i)
{
int64_t run_count = 0;
ASSERT_EQ(OB_SUCCESS, run_file.begin_read_bucket(i, run_count));
ASSERT_EQ(run_count, run_count_per_bucket);
for (int64_t j = 0; j < ROW_COUNT; ++j)
{
for (int64_t k = 0; k < run_count; ++k)
{
ASSERT_EQ(OB_SUCCESS, run_file.get_next_row(k, row));
ASSERT_EQ(OB_SUCCESS, row.raw_get_cell(1, cell, table_id, column_id));
int64_t int_value;
ASSERT_EQ(OB_SUCCESS, cell->get_int(int_value));
ASSERT_EQ(j, int_value);
}
} // end for
for (int64_t k = 0; k < run_count; ++k)
{
ASSERT_EQ(OB_ITER_END, run_file.get_next_row(k, row));
}
ASSERT_EQ(OB_SUCCESS, run_file.end_read_bucket());
}
ASSERT_EQ(OB_SUCCESS, run_file.close());
ASSERT_EQ(false, run_file.is_opened());
ASSERT_EQ(OB_SUCCESS, input_data_.close());
}
TEST(ParamModifier, scan_param)
{
ObMemBuffer range_buffer;
ObScanParam org_param;
ObReadParam &org_read_param = org_param;
ObScanParam cur_param;
ObReadParam &cur_read_param = cur_param;
ObScanner cur_result;
int64_t pos = 0;
char tablet_range_buf[1024];
ObString tablet_range_str;
ObRange tablet_range;
bool is_cached = false;
ObVersionRange version_range;
version_range.border_flag_.set_max_value();
version_range.border_flag_.set_min_value();
org_param.set_version_range(version_range);
org_param.set_is_result_cached(is_cached);
char cur_last_key_val = 'c';
string start_key_val("a");
string end_key_val("z");
string tablet_range_end_key_val("z");
string cur_last_key(&cur_last_key_val, &cur_last_key_val + 1);
ObCellInfo last_cell;
ObString rowkey;
ObString start_key;
ObString end_key;
ObString tablet_range_end_key;
start_key.assign((char*)start_key_val.c_str(),static_cast<int32_t>(start_key_val.size()));
end_key.assign((char*)end_key_val.c_str(),static_cast<int32_t>(end_key_val.size()));
tablet_range_end_key.assign((char*)tablet_range_end_key_val.c_str(),
static_cast<int32_t>(tablet_range_end_key_val.size()));
tablet_range.start_key_ = start_key;
tablet_range.end_key_ = end_key;
tablet_range.border_flag_.set_inclusive_start();
tablet_range.border_flag_.set_inclusive_end();
org_param.set(1,start_key,tablet_range);
UNUSED(pos);
UNUSED(tablet_range_buf);
UNUSED(tablet_range_str);
bool is_fullfilled = false;
int64_t memtable_version = 24;
/// first time
EXPECT_EQ(get_next_param(org_param,cur_result,&cur_param, range_buffer),OB_SUCCESS);
EXPECT_TRUE(org_read_param== cur_read_param);
EXPECT_TRUE(*org_param.get_range() == *cur_param.get_range());
/// current tablet not finish
ObScanParam cur_param_1;
ObScanParam &cur_read_param_1 = cur_param_1;
cur_last_key[0]='c';
cur_result.clear();
rowkey.assign(const_cast<char*>(cur_last_key.c_str()),static_cast<int32_t>(cur_last_key.size()));
last_cell.row_key_ = rowkey;
EXPECT_EQ(cur_result.add_cell(last_cell),OB_SUCCESS);
EXPECT_EQ(cur_result.set_is_req_fullfilled(is_fullfilled,1), OB_SUCCESS);
cur_result.set_data_version(memtable_version);
///ups
EXPECT_EQ(get_ups_param(cur_param,cur_result, range_buffer),OB_SUCCESS);
EXPECT_TRUE(cur_param.get_range()->start_key_ == org_param.get_range()->start_key_);
EXPECT_TRUE(cur_param.get_range()->border_flag_.inclusive_start()
== org_param.get_range()->border_flag_.inclusive_start());
EXPECT_TRUE(cur_param.get_range()->end_key_ == rowkey);
EXPECT_TRUE(cur_param.get_range()->border_flag_.inclusive_end());
///cs
EXPECT_EQ(get_next_param(org_param,cur_result,&cur_param_1,range_buffer),OB_SUCCESS);
EXPECT_TRUE(org_read_param== cur_read_param_1);
EXPECT_TRUE(cur_param_1.get_range()->start_key_ == last_cell.row_key_);
EXPECT_TRUE(!cur_param_1.get_range()->border_flag_.inclusive_start());
EXPECT_TRUE(cur_param_1.get_range()->end_key_ == org_param.get_range()->end_key_);
EXPECT_TRUE(cur_param_1.get_range()->border_flag_.inclusive_end()
== org_param.get_range()->border_flag_.inclusive_end());
/// current tablet finish, all not finish
is_fullfilled = true;
ObScanParam cur_param_2;
ObScanParam &cur_read_param_2 = cur_param_2;
cur_last_key[0]='f';
cur_result.clear();
rowkey.assign(const_cast<char*>(cur_last_key.c_str()),static_cast<int32_t>(cur_last_key.size()));
last_cell.row_key_ = rowkey;
EXPECT_EQ(cur_result.add_cell(last_cell),OB_SUCCESS);
EXPECT_EQ(cur_result.set_is_req_fullfilled(is_fullfilled,1), OB_SUCCESS);
cur_result.set_data_version(memtable_version);
tablet_range_end_key_val[0] = 'g';
tablet_range.end_key_ = tablet_range_end_key;
pos = 0;
EXPECT_EQ(tablet_range.serialize(tablet_range_buf,sizeof(tablet_range_buf),pos),OB_SUCCESS);
tablet_range_str.assign(tablet_range_buf,static_cast<int32_t>(pos));
EXPECT_EQ(cur_result.set_range(tablet_range),OB_SUCCESS);
///ups
EXPECT_EQ(get_ups_param(cur_param_1,cur_result,range_buffer),OB_SUCCESS);
EXPECT_TRUE(cur_param_1.get_range()->end_key_ == tablet_range_end_key);
EXPECT_TRUE(cur_param_1.get_range()->border_flag_.inclusive_end());
///cs
EXPECT_EQ(get_next_param(org_param,cur_result,&cur_param_2,range_buffer),OB_SUCCESS);
EXPECT_TRUE(org_read_param== cur_read_param_2);
EXPECT_TRUE(cur_param_2.get_range()->start_key_ == tablet_range_end_key);
EXPECT_TRUE(!cur_param_2.get_range()->border_flag_.inclusive_start());
EXPECT_TRUE(cur_param_2.get_range()->end_key_ == org_param.get_range()->end_key_);
EXPECT_TRUE(cur_param_2.get_range()->border_flag_.inclusive_end()
== org_param.get_range()->border_flag_.inclusive_end());
/// current tablet finish and all finish
is_fullfilled = true;
ObScanParam cur_param_3;
cur_last_key[0]='f';
cur_result.clear();
rowkey.assign(const_cast<char*>(cur_last_key.c_str()),static_cast<int32_t>(cur_last_key.size()));
last_cell.row_key_ = rowkey;
EXPECT_EQ(cur_result.add_cell(last_cell),OB_SUCCESS);
EXPECT_EQ(cur_result.set_is_req_fullfilled(is_fullfilled,1), OB_SUCCESS);
cur_result.set_data_version(memtable_version);
tablet_range_end_key_val[0] = 'z';
tablet_range.end_key_ = tablet_range_end_key;
pos = 0;
EXPECT_EQ(tablet_range.serialize(tablet_range_buf,sizeof(tablet_range_buf),pos),OB_SUCCESS);
tablet_range_str.assign(tablet_range_buf,static_cast<int32_t>(pos));
EXPECT_EQ(cur_result.set_range(tablet_range),OB_SUCCESS);
EXPECT_EQ(get_next_param(org_param,cur_result,&cur_param_3,range_buffer),OB_ITER_END);
/// current tablet finish and all finish
is_fullfilled = true;
ObScanParam cur_param_4;
cur_last_key[0]='f';
cur_result.clear();
rowkey.assign(const_cast<char*>(cur_last_key.c_str()),static_cast<int32_t>(cur_last_key.size()));
last_cell.row_key_ = rowkey;
EXPECT_EQ(cur_result.add_cell(last_cell),OB_SUCCESS);
EXPECT_EQ(cur_result.set_is_req_fullfilled(is_fullfilled,1), OB_SUCCESS);
cur_result.set_data_version(memtable_version);
tablet_range_end_key_val[0] = 'a';
tablet_range.end_key_ = tablet_range_end_key;
tablet_range.border_flag_.set_max_value();
pos = 0;
EXPECT_EQ(tablet_range.serialize(tablet_range_buf,sizeof(tablet_range_buf),pos),OB_SUCCESS);
tablet_range_str.assign(tablet_range_buf,static_cast<int32_t>(pos));
EXPECT_EQ(cur_result.set_range(tablet_range),OB_SUCCESS);
EXPECT_EQ(get_next_param(org_param,cur_result,&cur_param_4,range_buffer),OB_ITER_END);
}
int ObScannerLoader::load_from_config(const char* scanner_section_name)
{
int ret = OB_SUCCESS;
ObString tmpstr ;
ObRowkey tmp_rowkey;
int tmpint ;
char buf[OB_MAX_ROW_KEY_LENGTH];
if (ret == OB_SUCCESS)
{
table_id_ = config_.getInt(scanner_section_name, OBSP_TABLE_ID, 0);
if (table_id_ <= 0)
{
TBSYS_LOG(ERROR, "invalid table id (%d)", table_id_);
ret = OB_INVALID_ARGUMENT;
}
}
if (ret == OB_SUCCESS)
{
if(OB_SUCCESS != (ret = load_string((char*)buf, OB_MAX_ROW_KEY_LENGTH,
scanner_section_name, OBSP_TABLE_NAME, 0)))
{
TBSYS_LOG(ERROR, "invalid/empty table name. err=%d", ret);
ret = OB_INVALID_ARGUMENT;
}
else
{
tmpstr.assign(buf, static_cast<int32_t>(strlen(buf)));
strbuf.write_string(tmpstr, &table_name_);
}
}
if (ret == OB_SUCCESS)
{
if(OB_SUCCESS != (ret = load_string((char*)buf, OB_MAX_ROW_KEY_LENGTH,
scanner_section_name, OBSP_RANGE_START, 0)))
{
TBSYS_LOG(ERROR, "invalid/empty range start. err=%d", ret);
ret = OB_INVALID_ARGUMENT;
}
else
{
// TODO
//tmpstr.assign(buf, static_cast<int32_t>(strlen(buf)));
strbuf.write_string(tmp_rowkey, &range_start_);
}
}
if (ret == OB_SUCCESS)
{
if(OB_SUCCESS != (ret = load_string((char*)buf, OB_MAX_ROW_KEY_LENGTH,
scanner_section_name, OBSP_RANGE_END, 0)))
{
TBSYS_LOG(ERROR, "invalid/empty %s. err=%d", OBSP_RANGE_END, ret);
ret = OB_INVALID_ARGUMENT;
}
else
{
// TODO
//tmpstr.assign(buf, static_cast<int32_t>(strlen(buf)));
strbuf.write_string(tmp_rowkey, &range_end_);
TBSYS_LOG(DEBUG, "************%.*s**************", tmpstr.length(), tmpstr.ptr());
}
}
if (ret == OB_SUCCESS)
{
if(OB_SUCCESS != (ret = load_string((char*)data_file_name_, 4096,
scanner_section_name, OB_DATA_FILE_NAME, 0)))
{
TBSYS_LOG(ERROR, "invalid/empty %s. err=%d", OB_DATA_FILE_NAME, ret);
ret = OB_INVALID_ARGUMENT;
}
}
tmpint = config_.getInt(scanner_section_name, OBSP_RANGE_START_MIN, 0);
if (tmpint != 0 && tmpint != 1)
{
TBSYS_LOG(ERROR, "invalid %s (%d)", OBSP_RANGE_START_MIN, tmpint);
ret = OB_INVALID_ARGUMENT;
}
else
{
range_start_min_ = (tmpint == 1);
}
tmpint = config_.getInt(scanner_section_name, OBSP_RANGE_START_INCLUSIVE, 0);
if (tmpint != 0 && tmpint != 1)
{
TBSYS_LOG(ERROR, "invalid %s (%d)", OBSP_RANGE_START_INCLUSIVE, tmpint);
ret = OB_INVALID_ARGUMENT;
}
else
{
range_start_inclusive_ = (tmpint == 1);
}
tmpint = config_.getInt(scanner_section_name, OBSP_RANGE_END_INCLUSIVE, 0);
if (tmpint != 0 && tmpint != 1)
{
TBSYS_LOG(ERROR, "invalid %s (%d)", OBSP_RANGE_END_INCLUSIVE, tmpint);
ret = OB_INVALID_ARGUMENT;
}
else
{
range_end_inclusive_ = (tmpint == 1);
}
tmpint = config_.getInt(scanner_section_name, OBSP_RANGE_END_MAX, 0);
if (tmpint != 0 && tmpint != 1)
{
TBSYS_LOG(ERROR, "invalid %s (%d)", OBSP_RANGE_END_MAX, tmpint);
ret = OB_INVALID_ARGUMENT;
}
else
{
range_end_max_ = (tmpint == 1);
}
tmpint = config_.getInt(scanner_section_name, OBSP_IS_FULLFILLED, 0);
if (tmpint != 0 && tmpint != 1)
{
TBSYS_LOG(ERROR, "invalid %s (%d)", OBSP_IS_FULLFILLED, tmpint);
ret = OB_INVALID_ARGUMENT;
}
else
{
is_fullfilled_ = (tmpint == 1);
}
tmpint = config_.getInt(scanner_section_name, OBSP_FULLFILLED_ITEM_NUM, 0);
if (tmpint < 0)
{
TBSYS_LOG(ERROR, "invalid %s (%d)", OBSP_FULLFILLED_ITEM_NUM, tmpint);
ret = OB_INVALID_ARGUMENT;
}
else
{
fullfilled_item_num_ = tmpint;
}
tmpint = config_.getInt(scanner_section_name, OBSP_DATA_VERSION, 0);
if (tmpint < 0)
{
TBSYS_LOG(ERROR, "invalid %s (%d)", OBSP_DATA_VERSION, tmpint);
ret = OB_INVALID_ARGUMENT;
}
else
{
data_version_ = tmpint;
}
if (ret != OB_SUCCESS)
{
TBSYS_LOG(INFO, "load config return value not SUCCESS. rewrite to success!");
ret = OB_SUCCESS;
}
return ret;
}
int write_empty_sstable(const ObCellInfo** cell_infos,
const int64_t row_num, const int64_t col_num, const char* sstable_file_path )
{
int err = OB_SUCCESS;
if (sstable_file_path) unlink(sstable_file_path);
ObSSTableSchema sstable_schema;
ObSSTableSchemaColumnDef column_def;
EXPECT_TRUE(NULL != cell_infos);
EXPECT_TRUE(row_num > 0);
EXPECT_TRUE(col_num > 0);
uint64_t table_id = cell_infos[0][0].table_id_;
// add rowkey column
column_def.reserved_ = 0;
column_def.rowkey_seq_ = 1;
column_def.column_group_id_= 0;
column_def.column_name_id_ = 1;
column_def.column_value_type_ = ObVarcharType;
column_def.table_id_ = static_cast<uint32_t>(table_id);
sstable_schema.add_column_def(column_def);
for (int64_t i = 0; i < col_num; ++i)
{
column_def.reserved_ = 0;
column_def.rowkey_seq_ = 0;
column_def.table_id_ = static_cast<uint32_t>(table_id);
column_def.column_group_id_ = 0;
column_def.column_name_id_ = static_cast<uint16_t>(cell_infos[0][i].column_id_);
column_def.column_value_type_ = cell_infos[0][i].value_.get_type();
sstable_schema.add_column_def(column_def);
}
ObString path;
ObString compress_name;
const char* path_str = NULL;
if (NULL != sstable_file_path)
{
path_str = sstable_file_path;
}
else
{
path_str = DEF_SSTABLE_PATH;
}
path.assign((char*) path_str, static_cast<int32_t>(strlen(path_str)));
compress_name.assign((char*)"lzo_1.0", static_cast<int32_t>(strlen("lzo_1.0")));
ObSSTableWriter writer;
err = writer.create_sstable(sstable_schema, path, compress_name, table_id);
EXPECT_EQ(0, err);
int64_t offset = 0;
err = writer.close_sstable(offset);
EXPECT_EQ(0, err);
return err;
}
TEST(ObMergerSubGetRequest, param_iterator)
{
ObGetParam get_param;
PageArena<int64_t, ModulePageAllocator> mem_allocator;
get_param.reset(true);
ObMergerSubGetRequest sub_get_req;
sub_get_req.init(mem_allocator);
ObGetParam *cur_get_param = NULL;
const int64_t cell_count = 2048;
ObCellInfo cell;
for (int64_t i = 0; i < cell_count; i++)
{
cell.table_id_ = i + 1;
cell.column_id_ = i + 1;
cell.row_key_.assign((char*)&i,sizeof(i));
EXPECT_EQ(get_param.add_cell(cell), OB_SUCCESS);
}
sub_get_req.set_param(get_param);
for (int64_t i = 0; i < cell_count; i += 2)
{
EXPECT_EQ(sub_get_req.add_cell(i), OB_SUCCESS);
}
EXPECT_EQ(sub_get_req.get_cur_param(cur_get_param), OB_SUCCESS);
EXPECT_EQ((*cur_get_param).get_cell_size(), cell_count/2);
for (int64_t i = 0; i < cell_count; i += 2)
{
EXPECT_NE((*cur_get_param)[i/2], (void*)0);
EXPECT_EQ((*cur_get_param)[i/2]->column_id_, static_cast<uint64_t>(i + 1));
EXPECT_EQ((*cur_get_param)[i/2]->table_id_, static_cast<uint64_t>(i + 1));
ObString rowkey;
rowkey.assign((char*)&i, sizeof(i));
EXPECT_TRUE((*cur_get_param)[i/2]->row_key_ == rowkey);
}
//// add 1st result
ObScanner res_1st;
const int64_t first_result_count = 256;
for (int64_t i = 0; i < first_result_count; i += 2)
{
cell.table_id_ = i + 1;
cell.column_id_ = i + 1;
cell.row_key_.assign((char*)&i,sizeof(i));
EXPECT_EQ(res_1st.add_cell(cell), OB_SUCCESS);
}
EXPECT_EQ(sub_get_req.add_result(res_1st), OB_SUCCESS);
EXPECT_EQ(sub_get_req.get_cur_param(cur_get_param), OB_SUCCESS);
for (int64_t i = first_result_count; i < cell_count; i += 2)
{
EXPECT_NE((*cur_get_param)[(i - first_result_count) /2], (void*)0);
EXPECT_EQ((*cur_get_param)[(i - first_result_count)/2]->column_id_, static_cast<uint64_t>(i + 1));
EXPECT_EQ((*cur_get_param)[(i - first_result_count)/2]->table_id_, static_cast<uint64_t>(i + 1));
ObString rowkey;
rowkey.assign((char*)&i, sizeof(i));
EXPECT_TRUE((*cur_get_param)[(i - first_result_count)/2]->row_key_ == rowkey);
}
//// add 2nd result
ObScanner res_2nd;
for (int64_t i = first_result_count; i < cell_count; i += 2)
{
cell.table_id_ = i + 1;
cell.column_id_ = i + 1;
cell.row_key_.assign((char*)&i,sizeof(i));
EXPECT_EQ(res_2nd.add_cell(cell), OB_SUCCESS);
}
EXPECT_EQ(sub_get_req.add_result(res_2nd), OB_SUCCESS);
EXPECT_EQ(sub_get_req.get_cur_param(cur_get_param), OB_ITER_END);
/// check result
for (int64_t i = 0; i < cell_count; i+=2)
{
ObInnerCellInfo *cell = NULL;
int64_t org_idx = 0;
EXPECT_EQ(sub_get_req.has_next(), OB_SUCCESS);
EXPECT_EQ(sub_get_req.next(cell, org_idx), OB_SUCCESS);
EXPECT_EQ(org_idx, i);
EXPECT_EQ(cell->column_id_, static_cast<uint64_t>(i + 1));
EXPECT_EQ(cell->table_id_, static_cast<uint64_t>(i + 1));
ObString rowkey;
rowkey.assign((char*)&i, sizeof(i));
EXPECT_TRUE(cell->row_key_ == rowkey);
}
EXPECT_EQ(sub_get_req.has_next(), OB_ITER_END);
}
int ObScanParamLoader::load_from_config(const char *scan_param_section_name)
{
int ret = OB_SUCCESS;
ObString tmpstr ;
int tmpint ;
int i = 0;
char buf[OB_MAX_ROW_KEY_LENGTH];
if (ret == OB_SUCCESS)
{
table_id_ = config_.getInt(scan_param_section_name, OBSP_TABLE_ID, 0);
if (table_id_ <= 0)
{
TBSYS_LOG(ERROR, "invalid table id (%d)", table_id_);
ret = OB_INVALID_ARGUMENT;
}
}
if (ret == OB_SUCCESS)
{
if(OB_SUCCESS != (ret = load_string((char*)buf, OB_MAX_ROW_KEY_LENGTH,
scan_param_section_name, OBSP_TABLE_NAME, 0)))
{
TBSYS_LOG(ERROR, "invalid/empty table name. err=%d", ret);
ret = OB_INVALID_ARGUMENT;
}
else
{
tmpstr.assign(buf, static_cast<int32_t>(strlen(buf)));
strbuf.write_string(tmpstr, &table_name_);
}
}
if (ret == OB_SUCCESS)
{
if(OB_SUCCESS != (ret = load_string((char*)buf, OB_MAX_ROW_KEY_LENGTH,
scan_param_section_name, OBSP_RANGE_START, 0)))
{
TBSYS_LOG(ERROR, "invalid/empty range start. err=%d", ret);
ret = OB_INVALID_ARGUMENT;
}
else
{
tmpstr.assign(buf, static_cast<int32_t>(strlen(buf)));
strbuf.write_string(tmpstr, &range_start_);
}
}
if (ret == OB_SUCCESS)
{
if(OB_SUCCESS != (ret = load_string((char*)buf, OB_MAX_ROW_KEY_LENGTH,
scan_param_section_name, OBSP_RANGE_END, 0)))
{
TBSYS_LOG(ERROR, "invalid/empty %s. err=%d", OBSP_RANGE_END, ret);
ret = OB_INVALID_ARGUMENT;
}
else
{
tmpstr.assign(buf, static_cast<int32_t>(strlen(buf)));
strbuf.write_string(tmpstr
, &range_end_);
}
}
if(OB_SUCCESS == (ret = load_string((char*)buf, OB_MAX_ROW_KEY_LENGTH,
scan_param_section_name, OBSP_WHERE_COND, 0)))
{
tmpstr.assign(buf, static_cast<int32_t>(strlen(buf)));
strbuf.write_string(tmpstr, &where_cond_);
}
if(OB_SUCCESS == (ret = load_string((char*)buf, OB_MAX_ROW_KEY_LENGTH,
scan_param_section_name, OBSP_HAVING_COND, 0)))
{
tmpstr.assign(buf, static_cast<int32_t>(strlen(buf)));
strbuf.write_string(tmpstr, &having_cond_);
}
tmpint = config_.getInt(scan_param_section_name, OBSP_RANGE_START_INCLUSIVE, 0);
if (tmpint != 0 && tmpint != 1)
{
TBSYS_LOG(ERROR, "invalid %s (%d)", OBSP_RANGE_START_INCLUSIVE, tmpint);
ret = OB_INVALID_ARGUMENT;
}
else
{
range_start_inclusive_ = (tmpint == 1);
}
tmpint = config_.getInt(scan_param_section_name, OBSP_RANGE_START_MIN, 0);
if (tmpint != 0 && tmpint != 1)
{
TBSYS_LOG(ERROR, "invalid %s (%d)", OBSP_RANGE_START_MIN, tmpint);
ret = OB_INVALID_ARGUMENT;
}
else
{
range_start_min_ = (tmpint == 1);
}
tmpint = config_.getInt(scan_param_section_name, OBSP_RANGE_END_INCLUSIVE, 0);
if (tmpint != 0 && tmpint != 1)
{
TBSYS_LOG(ERROR, "invalid %s (%d)", OBSP_RANGE_END_INCLUSIVE, tmpint);
ret = OB_INVALID_ARGUMENT;
}
else
{
range_end_inclusive_ = (tmpint == 1);
}
tmpint = config_.getInt(scan_param_section_name, OBSP_RANGE_END_MAX, 0);
if (tmpint != 0 && tmpint != 1)
{
TBSYS_LOG(ERROR, "invalid %s (%d)", OBSP_RANGE_END_MAX, tmpint);
ret = OB_INVALID_ARGUMENT;
}
else
{
range_end_max_ = (tmpint == 1);
}
tmpint = config_.getInt(scan_param_section_name, OBSP_SCAN_DIRECTION, 0);
if (tmpint != 0 && tmpint != 1)
{
TBSYS_LOG(ERROR, "invalid %s (%d)", OBSP_SCAN_DIRECTION, tmpint);
ret = OB_INVALID_ARGUMENT;
}
else
{
scan_direction_ = (tmpint == 1);
}
tmpint = config_.getInt(scan_param_section_name, OBSP_LIMIT_OFFSET, 0);
if (tmpint < 0)
{
TBSYS_LOG(ERROR, "invalid %s (%d)", OBSP_LIMIT_OFFSET, tmpint);
ret = OB_INVALID_ARGUMENT;
}
else
{
limit_offset_ = tmpint;
}
tmpint = config_.getInt(scan_param_section_name, OBSP_LIMIT_COUNT, 0);
if (tmpint < 0)
{
TBSYS_LOG(ERROR, "invalid %s (%d)", OBSP_LIMIT_COUNT, tmpint);
ret = OB_INVALID_ARGUMENT;
}
else
{
limit_count_ = tmpint;
}
char name_buf[1024];
for (i = 0; i < OB_MAX_COLUMN_NUMBER; i++)
{
sprintf(name_buf, "%s%d", OBSP_COLUMN_ID, i);
if(OB_SUCCESS != (ret = load_string((char*)buf, OB_MAX_ROW_KEY_LENGTH,
scan_param_section_name, name_buf, 0)))
{
continue;
}
else
{
tmpstr.assign(buf, static_cast<int32_t>(strlen(buf)));
strbuf.write_string(tmpstr, &column_id_[i]);
column_is_return_[column_id_count_] = 1;
column_id_count_++;
}
sprintf(name_buf, "%s%d", OBSP_COLUMN_IS_RETURN, i);
tmpint = config_.getInt(scan_param_section_name, name_buf, -1);
if (tmpint == 0)
{
column_is_return_[column_id_count_ - 1] = 0;
}
}
for (i = 0; i < OB_MAX_COLUMN_NUMBER; i++)
{
sprintf(name_buf, "%s%d", OBSP_COMPLEX_COLUMN_ID, i);
if(OB_SUCCESS != (ret = load_string((char*)buf, OB_MAX_ROW_KEY_LENGTH,
scan_param_section_name, name_buf, 0)))
{
continue;
}
else
{
tmpstr.assign(buf, static_cast<int32_t>(strlen(buf)));
strbuf.write_string(tmpstr, &complex_column_id_[i]);
complex_column_is_return_[complex_column_id_count_] = 1; // default
complex_column_id_count_++;
}
sprintf(name_buf, "%s%d", OBSP_COMPLEX_COLUMN_IS_RETURN, i);
tmpint = config_.getInt(scan_param_section_name, name_buf, -1);
if (tmpint == 0)
{
complex_column_is_return_[complex_column_id_count_ - 1] = 0;
}
}
for (i = 0; i < OB_MAX_COLUMN_NUMBER; i++)
{
sprintf(name_buf, "%s%d", OBSP_GROUPBY_COLUMN_ID, i);
if(OB_SUCCESS != (ret = load_string((char*)buf, OB_MAX_ROW_KEY_LENGTH,
scan_param_section_name, name_buf, 0)))
{
continue;
}
else
{
tmpstr.assign(buf, static_cast<int32_t>(strlen(buf)));
strbuf.write_string(tmpstr, &groupby_column_id_[i]);
groupby_column_is_return_[groupby_column_id_count_] = 1;
groupby_column_id_count_++;
}
sprintf(name_buf, "%s%d", OBSP_GROUPBY_COLUMN_IS_RETURN, i);
tmpint = config_.getInt(scan_param_section_name, name_buf, -1);
if (tmpint == 0)
{
groupby_column_is_return_[groupby_column_id_count_ - 1] = 0;
}
}
for (i = 0; i < OB_MAX_COLUMN_NUMBER; i++)
{
sprintf(name_buf, "%s%d", OBSP_AGG_COLUMN_ID, i);
if(OB_SUCCESS != (ret = load_string((char*)buf, OB_MAX_ROW_KEY_LENGTH,
scan_param_section_name, name_buf, 0)))
{
continue;
}
else
{
tmpstr.assign(buf, static_cast<int32_t>(strlen(buf)));
strbuf.write_string(tmpstr, &agg_column_id_[i]);
agg_column_is_return_[agg_column_id_count_] = 1;
agg_column_op_[agg_column_id_count_] = 0;
agg_column_id_count_++;
}
sprintf(name_buf, "%s%d", OBSP_AGG_COLUMN_AS_NAME, i);
if(OB_SUCCESS != (ret = load_string((char*)buf, OB_MAX_ROW_KEY_LENGTH,
scan_param_section_name, name_buf, 0)))
{
TBSYS_LOG(WARN, "no as name found for aggregate column %.*s",
agg_column_id_[i].length(), agg_column_id_[i].ptr());
continue;
}
else
{
tmpstr.assign(buf, static_cast<int32_t>(strlen(buf)));
strbuf.write_string(tmpstr, &agg_column_as_name_[i]);
}
sprintf(name_buf, "%s%d", OBSP_AGG_COLUMN_IS_RETURN, i);
tmpint = config_.getInt(scan_param_section_name, name_buf, -1);
if (tmpint == 0)
{
agg_column_is_return_[agg_column_id_count_ - 1] = 0;
}
sprintf(name_buf, "%s%d", OBSP_AGG_COLUMN_OP, i);
tmpint = config_.getInt(scan_param_section_name, name_buf, -1);
if (tmpint > 0)
{
agg_column_op_[agg_column_id_count_ - 1] = tmpint;
}
}
for (i = 0; i < OB_MAX_COLUMN_NUMBER; i++)
{
sprintf(name_buf, "%s%d", OBSP_GROUPBY_COMPLEX_COLUMN_ID, i);
if(OB_SUCCESS != (ret = load_string((char*)buf, OB_MAX_ROW_KEY_LENGTH,
scan_param_section_name, name_buf, 0)))
{
continue;
}
else
{
tmpstr.assign(buf, static_cast<int32_t>(strlen(buf)));
strbuf.write_string(tmpstr, &groupby_complex_column_id_[i]);
groupby_complex_column_is_return_[groupby_complex_column_id_count_] = 1;
groupby_complex_column_id_count_++;
}
sprintf(name_buf, "%s%d", OBSP_GROUPBY_COMPLEX_COLUMN_IS_RETURN, i);
tmpint = config_.getInt(scan_param_section_name, name_buf, -1);
if (tmpint == 0)
{
groupby_complex_column_is_return_[agg_column_id_count_ - 1] = 0;
}
}
for (i = 0; i < OB_MAX_COLUMN_NUMBER; i++)
{
sprintf(name_buf, "%s%d", OBSP_ORDERBY_COLUMN_ID, i);
if(OB_SUCCESS != (ret = load_string((char*)buf, OB_MAX_ROW_KEY_LENGTH,
scan_param_section_name, name_buf, 0)))
{
continue;
}
else
{
tmpstr.assign(buf, static_cast<int32_t>(strlen(buf)));
strbuf.write_string(tmpstr, &orderby_column_id_[i]);
orderby_column_order_[orderby_column_id_count_] = 1;
orderby_column_id_count_++;
}
sprintf(name_buf, "%s%d", OBSP_ORDERBY_COLUMN_ORDER, i);
tmpint = config_.getInt(scan_param_section_name, name_buf, -1);
if (tmpint == 0)
{
orderby_column_order_[orderby_column_id_count_ - 1] = 0;
}
}
if (ret != OB_SUCCESS)
{
TBSYS_LOG(INFO, "load config return value not SUCCESS. rewrite to success!");
ret = OB_SUCCESS;
}
return ret;
}
static int init_sstable(ObSSTableReader& sstable, const ObCellInfo** cell_infos,
const int64_t row_num, const int64_t col_num, const int64_t sst_id = 0L)
{
int err = OB_SUCCESS;
ObSSTableSchema sstable_schema;
ObSSTableSchemaColumnDef column_def;
EXPECT_TRUE(NULL != cell_infos);
EXPECT_TRUE(row_num > 0);
EXPECT_TRUE(col_num > 0);
uint64_t table_id = cell_infos[0][0].table_id_;
ObString path;
int64_t sstable_file_id = 0;
ObString compress_name;
char* path_str = sstable_file_path;
int64_t path_len = OB_MAX_FILE_NAME_LENGTH;
for (int64_t i = 0; i < col_num; ++i)
{
column_def.reserved_ = 0;
if (i >=2)
{
column_def.column_group_id_= 2;
}
else
{
column_def.column_group_id_= 0;
}
column_def.column_name_id_ = cell_infos[0][i].column_id_;
column_def.column_value_type_ = cell_infos[0][i].value_.get_type();
column_def.table_id_ = table_id;
sstable_schema.add_column_def(column_def);
}
if (0 == sst_id)
{
sstable_file_id = 100;
}
else
{
sstable_file_id = sst_id;
}
ObSSTableId sstable_id(sst_id);
get_sstable_path(sstable_id, path_str, path_len);
char cmd[256];
sprintf(cmd, "mkdir -p %s", path_str);
system(cmd);
path.assign((char*)path_str, strlen(path_str));
compress_name.assign("lzo_1.0", strlen("lzo_1.0"));
remove(path.ptr());
ObSSTableWriter writer;
err = writer.create_sstable(sstable_schema, path, compress_name, 0);
EXPECT_EQ(OB_SUCCESS, err);
for (int64_t i = 0; i < row_num; ++i)
{
ObSSTableRow row;
row.set_table_id(table_id);
row.set_column_group_id(0);
err = row.set_row_key(cell_infos[i][0].row_key_);
EXPECT_EQ(OB_SUCCESS, err);
for (int64_t j = 0; j < 2; ++j)
{
err = row.add_obj(cell_infos[i][j].value_);
EXPECT_EQ(OB_SUCCESS, err);
}
int64_t space_usage = 0;
err = writer.append_row(row, space_usage);
EXPECT_EQ(OB_SUCCESS, err);
}
for (int64_t i = 0; i < row_num; ++i)
{
ObSSTableRow row;
row.set_table_id(table_id);
row.set_column_group_id(2);
err = row.set_row_key(cell_infos[i][0].row_key_);
EXPECT_EQ(OB_SUCCESS, err);
for (int64_t j = 2; j < col_num; ++j)
{
err = row.add_obj(cell_infos[i][j].value_);
EXPECT_EQ(OB_SUCCESS, err);
}
int64_t space_usage = 0;
err = writer.append_row(row, space_usage);
EXPECT_EQ(OB_SUCCESS, err);
}
int64_t offset = 0;
err = writer.close_sstable(offset);
EXPECT_EQ(OB_SUCCESS, err);
err = fic.init(1024);
EXPECT_EQ(OB_SUCCESS, err);
err = reader_.open(sstable_id);
EXPECT_EQ(OB_SUCCESS, err);
EXPECT_TRUE(reader_.is_opened());
return err;
}
void test_write_patch_file_with_check()
{
ObSSTableWriter writer;
ObSSTableSchema schema;
ObSSTableRow row;
ObString file_name;
ObString compressor;
int ret;
ObSSTableSchemaColumnDef column_def;
int64_t trailer_offset = 0;
int64_t space_usage = 0;
int64_t sstable_size = 0;
uint64_t table_id = 0;
uint64_t column_group_id = 0;
ObObj key_obj;
ObObj obj;
ObString row_key;
ObRowkey key;
char value_data[1024 + 1];
char rowkey_str[32];
char *ptr;
file_name.assign(sstable_path, static_cast<int32_t>(strlen(sstable_path)));
char *compressor_name = (char*)COMPRESSOR_NAME;
compressor.assign(compressor_name, static_cast<int32_t>(strlen(compressor_name) + 1));
// init schema
for (int64_t i = 0; i < 5; ++i)
{
column_def.table_id_ = static_cast<uint32_t>(1025 + i);
// add rowkey column
column_def.column_group_id_ = 0;
column_def.column_name_id_ = 1;
column_def.column_value_type_ = ObVarcharType;
column_def.rowkey_seq_ = 1;
schema.add_column_def(column_def);
for ( int j = 0; j < 10 ; ++j)
{
column_def.column_group_id_ = static_cast<uint16_t>(j);
column_def.column_name_id_ = 2;
column_def.column_value_type_ = ObDoubleType;
column_def.rowkey_seq_ = 0;
schema.add_column_def(column_def);
column_def.column_name_id_ = 3;
column_def.column_value_type_ = ObIntType;
column_def.rowkey_seq_ = 0;
schema.add_column_def(column_def);
column_def.column_name_id_ = 4;
column_def.column_value_type_ = ObVarcharType;
column_def.rowkey_seq_ = 0;
schema.add_column_def(column_def);
}
}
//build data
ptr = value_data;
for (int64_t i = 0; i < 128; ++i) {
memcpy(ptr, "testing ", 8);
ptr += 8;
}
ObString value_str(1025, 1025, value_data);
writer.set_dio(true);
int64_t start_time = tbsys::CTimeUtil::getTime();
ret = writer.create_sstable(schema, file_name, compressor, 2,
OB_SSTABLE_STORE_SPARSE);
for (int64_t i = 0; i < 5000000; ++i) {
row.clear();
table_id = i / 1000000 + 1025;
column_group_id = i % 1000000 / 100000;
row.set_table_id(table_id);
row.set_column_group_id(column_group_id);
sprintf(rowkey_str, "row_key_%08ld", i);
row_key.assign(rowkey_str, 16);
key_obj.set_varchar(row_key);
key.assign(&key_obj, 1);
row.set_rowkey(key);
obj.set_double((double)i);
row.add_obj(obj);
obj.set_int(i);
row.add_obj(obj);
obj.set_varchar(value_str);
row.add_obj(obj);
if (OB_ERROR == (ret = writer.append_row(row, space_usage)))
{
TBSYS_LOG(ERROR, "add row failed");
return;
}
}
if (OB_ERROR == (ret = writer.close_sstable(trailer_offset, sstable_size)))
{
TBSYS_LOG(ERROR, "close sstable failed ------------------");
}
printf("test_write_patch_file_with_check(), run_time=%ld\n",
tbsys::CTimeUtil::getTime() - start_time);
//remove(sstable_path);
}
