TEST_F(TestMutatorParamDecoder, test_decode)
{
ObSchemaManagerV2 schema(100);
tbsys::CConfig config;
EXPECT_TRUE(schema.parse_from_file("schema.ini", config));
ObCellInfo cell;
ObCellInfo out_cell;
char * no_name = (char*)"test_not_exist";
char * tablename = (char*)"collect_info";
char * columnname = (char*)"item_price";
char * rowkey = (char*)"row_key";
ObString table_name;
ObString column_name;
ObString row_key;
table_name.assign(tablename, static_cast<int32_t>(strlen(tablename)));
column_name.assign(columnname, static_cast<int32_t>(strlen(columnname)));
row_key.assign(rowkey, static_cast<int32_t>(strlen(rowkey)));
ObMutator mutator;
int64_t count = 20;
mutator.del_row(table_name, row_key);
for (int64_t i = 0; i < count; ++i)
{
mutator.add(table_name, row_key, column_name, (int64_t)1, ObMutator::RETURN_NO_RESULT);
mutator.add(table_name, row_key, column_name, i + 10, ObMutator::RETURN_UPDATE_RESULT);
}
mutator.del_row(table_name, row_key);
ObUpdateCondition & cond = mutator.get_update_condition();
ObObj obj;
obj.set_int(1234);
EXPECT_TRUE(OB_SUCCESS == cond.add_cond(table_name, row_key, column_name, LT, obj));
EXPECT_TRUE(OB_SUCCESS == cond.add_cond(table_name, row_key, false));
obj.set_int(1230);
EXPECT_TRUE(OB_SUCCESS == cond.add_cond(table_name, row_key, column_name, GT, obj));
EXPECT_TRUE(OB_SUCCESS == cond.add_cond(table_name, row_key, false));
// succ
ObMutator decode_mutator;
ObGetParam org_param;
ObGetParam decode_param;
EXPECT_TRUE(OB_SUCCESS == ObMutatorParamDecoder::decode(mutator, schema, decode_mutator, org_param, decode_param));
// decode mutator
EXPECT_TRUE(decode_mutator.get_update_condition().get_count() == cond.get_count());
// need return
EXPECT_TRUE(org_param.get_cell_size() == count);
// need prefetch
EXPECT_TRUE(decode_param.get_cell_size() == (count + cond.get_count()));
// failed
table_name.assign(no_name, static_cast<int32_t>(strlen(no_name)));
for (int64_t i = 0; i < count; ++i)
{
mutator.add(table_name, row_key, column_name, (int64_t)1, ObMutator::RETURN_NO_RESULT);
mutator.add(table_name, row_key, column_name, i + 10, ObMutator::RETURN_UPDATE_RESULT);
}
org_param.reset();
decode_param.reset();
decode_mutator.reset();
EXPECT_TRUE(OB_SUCCESS != ObMutatorParamDecoder::decode(mutator, schema, decode_mutator, org_param, decode_param));
}
TEST_F(ObRowUtilTest, basic_test1)
{
char buf[1024];
ObCompactCellWriter cell_writer;
OK(cell_writer.init(buf, 1024, SPARSE));
ObObj value;
ObRowDesc row_desc;
for(int64_t i=0;i<10;i++)
{
row_desc.add_column_desc(TABLE_ID, i);
value.set_int(i);
OK(cell_writer.append(i, value));
}
OK(cell_writer.row_finish());
ObString compact_row;
compact_row.assign_ptr(cell_writer.get_buf(), (int32_t)cell_writer.size());
ObRow row;
row.set_row_desc(row_desc);
OK(ObRowUtil::convert(compact_row, row));
const ObObj *cell = NULL;
uint64_t column_id = OB_INVALID_ID;
uint64_t table_id = OB_INVALID_ID;
int64_t int_value = 0;
for(int64_t i=0;i<10;i++)
{
OK(row.raw_get_cell(i, cell, table_id, column_id));
cell->get_int(int_value);
ASSERT_EQ(i, int_value);
}
}
/* 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(TestObInsertDBSemFilter, child_not_empty)
{
ObInsertDBSemFilter dbi;
ObRowDesc row_desc;
row_desc.add_column_desc(1001, 16);
row_desc.add_column_desc(1001, 17);
row_desc.add_column_desc(1001, 101);
row_desc.add_column_desc(1001, 102);
ObRowDescExt row_desc_ext;
ObObj type;
type.set_int(0);
row_desc_ext.add_column_desc(1001, 16, type);
row_desc_ext.add_column_desc(1001, 17, type);
row_desc_ext.add_column_desc(1001, 101, type);
row_desc_ext.add_column_desc(1001, 102, type);
ObValues cc;
dbi.get_values().set_row_desc(row_desc, row_desc_ext);
cc.set_row_desc(row_desc);
build_values(10, row_desc, dbi.get_values(), cc);
dbi.set_child(0, cc);
int ret = dbi.open();
EXPECT_EQ(OB_ERR_PRIMARY_KEY_DUPLICATE, ret);
const ObRow *row = NULL;
ret = dbi.get_next_row(row);
EXPECT_EQ(OB_ITER_END, ret);
ret = dbi.close();
EXPECT_EQ(OB_SUCCESS, 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;
}
TEST(ObObj,int_boundary)
{
int64_t need_len = 0;
int64_t data[] = {1,28,-1,INT32_MIN,static_cast<int64_t>(UINT32_MAX),INT64_MAX,INT64_MIN,UINT64_MAX,124543900};
for(uint32_t i=0;i<sizeof(data)/sizeof(data[0]);++i)
{
need_len += serialization::encoded_length_int(data[i]);
}
char *buf = (char *)malloc(need_len);
ObObj t;
int64_t pos = 0;
for(uint32_t i=0;i<sizeof(data)/sizeof(data[0]);++i)
{
t.reset();
t.set_int(data[i]);
ASSERT_EQ(t.serialize(buf,need_len,pos),OB_SUCCESS);
}
pos = 0;
int64_t v = 0;
for(uint32_t i=0;i<sizeof(data)/sizeof(data[0]);++i)
{
t.reset();
ASSERT_EQ(t.deserialize(buf,need_len,pos),OB_SUCCESS);
ASSERT_EQ(t.get_int(v),OB_SUCCESS);
ASSERT_EQ(v,data[i]);
}
free(buf);
}
void build_values(const int64_t row_count, ObRowDesc &row_desc, ObExprValues &values1, ObValues &values2)
{
for (int64_t i = 0; i < row_count; i++)
{
ObRow row;
row.set_row_desc(row_desc);
for (int64_t j = 0; j < row_desc.get_column_num(); j++)
{
uint64_t table_id = OB_INVALID_ID;
uint64_t column_id = OB_INVALID_ID;
row_desc.get_tid_cid(j, table_id, column_id);
ObObj obj;
obj.set_int(i + j);
row.set_cell(table_id, column_id, obj);
ObSqlExpression se;
se.set_tid_cid(table_id, column_id);
ExprItem ei;
ei.type_ = T_INT;
ei.value_.int_ = i + j;
se.add_expr_item(ei);
//ei.type_ = T_REF_COLUMN;
//ei.value_.cell_.tid = table_id;
//ei.value_.cell_.cid = column_id;
//se.add_expr_item(ei);
se.add_expr_item_end();
values1.add_value(se);
}
//values1.add_values(row);
values2.add_values(row);
}
}
TEST(ObObj,Serialize_int_add)
{
ObObj t;
t.set_int(9900);
int64_t len = t.get_serialize_size();
ASSERT_EQ(len,3);
char *buf = (char *)malloc(len);
int64_t pos = 0;
ASSERT_EQ(t.serialize(buf,len,pos),OB_SUCCESS);
ASSERT_EQ(pos,len);
ObObj f;
pos = 0;
ASSERT_EQ(f.deserialize(buf,len,pos),OB_SUCCESS);
ASSERT_EQ(pos,len);
int64_t r = 0;
int64_t l = 0;
ASSERT_EQ(f.get_type(),t.get_type());
f.get_int(r);
t.get_int(l);
ASSERT_EQ(r,l);
free(buf);
}
TEST_F(TestParamDecoder, test_decode_cond_cell)
{
ObSchemaManagerV2 schema(100);
tbsys::CConfig config;
EXPECT_TRUE(schema.parse_from_file("schema.ini", config));
ObCondInfo cond;
ObCellInfo out_cell;
char * no_name = (char*)"test_not_exist";
char * tablename = (char*)"collect_info";
char * columnname = (char*)"item_price";
char * rowkey = (char*)"rowkey_test";
ObString table_name;
ObString column_name;
ObRowkey row_key;
// NORMAL TYPE
// table name not exist and column not exist
table_name.assign(no_name, static_cast<int32_t>(strlen(no_name)));
column_name.assign(no_name, static_cast<int32_t>(strlen(no_name)));
row_key = make_rowkey(rowkey, &allocator_);
ObObj obj;
obj.set_int(1234);
cond.set(NE, table_name, row_key, column_name, obj);
EXPECT_TRUE(OB_SUCCESS != ObParamDecoder::decode_cond_cell(cond, schema, out_cell));
// table name not exist but column exist
table_name.assign(no_name, static_cast<int32_t>(strlen(no_name)));
column_name.assign(columnname, static_cast<int32_t>(strlen(columnname)));
cond.set(NE, table_name, row_key, column_name, obj);
EXPECT_TRUE(OB_SUCCESS != ObParamDecoder::decode_cond_cell(cond, schema, out_cell));
// table name exist but column not exist
table_name.assign(tablename, static_cast<int32_t>(strlen(tablename)));
column_name.assign(no_name, static_cast<int32_t>(strlen(no_name)));
cond.set(NE, table_name, row_key, column_name, obj);
EXPECT_TRUE(OB_SUCCESS != ObParamDecoder::decode_cond_cell(cond, schema, out_cell));
// table name exist and column exist
table_name.assign(tablename, static_cast<int32_t>(strlen(tablename)));
column_name.assign(columnname, static_cast<int32_t>(strlen(columnname)));
cond.set(NE, table_name, row_key, column_name, obj);
EXPECT_TRUE(OB_SUCCESS == ObParamDecoder::decode_cond_cell(cond, schema, out_cell));
// EXIST TYPE
// table name not exist
table_name.assign(no_name, static_cast<int32_t>(strlen(no_name)));
row_key = make_rowkey(rowkey, &allocator_);
cond.set(table_name, row_key, false);
EXPECT_TRUE(OB_SUCCESS != ObParamDecoder::decode_cond_cell(cond, schema, out_cell));
cond.set(table_name, row_key, true);
EXPECT_TRUE(OB_SUCCESS != ObParamDecoder::decode_cond_cell(cond, schema, out_cell));
// table name exist
table_name.assign(tablename, static_cast<int32_t>(strlen(tablename)));
cond.set(table_name, row_key, true);
EXPECT_TRUE(OB_SUCCESS == ObParamDecoder::decode_cond_cell(cond, schema, out_cell));
cond.set(table_name, row_key, false);
EXPECT_TRUE(OB_SUCCESS == ObParamDecoder::decode_cond_cell(cond, schema, out_cell));
}
int set_int_obj_value(char * buf, const int64_t buf_len, int64_t & pos, const int64_t value)
{
int ret = OB_SUCCESS;
ObObj obj;
obj.set_int(value);
ret = obj.serialize(buf, buf_len, pos);
return ret;
}
ScanConds::ScanConds(const char* column_name, const ObLogicOperator& cond_op, int64_t value)
{
ObString name;
name.assign_ptr(const_cast<char*>(column_name), static_cast<int32_t>(strlen(column_name)));
ObObj obj;
obj.set_int(value);
EasyArray<ObSimpleCond>(ObSimpleCond(name, cond_op, obj));
}
int64_t ObReadParam::get_reserve_param_serialize_size(void) const
{
ObObj obj;
// reserve for read master
obj.set_ext(ObActionFlag::RESERVE_PARAM_FIELD);
int64_t total_size = obj.get_serialize_size();
obj.set_int(get_is_read_consistency());
total_size += obj.get_serialize_size();
return total_size;
}
int ObSqlGetParam::serialize_int(char* buf, const int64_t buf_len, int64_t& pos,
const int64_t value) const
{
int ret = OB_SUCCESS;
ObObj obj;
obj.set_int(value);
ret = obj.serialize(buf, buf_len, pos);
return ret;
}
int ObReadParam::serialize_reserve_param(char * buf, const int64_t buf_len, int64_t & pos) const
{
ObObj obj;
// serialize RESERVER PARAM FIELD
obj.set_ext(ObActionFlag::RESERVE_PARAM_FIELD);
int ret = obj.serialize(buf, buf_len, pos);
if (ret == OB_SUCCESS)
{
obj.set_int(get_is_read_consistency());
ret = obj.serialize(buf, buf_len, pos);
}
return ret;
}
int64_t ObSqlScanParam::get_basic_param_serialize_size(void) const
{
int64_t total_size = 0;
ObObj obj;
// BASIC_PARAM_FIELD
obj.set_ext(ObActionFlag::BASIC_PARAM_FIELD);
total_size += obj.get_serialize_size();
// scan range
obj.set_int(range_.table_id_);
total_size += obj.get_serialize_size();
obj.set_int(range_.border_flag_.get_data());
total_size += obj.get_serialize_size();
// start_key_
total_size += get_rowkey_obj_array_size(
range_.start_key_.get_obj_ptr(), range_.start_key_.get_obj_cnt());
// end_key_
total_size += get_rowkey_obj_array_size(
range_.end_key_.get_obj_ptr(), range_.end_key_.get_obj_cnt());
obj.set_int(scan_flag_.flag_);
total_size += obj.get_serialize_size();
return total_size;
}
TEST(ObObj, test_bug)
{
ObObj obj;
obj.set_int(100, false);
char buf[2048];
int64_t len = 2048;
int64_t pos = 0;
ASSERT_EQ(obj.serialize(buf, len, pos), OB_SUCCESS);
pos = 0;
ObObj temp;
temp.set_int(200, true);
temp.reset();
ASSERT_EQ(temp.deserialize(buf, len, pos), OB_SUCCESS);
ASSERT_EQ(temp == obj, true);
ObObj test;
test.set_int(300, true);
test = temp;
ASSERT_EQ(test == temp, true);
}
int64_t get_rowkey_obj_array_size(const ObObj* array, const int64_t size)
{
int64_t total_size = 0;
ObObj obj;
obj.set_int(size);
total_size += obj.get_serialize_size();
for (int64_t i = 0; i < size; ++i)
{
total_size += array[i].get_serialize_size();
}
return total_size;
}
TEST_F(ObRowFuseTest, assign)
{
uint64_t TABLE_ID = 1000;
ObRowDesc row_desc;
for(int i=0;i<8;i++)
{
row_desc.add_column_desc(TABLE_ID, OB_APP_MIN_COLUMN_ID + i);
}
ObRow row;
row.set_row_desc(row_desc);
ObObj value;
for(int i=0;i<8;i++)
{
value.set_int(i);
OK(row.raw_set_cell(i, value));
}
ObRowDesc ups_row_desc;
for(int i=0;i<4;i++)
{
ups_row_desc.add_column_desc(TABLE_ID, OB_APP_MIN_COLUMN_ID + i);
}
ObUpsRow ups_row;
ups_row.set_row_desc(ups_row_desc);
for(int i=0;i<4;i++)
{
value.set_ext(ObActionFlag::OP_NOP);
OK(ups_row.raw_set_cell(i, value));
}
ups_row.set_delete_row(true);
OK(ObRowFuse::assign(ups_row, row));
const ObObj *cell = NULL;
uint64_t table_id = OB_INVALID_ID;
uint64_t column_id = OB_INVALID_ID;
for(int i=0;i<4;i++)
{
OK(row.raw_get_cell(i, cell, table_id, column_id));
ASSERT_EQ(ObNullType, cell->get_type());
}
ASSERT_TRUE(OB_SUCCESS != row.raw_get_cell(4, cell, table_id, column_id));
}
int64_t ObSqlReadParam::get_basic_param_serialize_size(void) const
{
int64_t total_size = 0;
ObObj obj;
// consistency
obj.set_int(get_is_read_consistency());
total_size += obj.get_serialize_size();
// result cached
obj.set_int(get_is_result_cached());
total_size += obj.get_serialize_size();
// data version
obj.set_int(get_data_version());
total_size += obj.get_serialize_size();
// table id
obj.set_int(table_id_);
total_size += obj.get_serialize_size();
// renamed table id
obj.set_int(renamed_table_id_);
total_size += obj.get_serialize_size();
// only_static_data
obj.set_bool(only_static_data_);
total_size += obj.get_serialize_size();
return total_size;
}
int64_t ObSqlGetParam::get_obj_serialize_size(const int64_t value, bool is_ext) const
{
ObObj obj;
if (is_ext)
{
obj.set_ext(value);
}
else
{
obj.set_int(value);
}
return obj.get_serialize_size();
}
TEST_F(ObRowUtilTest, basic_test)
{
char buf[1024];
ObCompactCellWriter cell_writer;
OK(cell_writer.init(buf, 1024, DENSE_SPARSE));
ObRowkey rowkey;
ObObj rowkey_obj[OB_MAX_ROWKEY_COLUMN_NUMBER];
rowkey_obj[0].set_int(3);
rowkey_obj[1].set_int(30);
rowkey.assign(rowkey_obj, 2);
OK(cell_writer.append_rowkey(rowkey));
ObObj value;
ObRowDesc row_desc;
for(int64_t i=0;i<10;i++)
{
row_desc.add_column_desc(TABLE_ID, i);
value.set_int(i);
OK(cell_writer.append(i, value));
}
OK(cell_writer.row_finish());
ObString compact_row;
compact_row.assign_ptr(cell_writer.get_buf(), (int32_t)cell_writer.size());
ObRow row;
ObRowkey rk;
ObObj rk_obj[OB_MAX_ROWKEY_COLUMN_NUMBER];
row.set_row_desc(row_desc);
OK(ObRowUtil::convert(compact_row, row, &rk, rk_obj));
ASSERT_TRUE( rowkey == rk );
const ObObj *cell = NULL;
uint64_t column_id = OB_INVALID_ID;
uint64_t table_id = OB_INVALID_ID;
int64_t int_value = 0;
for(int64_t i=0;i<10;i++)
{
OK(row.raw_get_cell(i, cell, table_id, column_id));
cell->get_int(int_value);
ASSERT_EQ(i, int_value);
}
}
TEST_F(ObRowUtilTest, basic_test)
{
char buf[1024];
ObCompactCellWriter cell_writer;
OK(cell_writer.init(buf, 1024, DENSE_SPARSE));
const char *rowkey = "rowkey_00001";
ObString rowkey_str;
rowkey_str.assign_ptr(const_cast<char *>(rowkey), (int32_t)(strlen(rowkey)));
ObObj rowkey_obj;
rowkey_obj.set_varchar(rowkey_str);
OK(cell_writer.append(rowkey_obj));
OK(cell_writer.rowkey_finish());
ObObj value;
ObRowDesc row_desc;
for(int64_t i=0;i<10;i++)
{
row_desc.add_column_desc(TABLE_ID, i);
value.set_int(i);
OK(cell_writer.append(i, value));
}
OK(cell_writer.row_finish());
ObString compact_row;
compact_row.assign_ptr(cell_writer.get_buf(), (int32_t)cell_writer.size());
ObRow row;
ObString rk;
row.set_row_desc(row_desc);
OK(ObRowUtil::convert(compact_row, row, &rk));
ASSERT_EQ(0, strncmp(rowkey, rk.ptr(), rk.length()));
const ObObj *cell = NULL;
uint64_t column_id = OB_INVALID_ID;
uint64_t table_id = OB_INVALID_ID;
int64_t int_value = 0;
for(int64_t i=0;i<10;i++)
{
OK(row.raw_get_cell(i, cell, table_id, column_id));
cell->get_int(int_value);
ASSERT_EQ(i, int_value);
}
}
TEST(TestObInsertDBSemFilter, iter_succ)
{
ObInsertDBSemFilter dbi;
ObRowDesc row_desc;
row_desc.add_column_desc(1001, 16);
row_desc.add_column_desc(1001, 17);
row_desc.add_column_desc(1001, 101);
row_desc.add_column_desc(1001, 102);
ObRowDescExt row_desc_ext;
ObObj type;
type.set_int(0);
row_desc_ext.add_column_desc(1001, 16, type);
row_desc_ext.add_column_desc(1001, 17, type);
row_desc_ext.add_column_desc(1001, 101, type);
row_desc_ext.add_column_desc(1001, 102, type);
ObValues cc;
dbi.get_values().set_row_desc(row_desc, row_desc_ext);
cc.set_row_desc(row_desc);
build_values(10, row_desc, dbi.get_values(), cc);
ObValues empty_values;
dbi.set_child(0, empty_values);
int ret = dbi.open();
EXPECT_EQ(OB_SUCCESS, ret);
cc.open();
const ObRow *row1 = NULL;
const ObRow *row2 = NULL;
while (OB_SUCCESS == cc.get_next_row(row1))
{
ret = dbi.get_next_row(row2);
EXPECT_EQ(OB_SUCCESS, ret);
EXPECT_EQ(true, equal(*row1, *row2));
}
ret = cc.get_next_row(row1);
EXPECT_EQ(OB_ITER_END, ret);
ret = dbi.get_next_row(row2);
EXPECT_EQ(OB_ITER_END, ret);
ret = dbi.close();
EXPECT_EQ(OB_SUCCESS, ret);
}
TEST_F(TestSimpleFilter, test_index)
{
ObLogicOperator operate = LIKE;
char * ptr = "test_test";
ObString sub_string;
sub_string.assign(ptr, strlen(ptr));
ObObj operand;
operand.set_varchar(sub_string);
ObSimpleFilter filter;
ObSimpleCond cond1;
EXPECT_TRUE(cond1.set(2, operate, operand) == OB_SUCCESS);
EXPECT_TRUE(filter.add_cond(2, operate, operand) == OB_SUCCESS);
operate = GE;
operand.set_int(23);
ObSimpleCond cond2;
EXPECT_TRUE(cond2.set(1, operate, operand) == OB_SUCCESS);
EXPECT_TRUE(filter.add_cond(1, operate, operand) == OB_SUCCESS);
operate = NE;
operand.set_varchar(sub_string);
ObSimpleCond cond3;
EXPECT_TRUE(cond3.set(3, operate, operand) == OB_SUCCESS);
EXPECT_TRUE(filter.add_cond(3, operate, operand) == OB_SUCCESS);
const ObSimpleCond * cond = NULL;
cond = filter[-1];
EXPECT_TRUE(cond == NULL);
cond = filter[3];
EXPECT_TRUE(cond == NULL);
cond = filter[0];
EXPECT_TRUE(*cond == cond1);
cond = filter[1];
EXPECT_TRUE(cond != NULL);
EXPECT_TRUE(*cond == cond2);
cond = filter[2];
EXPECT_TRUE(cond != NULL);
EXPECT_TRUE(*cond == cond3);
}
void build_values(const int64_t row_count, ObRowDesc &row_desc, ObValues &values1, ObValues &values2)
{
values1.set_row_desc(row_desc);
values2.set_row_desc(row_desc);
for (int64_t i = 0; i < row_count; i++)
{
ObRow row;
row.set_row_desc(row_desc);
for (int64_t j = 0; j < row_desc.get_column_num(); j++)
{
uint64_t table_id = OB_INVALID_ID;
uint64_t column_id = OB_INVALID_ID;
row_desc.get_tid_cid(j, table_id, column_id);
ObObj obj;
obj.set_int(i + j);
row.set_cell(table_id, column_id, obj);
}
values1.add_values(row);
values2.add_values(row);
}
}
TEST(ObObj, performance)
{
// int64_t start_time = tbsys::CTimeUtil::getTime();
//const int64_t MAX_COUNT = 10 * 1000 * 1000L;
const int64_t MAX_COUNT = 1000L;
ObObj obj;
char buf[2048];
int64_t len = 2048;
int64_t pos = 0;
int64_t data = 0;
for (int64_t i = 0; i < MAX_COUNT; ++i)
{
obj.set_int(i);
pos = 0;
ASSERT_EQ(obj.serialize(buf, len, pos), OB_SUCCESS);
pos = 0;
ASSERT_EQ(obj.deserialize(buf, len, pos), OB_SUCCESS);
ASSERT_EQ(obj.get_int(data), OB_SUCCESS);
ASSERT_EQ(data, i);
}
const char *tmp = "Hello12344556666777777777777545352454254254354354565463241242354345345345235345";
ObObj obj2;
ObString string;
ObString string2;
string.assign_ptr(const_cast<char *>(tmp), 1024);
obj2.set_varchar(string);
for (register int64_t i = 0; i < MAX_COUNT; ++i )
{
pos = 0;
ASSERT_EQ(obj2.serialize(buf, len, pos), OB_SUCCESS);
pos = 0;
ASSERT_EQ(obj2.deserialize(buf, len, pos), OB_SUCCESS);
ASSERT_EQ(obj2.get_varchar(string2), OB_SUCCESS);
}
// int64_t end_time = tbsys::CTimeUtil::getTime();
//printf("using time:%ld\n", end_time - start_time);
}
////////////////////// SERIALIZATION ///////////////////////
int ObSqlReadParam::serialize_basic_param(char * buf, const int64_t buf_len, int64_t & pos) const
{
ObObj obj;
int ret = OB_SUCCESS;
// read consistency
if (ret == OB_SUCCESS)
{
obj.set_int(get_is_read_consistency());
if (OB_SUCCESS != (ret = obj.serialize(buf, buf_len, pos)))
{
TBSYS_LOG(WARN, "fail to serialize basic param. buf=%p, buf_len=%ld, pos=%ld, ret=%d", buf, buf_len, pos, ret);
}
}
// result cached
if (ret == OB_SUCCESS)
{
obj.set_int(get_is_result_cached());
if (OB_SUCCESS != (ret = obj.serialize(buf, buf_len, pos)))
{
TBSYS_LOG(WARN, "fail to serialize basic param. buf=%p, buf_len=%ld, pos=%ld, ret=%d", buf, buf_len, pos, ret);
}
}
// data version
if (ret == OB_SUCCESS)
{
obj.set_int(get_data_version());
if (OB_SUCCESS != (ret = obj.serialize(buf, buf_len, pos)))
{
TBSYS_LOG(WARN, "fail to serialize basic param. buf=%p, buf_len=%ld, pos=%ld, ret=%d", buf, buf_len, pos, ret);
}
}
// table id
if (OB_SUCCESS == ret)
{
if (OB_INVALID_ID != table_id_)
{
obj.set_int(table_id_);
if (OB_SUCCESS != (ret = obj.serialize(buf, buf_len, pos)))
{
TBSYS_LOG(WARN, "fail to serialize table id = %lu", table_id_);
}
}
else
{
TBSYS_LOG(WARN, "Invalid table_id_. table_id_=%ld", table_id_);
ret = OB_INVALID_ARGUMENT;
}
}
// renamed table id
if (OB_SUCCESS == ret)
{
if (OB_INVALID_ID != renamed_table_id_)
{
obj.set_int(renamed_table_id_);
if (OB_SUCCESS != (ret = obj.serialize(buf, buf_len, pos)))
{
TBSYS_LOG(WARN, "fail to serialize renamed table id = %lu", renamed_table_id_);
}
}
else
{
TBSYS_LOG(WARN, "Invalid renamed_table_id_. renamed_table_id_=%ld", renamed_table_id_);
ret = OB_INVALID_ARGUMENT;
}
}
if (OB_SUCCESS == ret)
{
obj.set_bool(only_static_data_);
if (OB_SUCCESS != (ret = obj.serialize(buf, buf_len, pos)))
{
TBSYS_LOG(WARN, "fail to serialize bool:ret[%d]", ret);
}
}
return ret;
}
int gen_sst(const gen_param ¶m)
{
ObSSTableSchema *sst_schema = new(std::nothrow)ObSSTableSchema;
ObSSTableWriter sst_writer;
ObSSTableRow sst_row;
tbsys::CConfig config;
ObSchemaManagerV2 *mgr = new(std::nothrow) ObSchemaManagerV2;
int err = OB_SUCCESS;
if ((NULL == mgr) || (NULL == sst_schema))
{
err = OB_ALLOCATE_MEMORY_FAILED;
TBSYS_LOG(WARN,"fail to allocate memory for ObSchemaManagerV2");
}
if ((OB_SUCCESS == err) && (!mgr->parse_from_file(param.schema_,config)))
{
TBSYS_LOG(WARN,"fail to load schema from file [err:%d,schema.ini:%s]", err, param.schema_);
err = OB_INVALID_ARGUMENT;
}
if ((OB_SUCCESS == err) && (OB_SUCCESS != (err = fill_sstable_schema(*mgr,msolap::target_table_id,*sst_schema))))
{
TBSYS_LOG(WARN,"fail to fill sst schema [err:%d, table_id:%lu]", err, msolap::target_table_id);
}
ObTrailerParam trailer_param;
trailer_param.block_size_ = msolap::ups_sst_block_size;
trailer_param.compressor_name_.assign((char*)msolap::ups_sst_compressor_name, static_cast<int32_t>(strlen(msolap::ups_sst_compressor_name)));
trailer_param.frozen_time_ = tbsys::CTimeUtil::getTime();
trailer_param.store_type_ = msolap::ups_sst_store_type;
trailer_param.table_version_ = msolap::ups_sst_version;
ObString sst_path(static_cast<int32_t>(strlen(param.sst_name_)), static_cast<int32_t>(strlen(param.sst_name_)),(char*)param.sst_name_);
if ((OB_SUCCESS == err) && (OB_SUCCESS != sst_writer.create_sstable(*sst_schema,sst_path, trailer_param)))
{
TBSYS_LOG(WARN,"fail to create sst [err:%d,sst_path:%s]", err, param.sst_name_);
}
uint32_t big_endian_row_key = 0;
int64_t space_usage = 0;
ObString row_key_str(sizeof(big_endian_row_key), sizeof(big_endian_row_key), (char*)&big_endian_row_key);
if((OB_SUCCESS == err) && (OB_SUCCESS != (err = sst_row.set_obj_count(msolap::max_column_id - msolap::min_column_id + 1))))
{
TBSYS_LOG(WARN,"fail to call sst_row.set_obj_count [err:%d]", err);
}
for (uint32_t row_key = param.start_include_; (OB_SUCCESS == err) && (row_key <= param.end_include_); row_key++)
{
big_endian_row_key = htonl(row_key);
sst_row.clear();
if ((OB_SUCCESS == err) &&(OB_SUCCESS != (err = sst_row.set_rowkey(TestRowkeyHelper(row_key_str, &allocator_)))))
{
TBSYS_LOG(WARN,"fail to set sst row rowkey [err:%d]", err);
}
if((OB_SUCCESS == err) && (OB_SUCCESS !=(err = sst_row.set_table_id(msolap::target_table_id))))
{
TBSYS_LOG(WARN,"fail to set sst row table id [err:%d]", err);
}
if((OB_SUCCESS == err) && (OB_SUCCESS !=(err = sst_row.set_column_group_id(msolap::ups_sst_column_group_id))))
{
TBSYS_LOG(WARN,"fail to set sst row group id [err:%d]", err);
}
for (uint64_t column_id = msolap::min_column_id; (OB_SUCCESS == err)&&(column_id <= msolap::max_column_id); column_id ++)
{
ObObj val;
val.set_int(msolap::olap_get_column_val(column_id,big_endian_row_key));
if (OB_SUCCESS != (err = sst_row.add_obj(val)))
{
TBSYS_LOG(WARN,"fail to add obj to sst row [err:%d]", err);
}
}
assert(OB_SUCCESS == sst_row.check_schema(*sst_schema));
if((OB_SUCCESS == err) && (OB_SUCCESS != (err = sst_writer.append_row(sst_row,space_usage))))
{
TBSYS_LOG(WARN,"fail to append row to sst writer [err:%d]", err);
}
}
int64_t trailer_offset = 0;
int64_t sst_size = 0;
if((OB_SUCCESS == err) && (OB_SUCCESS != (err = sst_writer.close_sstable(trailer_offset, sst_size))))
{
TBSYS_LOG(WARN,"fail to close sst [err:%d]", err);
}
else
{
TBSYS_LOG(INFO, "sst write success [trailer_offset:%ld,sst_size:%ld]", trailer_offset, sst_size);
}
delete sst_schema;
delete mgr;
return err;
}
int ObStatManager::get_scanner(ObNewScanner &scanner) const
{
int ret = OB_SUCCESS;
int64_t last_used_mod = OB_INVALID_ID;
char ipbuf[OB_IP_STR_BUFF] = {0};
server_.ip_to_string(ipbuf, sizeof (ipbuf));
ObString ipstr = ObString::make_string(ipbuf);
const int32_t port = server_.get_port();
ObString server_name = ObString::make_string(print_role(get_server_type()));
int64_t total_stat_cnt = 0;
/* create row_desc */
ObRowDesc row_desc;
int32_t column_id = OB_APP_MIN_COLUMN_ID;
row_desc.add_column_desc(OB_ALL_SERVER_STAT_TID, column_id++);
row_desc.add_column_desc(OB_ALL_SERVER_STAT_TID, column_id++);
row_desc.add_column_desc(OB_ALL_SERVER_STAT_TID, column_id++);
row_desc.add_column_desc(OB_ALL_SERVER_STAT_TID, column_id++);
row_desc.add_column_desc(OB_ALL_SERVER_STAT_TID, column_id++);
row_desc.set_rowkey_cell_count(4);
ObRow row;
ObObj obj;
// drop mod id info
for (int32_t mod = 0; mod < OB_MAX_MOD_NUMBER; mod++)
{
ObStat stat;
total_stat_cnt += stat_cnt_[mod];
// drop table id info
for (int32_t i = 0; i < table_stats_[mod].get_array_index(); i++)
{
for (int32_t j = 0; j < stat_cnt_[mod]; j++)
{
stat.inc(j, table_stats_[mod].at(i)->get_value(j));
}
}
for (int32_t i = 0; i < stat_cnt_[mod]; i++)
{
column_id = OB_APP_MIN_COLUMN_ID;
row.set_row_desc(row_desc);
row.reset(false, ObRow::DEFAULT_NULL);
/* server type */
obj.set_type(ObVarcharType);
obj.set_varchar(server_name);
row.set_cell(OB_ALL_SERVER_STAT_TID, column_id++, obj);
/* server ip */
obj.set_type(ObVarcharType);
obj.set_varchar(ipstr);
row.set_cell(OB_ALL_SERVER_STAT_TID, column_id++, obj);
/* port */
obj.set_type(ObIntType);
obj.set_int(port);
row.set_cell(OB_ALL_SERVER_STAT_TID, column_id++, obj);
/* key */
obj.set_type(ObVarcharType);
obj.set_varchar(ObString::make_string(get_name(mod, i)));
row.set_cell(OB_ALL_SERVER_STAT_TID, column_id++, obj);
/* value */
obj.set_type(ObIntType);
obj.set_int(stat.get_value(i));
row.set_cell(OB_ALL_SERVER_STAT_TID, column_id++, obj);
scanner.add_row(row);
// for last rowkey
last_used_mod = mod;
}
}
/* last rowkey */
if (total_stat_cnt > 0)
{
static ObObj rk_objs[4];
rk_objs[0].set_type(ObVarcharType);
rk_objs[0].set_varchar(server_name);
rk_objs[1].set_type(ObVarcharType);
rk_objs[1].set_varchar(ipstr);
rk_objs[2].set_type(ObIntType);
rk_objs[2].set_int(port);
rk_objs[3].set_type(ObVarcharType);
rk_objs[3].set_varchar(ObString::make_string(get_name(last_used_mod, stat_cnt_[last_used_mod] - 1)));
ObRowkey rowkey(rk_objs, 4);
scanner.set_last_row_key(rowkey);
}
/* fullfilled */
scanner.set_is_req_fullfilled(true, total_stat_cnt);
return ret;
}
ObObj gen_int_obj(int64_t int_value, bool is_add = false)
{
ObObj value;
value.set_int(int_value, is_add);
return value;
}
