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 obj_cast(const ObObj &orig_cell, const ObObj &expected_type,
ObObj &casted_cell, const ObObj *&res_cell)
{
int ret = OB_SUCCESS;
if (orig_cell.get_type() != expected_type.get_type())
{
// type cast
ObObjCastParams params;
ObExprObj from;
ObExprObj to;
from.assign(orig_cell);
to.assign(casted_cell);
if (OB_SUCCESS != (ret = OB_OBJ_CAST[orig_cell.get_type()][expected_type.get_type()](params, from, to)))
{
jlog(WARNING, "failed to type cast obj, err=%d", ret);
}
else if (OB_SUCCESS != (ret = to.to(casted_cell)))
{
jlog(WARNING, "failed to convert expr_obj to obj, err=%d", ret);
}
else
{
res_cell = &casted_cell;
}
}
else
{
res_cell = &orig_cell;
}
return ret;
}
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));
}
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_bool)
{
ObObj t;
t.set_bool(true);
int64_t len = t.get_serialize_size();
ASSERT_EQ(len,2);
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);
bool r = false;
bool l = false;
ASSERT_EQ(f.get_type(),t.get_type());
f.get_bool(r);
t.get_bool(l);
ASSERT_EQ(r,l);
free(buf);
}
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(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);
}
}
TEST(ObObj,Serialize_precise_datetime)
{
ObObj t1;
t1.set_precise_datetime(221348087492);
int64_t len = t1.get_serialize_size();
char *buf = (char *)malloc(len);
int64_t pos = 0;
ASSERT_EQ(t1.serialize(buf,len,pos),OB_SUCCESS);
ObObj f;
pos = 0;
ASSERT_EQ(f.deserialize(buf,len,pos),OB_SUCCESS);
ASSERT_EQ(f.get_type(),t1.get_type());
ObPreciseDateTime l = 0;
ObPreciseDateTime r = 0;
f.get_precise_datetime(l);
t1.get_precise_datetime(r);
ASSERT_EQ(l,r);
free(buf);
}
int ObStringBuf :: write_obj(const ObObj& obj, ObObj* stored_obj)
{
int err = OB_SUCCESS;
if (NULL != stored_obj)
{
*stored_obj = obj;
}
ObObjType type = obj.get_type();
if (ObVarcharType == type)
{
ObString value;
ObString new_value;
obj.get_varchar(value);
err = write_string(value, &new_value);
if (OB_SUCCESS == err)
{
if (NULL != stored_obj)
{
stored_obj->set_varchar(new_value);
}
}
}
return err;
}
TEST_F(ObTabletJoinTest, get_right_table_rowkey)
{
ObRowDesc row_desc;
row_desc.add_column_desc(LEFT_TABLE_ID, 1);
const char *rowkey_str = "oceanbase";
ObString row_key_str;
row_key_str.assign_ptr(const_cast<char *>(rowkey_str), (int32_t)strlen(rowkey_str));
ObObj row_key_obj;
row_key_obj.set_varchar(row_key_str);
ObRowkey row_key;
row_key.assign(&row_key_obj, 1);
ObObj value;
value.set_varchar(row_key_str);
ObRow row;
row.set_row_desc(row_desc);
row.raw_set_cell(0, value);
ObObj rowkey_obj[OB_MAX_ROWKEY_COLUMN_NUMBER];
ObRowkey rowkey2;
ObTabletCacheJoin tablet_join;
tablet_join.set_table_join_info(tablet_join_info_);
OK(tablet_join.get_right_table_rowkey(row, rowkey2, rowkey_obj));
ASSERT_TRUE(row_key == rowkey2);
}
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;
}
/* 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();
}
}
int ObMetaTable3::MyIterator::check_rowkey_obj_type(int32_t rowkey_obj_idx, const ObObj &obj) const
{
int ret = OB_SUCCESS;
bool found = false;
for (int k = 0; k < table_schema_.columns_.count(); ++k)
{
const ColumnSchema &cschema = table_schema_.columns_.at(k);
if (rowkey_obj_idx + 1 == cschema.rowkey_id_) // rowkey_id start from 1
{
if (obj.get_type() != cschema.data_type_
&& (!obj.is_min_value())
&& (!obj.is_max_value()))
{
TBSYS_LOG(WARN, "invalid meta table row key, cid=%lu ctype=%d obj_type=%d",
cschema.column_id_, cschema.data_type_, obj.get_type());
break;
}
found = true;
break;
}
} // end for
if (!found)
{
TBSYS_LOG(WARN, "rowkey obj not found in table schema, idx=%d", rowkey_obj_idx);
ret = OB_ERR_DATA_FORMAT;
}
return ret;
}
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_str_obj_value(char * buf, const int64_t buf_len, int64_t & pos, const ObString &value)
{
int ret = OB_SUCCESS;
ObObj obj;
obj.set_varchar(value);
ret = obj.serialize(buf, buf_len, pos);
return ret;
}
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, ObString& value)
{
ObString name;
name.assign_ptr(const_cast<char*>(column_name), static_cast<int32_t>(strlen(column_name)));
ObObj obj;
obj.set_varchar(value);
EasyArray<ObSimpleCond>(ObSimpleCond(name, cond_op, obj));
}
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;
}
ScanConds& ScanConds::operator()(const char* column_name, const ObLogicOperator& cond_op, int64_t value)
{
ObString name;
name.assign_ptr(const_cast<char*>(column_name), static_cast<int32_t>(strlen(column_name)));
ObObj obj;
obj.set_int(value);
EasyArray<ObSimpleCond>::operator()(ObSimpleCond(name, cond_op, obj));
return *this;
}
int 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 ObSqlGetParam::serialize_flag(char* buf, const int64_t buf_len, int64_t& pos,
const int64_t flag) const
{
int ret = OB_SUCCESS;
ObObj obj;
obj.set_ext(flag);
ret = obj.serialize(buf, buf_len, pos);
return ret;
}
int get_str_obj_value(const char* buf, const int64_t buf_len, int64_t & pos, ObString & str_value)
{
int ret = OB_SUCCESS;
ObObj obj;
if ( OB_SUCCESS == (ret = obj.deserialize(buf, buf_len, pos))
&& ObVarcharType == obj.get_type())
{
ret = obj.get_varchar(str_value);
}
return ret;
}
int get_int_obj_value(const char* buf, const int64_t buf_len, int64_t & pos, int64_t & int_value)
{
int ret = OB_SUCCESS;
ObObj obj;
if ( OB_SUCCESS == (ret = obj.deserialize(buf, buf_len, pos))
&& ObIntType == obj.get_type())
{
ret = obj.get_int(int_value);
}
return ret;
}
void check_obj(const ObObj& expected, const ObObj& real)
{
// TODO
EXPECT_EQ(expected.get_type(), real.get_type());
int64_t expected_val, real_val;
int ret = 0;
ret = expected.get_int(expected_val);
EXPECT_EQ(0, ret);
ret = real.get_int(real_val);
EXPECT_EQ(0, ret);
EXPECT_EQ(expected_val, real_val);
}
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;
}
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;
}
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 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);
}
}
int ObReadParam::deserialize_reserve_param(const char * buf, const int64_t data_len, int64_t & pos)
{
ObObj obj;
int64_t int_value = 0;
int ret = obj.deserialize(buf, data_len, pos);
if (OB_SUCCESS == ret)
{
ret = obj.get_int(int_value);
if (OB_SUCCESS == ret)
{
//is read master
set_is_read_consistency(int_value);
}
}
return ret;
}
