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);
}
/* 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 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;
}
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);
}
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));
}
inline int ObCellArray::copy_obj_(ObObj &dst, const ObObj &src)
{
int err = OB_SUCCESS;
char *tmp_buf = NULL;
/// allocate value
if (src.get_type() == ObVarcharType)
{
ObString src_value;
ObString dst_value;
err = src.get_varchar(src_value);
if (OB_SUCCESS == err)
{
// must assign %src to %dst first, for copy meta data to %dst object.
// dst's meta_ members(especially meta_.reserved_) could be random value
// if only call dst.set_varchar();
dst = src;
if (src_value.length() > 0)
{
tmp_buf =reinterpret_cast<char*>( page_arena_.alloc(src_value.length()));
if (NULL == tmp_buf)
{
TBSYS_LOG(WARN, "%s", "fail to malloc buffer for varchar value");
err = OB_ALLOCATE_MEMORY_FAILED;
}
else
{
allocated_memory_size_ += src_value.length();
memcpy(tmp_buf, src_value.ptr(), src_value.length());
dst_value.assign(tmp_buf,src_value.length());
dst.set_varchar(dst_value);
}
}
else
{
dst.set_varchar(dst_value);
}
}
}
return err;
}
virtual void SetUp()
{
int64_t pos = 0;
range.table_id_ = 1001;
start_key_obj.set_varchar(start_key);
range.start_key_.assign(&start_key_obj, 1);
end_key_obj.set_varchar(end_key);
range.end_key_.assign(&end_key_obj, 1);
range.border_flag_.unset_inclusive_start();
range.border_flag_.set_inclusive_end();
default_range.table_id_ = OB_INVALID_ID;
default_range.set_whole_range();
default_range.border_flag_.unset_inclusive_start();
default_range.border_flag_.unset_inclusive_end();
range.start_key_.serialize(key_stream_buf, 512, pos);
range.end_key_.serialize(key_stream_buf, 512, pos);
key_stream.assign_ptr(key_stream_buf, static_cast<int32_t>(pos));
}
int ObUpsCompactCellIterator::parse_varchar(ObBufferReader &buf_reader, ObObj &value) const
{
int ret = OB_SUCCESS;
const int32_t *varchar_len = NULL;
ObString str_value;
ret = buf_reader.get<int32_t>(varchar_len);
if(OB_SUCCESS == ret)
{
if(*varchar_len <= (int32_t)sizeof(const char*))
{
str_value.assign_ptr(const_cast<char*>(buf_reader.cur_ptr()), *varchar_len);
buf_reader.skip(*varchar_len);
value.set_varchar(str_value);
}
else
{
const char* ptr = buf_reader.get<const char*>();
str_value.assign_ptr(const_cast<char*>(ptr), *varchar_len);
value.set_varchar(str_value);
}
}
return ret;
}
TEST(ObPrivilege, test)
{
ObPrivilege privilege;
int ret = OB_SUCCESS;
ret = privilege.init();
ASSERT_EQ(OB_SUCCESS, ret);
// add_user_table_privilege_per
ObRow row;
ObRowDesc row_desc;
ObRow row2;
ObRowDesc row_desc2;
const uint64_t OB_USERS_TID = 20;
const uint64_t OB_USERS_USERNAME_CID = 30;
const uint64_t OB_USERS_USERID_CID = 31;
const uint64_t OB_USERS_PASSWORD_CID = 32;
const uint64_t OB_USERS_COMMENT_CID = 34;
const uint64_t OB_USERS_PRIV_ALL_CID = 35;
const uint64_t OB_USERS_PRIV_ALTER_CID = 36;
const uint64_t OB_USERS_PRIV_CREATE_CID = 37;
const uint64_t OB_USERS_PRIV_CREATE_USER_CID = 38;
const uint64_t OB_USERS_PRIV_DELETE_CID = 39;
const uint64_t OB_USERS_PRIV_DROP_CID = 40;
const uint64_t OB_USERS_PRIV_GRANT_OPTION_CID = 41;
const uint64_t OB_USERS_PRIV_INSERT_CID = 42;
const uint64_t OB_USERS_PRIV_UPDATE_CID = 43;
const uint64_t OB_USERS_PRIV_SELECT_CID = 44;
const uint64_t OB_USERS_LOCKED_CID = 45;
const uint64_t OB_TABLE_PRIVILEGES_TID = 40;
const uint64_t OB_TABLE_PRIVILEGES_USERID_CID = 50;
const uint64_t OB_TABLE_PRIVILEGES_TABLEID_CID = 51;
const uint64_t OB_TABLE_PRIVILEGES_PRIV_ALL_CID = 52;
const uint64_t OB_TABLE_PRIVILEGES_PRIV_ALTER_CID = 53;
const uint64_t OB_TABLE_PRIVILEGES_PRIV_CREATE_CID = 54;
const uint64_t OB_TABLE_PRIVILEGES_PRIV_CREATE_USER_CID = 55;
const uint64_t OB_TABLE_PRIVILEGES_PRIV_DELETE_CID = 56;
const uint64_t OB_TABLE_PRIVILEGES_PRIV_DROP_CID = 57;
const uint64_t OB_TABLE_PRIVILEGES_PRIV_GRANT_OPTION_CID = 58;
const uint64_t OB_TABLE_PRIVILEGES_PRIV_INSERT_CID = 59;
const uint64_t OB_TABLE_PRIVILEGES_PRIV_UPDATE_CID = 60;
const uint64_t OB_TABLE_PRIVILEGES_PRIV_SELECT_CID = 61;
// set row desc, set table __users
ASSERT_EQ(OB_SUCCESS, row_desc.add_column_desc(OB_USERS_TID, OB_USERS_USERNAME_CID));
ASSERT_EQ(OB_SUCCESS, row_desc.add_column_desc(OB_USERS_TID, OB_USERS_USERID_CID));
ASSERT_EQ(OB_SUCCESS, row_desc.add_column_desc(OB_USERS_TID, OB_USERS_PASSWORD_CID));
ASSERT_EQ(OB_SUCCESS, row_desc.add_column_desc(OB_USERS_TID, OB_USERS_COMMENT_CID));
ASSERT_EQ(OB_SUCCESS, row_desc.add_column_desc(OB_USERS_TID, OB_USERS_PRIV_ALL_CID));
ASSERT_EQ(OB_SUCCESS, row_desc.add_column_desc(OB_USERS_TID, OB_USERS_PRIV_ALTER_CID));
ASSERT_EQ(OB_SUCCESS, row_desc.add_column_desc(OB_USERS_TID, OB_USERS_PRIV_CREATE_CID));
ASSERT_EQ(OB_SUCCESS, row_desc.add_column_desc(OB_USERS_TID, OB_USERS_PRIV_CREATE_USER_CID));
ASSERT_EQ(OB_SUCCESS, row_desc.add_column_desc(OB_USERS_TID, OB_USERS_PRIV_DELETE_CID));
ASSERT_EQ(OB_SUCCESS, row_desc.add_column_desc(OB_USERS_TID, OB_USERS_PRIV_DROP_CID));
ASSERT_EQ(OB_SUCCESS, row_desc.add_column_desc(OB_USERS_TID, OB_USERS_PRIV_GRANT_OPTION_CID));
ASSERT_EQ(OB_SUCCESS, row_desc.add_column_desc(OB_USERS_TID, OB_USERS_PRIV_INSERT_CID));
ASSERT_EQ(OB_SUCCESS, row_desc.add_column_desc(OB_USERS_TID, OB_USERS_PRIV_UPDATE_CID));
ASSERT_EQ(OB_SUCCESS, row_desc.add_column_desc(OB_USERS_TID, OB_USERS_PRIV_SELECT_CID));
ASSERT_EQ(OB_SUCCESS, row_desc.add_column_desc(OB_USERS_TID, OB_USERS_LOCKED_CID));
//set row desc , set table __table_privileges
ASSERT_EQ(OB_SUCCESS, row_desc2.add_column_desc(OB_TABLE_PRIVILEGES_TID, OB_TABLE_PRIVILEGES_USERID_CID));
ASSERT_EQ(OB_SUCCESS, row_desc2.add_column_desc(OB_TABLE_PRIVILEGES_TID, OB_TABLE_PRIVILEGES_TABLEID_CID));
ASSERT_EQ(OB_SUCCESS, row_desc2.add_column_desc(OB_TABLE_PRIVILEGES_TID, OB_TABLE_PRIVILEGES_PRIV_ALL_CID));
ASSERT_EQ(OB_SUCCESS, row_desc2.add_column_desc(OB_TABLE_PRIVILEGES_TID, OB_TABLE_PRIVILEGES_PRIV_ALTER_CID));
ASSERT_EQ(OB_SUCCESS, row_desc2.add_column_desc(OB_TABLE_PRIVILEGES_TID, OB_TABLE_PRIVILEGES_PRIV_CREATE_CID));
ASSERT_EQ(OB_SUCCESS, row_desc2.add_column_desc(OB_TABLE_PRIVILEGES_TID, OB_TABLE_PRIVILEGES_PRIV_CREATE_USER_CID));
ASSERT_EQ(OB_SUCCESS, row_desc2.add_column_desc(OB_TABLE_PRIVILEGES_TID, OB_TABLE_PRIVILEGES_PRIV_DELETE_CID));
ASSERT_EQ(OB_SUCCESS, row_desc2.add_column_desc(OB_TABLE_PRIVILEGES_TID, OB_TABLE_PRIVILEGES_PRIV_DROP_CID));
ASSERT_EQ(OB_SUCCESS, row_desc2.add_column_desc(OB_TABLE_PRIVILEGES_TID, OB_TABLE_PRIVILEGES_PRIV_GRANT_OPTION_CID));
ASSERT_EQ(OB_SUCCESS, row_desc2.add_column_desc(OB_TABLE_PRIVILEGES_TID, OB_TABLE_PRIVILEGES_PRIV_INSERT_CID));
ASSERT_EQ(OB_SUCCESS, row_desc2.add_column_desc(OB_TABLE_PRIVILEGES_TID, OB_TABLE_PRIVILEGES_PRIV_UPDATE_CID));
ASSERT_EQ(OB_SUCCESS, row_desc2.add_column_desc(OB_TABLE_PRIVILEGES_TID, OB_TABLE_PRIVILEGES_PRIV_SELECT_CID));
row.set_row_desc(row_desc);
row2.set_row_desc(row_desc2);
//=======================================================================================
// set row data
ObObj username;
ObString str;
str.assign_ptr(const_cast<char*>("zhangsan"), static_cast<int32_t>(strlen("zhangsan")));
username.set_varchar(str);
ASSERT_EQ(OB_SUCCESS, row.set_cell(OB_USERS_TID, OB_USERS_USERNAME_CID, username));
ObObj userid;
userid.set_int(10);
ASSERT_EQ(OB_SUCCESS, row.set_cell(OB_USERS_TID, OB_USERS_USERID_CID, userid));
ObObj password;
str.assign_ptr(const_cast<char*>("encryptedpass"), static_cast<int32_t>(strlen("encryptedpass")));
password.set_varchar(str);
ASSERT_EQ(OB_SUCCESS, row.set_cell(OB_USERS_TID, OB_USERS_PASSWORD_CID, password));
ObObj comment;
str.assign_ptr(const_cast<char*>("comment content"), static_cast<int32_t>(strlen("comment content")));
comment.set_varchar(str);
ASSERT_EQ(OB_SUCCESS, row.set_cell(OB_USERS_TID, OB_USERS_COMMENT_CID, comment));
/* PRIV_ALL PRIV_ALTER PRIV_CREATE PRIV_CREATE_USER PRIV_DELETE PRIV_DROP PRIV_GRANT_OPTION PRIV_INSERT PRIV_UPDATE PRIV_SELECT
* 1 1 0 0 1 0 0 1 0 0
*
*
*
*/
/* set privilege-related cell*/
ObObj priv_all;
priv_all.set_int(1);
ASSERT_EQ(OB_SUCCESS, row.set_cell(OB_USERS_TID, OB_USERS_PRIV_ALL_CID, priv_all));
ObObj priv_alter;
priv_alter.set_int(1);
ASSERT_EQ(OB_SUCCESS, row.set_cell(OB_USERS_TID, OB_USERS_PRIV_ALTER_CID, priv_alter));
ObObj priv_create;
priv_create.set_int(0);
ASSERT_EQ(OB_SUCCESS, row.set_cell(OB_USERS_TID, OB_USERS_PRIV_CREATE_CID, priv_create));
ObObj priv_create_user;
priv_create_user.set_int(0);
ASSERT_EQ(OB_SUCCESS, row.set_cell(OB_USERS_TID, OB_USERS_PRIV_CREATE_USER_CID, priv_create_user));
ObObj priv_delete;
priv_delete.set_int(1);
ASSERT_EQ(OB_SUCCESS, row.set_cell(OB_USERS_TID, OB_USERS_PRIV_DELETE_CID, priv_delete));
ObObj priv_drop;
priv_drop.set_int(0);
ASSERT_EQ(OB_SUCCESS, row.set_cell(OB_USERS_TID, OB_USERS_PRIV_DROP_CID, priv_drop));
ObObj priv_grant_option;
priv_grant_option.set_int(0);
ASSERT_EQ(OB_SUCCESS, row.set_cell(OB_USERS_TID, OB_USERS_PRIV_GRANT_OPTION_CID, priv_grant_option));
ObObj priv_insert;
priv_insert.set_int(1);
ASSERT_EQ(OB_SUCCESS, row.set_cell(OB_USERS_TID, OB_USERS_PRIV_INSERT_CID, priv_insert));
ObObj priv_update;
priv_update.set_int(0);
ASSERT_EQ(OB_SUCCESS, row.set_cell(OB_USERS_TID, OB_USERS_PRIV_UPDATE_CID, priv_update));
ObObj priv_select;
priv_select.set_int(0);
ASSERT_EQ(OB_SUCCESS, row.set_cell(OB_USERS_TID, OB_USERS_PRIV_SELECT_CID, priv_select));
/* finish set privilege-related cell */
ObObj locked;
locked.set_int(0);//locked
ASSERT_EQ(OB_SUCCESS, row.set_cell(OB_USERS_TID, OB_USERS_LOCKED_CID, locked));
//=====================================================================================
ObObj table_user_id;
table_user_id.set_int(10);//user id
ASSERT_EQ(OB_SUCCESS, row2.set_cell(OB_TABLE_PRIVILEGES_TID, OB_TABLE_PRIVILEGES_USERID_CID, table_user_id));
ObObj table_table_id;
table_table_id.set_int(100);//table id
ASSERT_EQ(OB_SUCCESS, row2.set_cell(OB_TABLE_PRIVILEGES_TID, OB_TABLE_PRIVILEGES_TABLEID_CID, table_table_id));
//start set privilege-related cell for table __table_privileges
// user: 1100100100
// user_table: 0000010100
ObObj table_priv_all;
table_priv_all.set_int(0);
ASSERT_EQ(OB_SUCCESS, row2.set_cell(OB_TABLE_PRIVILEGES_TID, OB_TABLE_PRIVILEGES_PRIV_ALL_CID, table_priv_all));
ObObj table_priv_alter;
table_priv_alter.set_int(0);
ASSERT_EQ(OB_SUCCESS, row2.set_cell(OB_TABLE_PRIVILEGES_TID, OB_TABLE_PRIVILEGES_PRIV_ALTER_CID, table_priv_alter));
ObObj table_priv_create;
table_priv_create.set_int(0);
ASSERT_EQ(OB_SUCCESS, row2.set_cell(OB_TABLE_PRIVILEGES_TID, OB_TABLE_PRIVILEGES_PRIV_CREATE_CID, table_priv_create));
ObObj table_priv_create_user;
table_priv_create_user.set_int(0);
ASSERT_EQ(OB_SUCCESS, row2.set_cell(OB_TABLE_PRIVILEGES_TID, OB_TABLE_PRIVILEGES_PRIV_CREATE_USER_CID, table_priv_create_user));
ObObj table_priv_delete;
table_priv_delete.set_int(0);
ASSERT_EQ(OB_SUCCESS, row2.set_cell(OB_TABLE_PRIVILEGES_TID, OB_TABLE_PRIVILEGES_PRIV_DELETE_CID, table_priv_delete));
ObObj table_priv_drop;
table_priv_drop.set_int(1);
ASSERT_EQ(OB_SUCCESS, row2.set_cell(OB_TABLE_PRIVILEGES_TID, OB_TABLE_PRIVILEGES_PRIV_DROP_CID, table_priv_drop));
ObObj table_priv_grant_option;
table_priv_grant_option.set_int(0);
ASSERT_EQ(OB_SUCCESS, row2.set_cell(OB_TABLE_PRIVILEGES_TID, OB_TABLE_PRIVILEGES_PRIV_GRANT_OPTION_CID, table_priv_grant_option));
ObObj table_priv_insert;
table_priv_insert.set_int(1);
ASSERT_EQ(OB_SUCCESS, row2.set_cell(OB_TABLE_PRIVILEGES_TID, OB_TABLE_PRIVILEGES_PRIV_INSERT_CID, table_priv_insert));
ObObj table_priv_update;
table_priv_update.set_int(0);
ASSERT_EQ(OB_SUCCESS, row2.set_cell(OB_TABLE_PRIVILEGES_TID, OB_TABLE_PRIVILEGES_PRIV_UPDATE_CID, table_priv_update));
ObObj table_priv_select;
table_priv_select.set_int(0);
ASSERT_EQ(OB_SUCCESS, row2.set_cell(OB_TABLE_PRIVILEGES_TID, OB_TABLE_PRIVILEGES_PRIV_SELECT_CID, table_priv_select));
/* finished set privilege-related cell for table __table_privileges */
//============================================================================================================
//start testing
ASSERT_EQ(OB_SUCCESS, privilege.add_users_entry(row));
ASSERT_EQ(OB_SUCCESS, privilege.add_table_privileges_entry(row2));
ObString user1;
ObString pass1;
user1.assign_ptr(const_cast<char*>("zhangsan"), static_cast<int32_t>(strlen("zhangsan")));
pass1.assign_ptr(const_cast<char*>("encryptedpass"), static_cast<int32_t>(strlen("encryptedpass")));
ASSERT_EQ(OB_SUCCESS, privilege.user_is_valid(user1, pass1));
ObString user2;
ObString pass2;
user2.assign_ptr(const_cast<char*>("lisi"), static_cast<int32_t>(strlen("lisi")));
pass2.assign_ptr(const_cast<char*>("lisipass"), static_cast<int32_t>(strlen("lisipass")));
ASSERT_EQ(OB_ERR_USER_NOT_EXIST, privilege.user_is_valid(user2, pass2));
ObString user3;
ObString pass3;
user3.assign_ptr(const_cast<char*>("zhangsan"), static_cast<int32_t>(strlen("zhangsan")));
pass3.assign_ptr(const_cast<char*>("xxxx"), static_cast<int32_t>(strlen("xxxx")));
ASSERT_EQ(OB_ERR_WRONG_PASSWORD, privilege.user_is_valid(user3, pass3));
//=========================================================================================================
// OB_PRIV_ALL从第一个bit开始
// user: 1100100100
// user_table: 0000010100
ObPrivilege::TablePrivilege table_privilege;
// on table_id=100, user zhangsan have:
// user: 1100100100
// user_table: 0000010100
//
// we test: 0111010000 , result should be true
table_privilege.table_id_ = 100;
EXPECT_TRUE(table_privilege.privileges_.add_member(OB_PRIV_ALTER));
EXPECT_TRUE(table_privilege.privileges_.add_member(OB_PRIV_CREATE));
EXPECT_TRUE(table_privilege.privileges_.add_member(OB_PRIV_CREATE_USER));
EXPECT_TRUE(table_privilege.privileges_.add_member(OB_PRIV_DROP));
ObArray<ObPrivilege::TablePrivilege> arr;
ASSERT_EQ(OB_SUCCESS, arr.push_back(table_privilege));
ASSERT_EQ(OB_SUCCESS, privilege.has_needed_privileges(user1, arr));
arr.pop_back();
// we test: 1100001100 result should be false
/* PRIV_ALL PRIV_ALTER PRIV_CREATE PRIV_CREATE_USER PRIV_DELETE PRIV_DROP PRIV_GRANT_OPTION PRIV_INSERT PRIV_UPDATE PRIV_SELECT*/
EXPECT_TRUE(table_privilege.privileges_.add_member(OB_PRIV_ALL));
EXPECT_TRUE(table_privilege.privileges_.add_member(OB_PRIV_ALTER));
EXPECT_TRUE(table_privilege.privileges_.add_member(OB_PRIV_GRANT_OPTION));
EXPECT_TRUE(table_privilege.privileges_.add_member(OB_PRIV_INSERT));
ASSERT_EQ(OB_SUCCESS, arr.push_back(table_privilege));
ASSERT_EQ(OB_ERR_NO_PRIVILEGE, privilege.has_needed_privileges(user1, arr));
arr.pop_back();
}
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;
}
void CellinfoBuilder::build_cell_(struct drand48_data &rand_data, const ObString &row_key, const ObSchema &schema,
ObObj &obj, int64_t &column_pos, int &op_type,
PageArena<char> &allocer)
{
const ObColumnSchema *column_schema = schema.column_begin();
int64_t column_num = schema.column_end() - schema.column_begin();
int64_t rand = 0;
lrand48_r(&rand_data, &rand);
op_type = calc_op_type_(rand);
//while (true)
//{
// lrand48_r(&rand_data, &rand);
// column_pos = range_rand(0, column_num - 3, rand);
// if (ObIntType <= column_schema[column_pos].get_type()
// && ObVarcharType >= column_schema[column_pos].get_type())
// {
// break;
// }
//}
column_pos=0;
lrand48_r(&rand_data, &rand);
switch (column_schema[column_pos].get_type())
{
case ObIntType:
{
int64_t tmp = rand;
obj.set_int(tmp, ADD == op_type);
break;
}
case ObFloatType:
{
float tmp = static_cast<float>(rand);
obj.set_float(tmp, ADD == op_type);
break;
}
case ObDoubleType:
{
double tmp = static_cast<double>(rand);
obj.set_double(tmp, ADD == op_type);
break;
}
case ObDateTimeType:
{
ObDateTime tmp = static_cast<ObDateTime>(rand);
obj.set_datetime(tmp, ADD == op_type);
break;
}
case ObPreciseDateTimeType:
{
ObPreciseDateTime tmp = static_cast<ObPreciseDateTime>(rand);
obj.set_precise_datetime(tmp, ADD == op_type);
break;
}
case ObVarcharType:
{
int64_t length = range_rand(1, column_schema[column_pos].get_size(), rand);
char *ptr = allocer.alloc(length);
build_string(ptr, length, rand);
ObString str;
str.assign_ptr(ptr, length);
if (ADD == op_type)
{
op_type = UPDATE;
}
obj.set_varchar(str);
break;
}
default:
break;
}
if (DEL_CELL == op_type)
{
obj.set_null();
}
else if (DEL_ROW == op_type)
{
obj.set_ext(ObActionFlag::OP_DEL_ROW);
}
}
int ObVariableSet::process_variables_set()
{
int ret = OB_SUCCESS;
bool need_global_change = false;
ObRow val_row;
const ObObj *value_obj = NULL;
ObSQLSessionInfo *session = my_phy_plan_->get_result_set()->get_session();
for (int64_t i = 0; ret == OB_SUCCESS && i < variable_nodes_.count(); i++)
{
VariableSetNode& node = variable_nodes_.at(i);
if ((ret = node.variable_expr_->calc(val_row, value_obj)) != OB_SUCCESS)
{
TBSYS_LOG(WARN, "Calculate variable value failed. ret=%d", ret);
}
else if (!node.is_system_variable_)
{
// user defined tmp variable
if ((ret = session->replace_variable(
node.variable_name_,
*value_obj)) != OB_SUCCESS)
{
TBSYS_LOG(WARN, "set variable to session plan failed. ret=%d, name=%.*s",
ret, node.variable_name_.length(), node.variable_name_.ptr());
}
}
else if (!node.is_global_)
{
// set session system variable
if ((ret = session->update_system_variable(
node.variable_name_,
*value_obj)) != OB_SUCCESS)
{
TBSYS_LOG(WARN, "set variable to session plan failed. ret=%d, name=%.*s",
ret, node.variable_name_.length(), node.variable_name_.ptr());
}
// special case: set autocommit
else if (node.variable_name_ == ObString::make_string("autocommit"))
{
int64_t int_val = 0;
ObObj int_obj;
ObObj obj_type;
obj_type.set_type(ObIntType);
const ObObj *res_obj = NULL;
if (OB_SUCCESS != (ret = obj_cast(*value_obj, obj_type, int_obj, res_obj)))
{
TBSYS_LOG(WARN, "failed to cast to int, obj=%s", to_cstring(*value_obj));
}
else
{
ret = res_obj->get_int(int_val);
OB_ASSERT(OB_SUCCESS == ret);
if (int_val)
{
ret = set_autocommit();
OB_STAT_INC(OBMYSQL, SQL_AUTOCOMMIT_ON_COUNT);
}
else
{
ret = clear_autocommit();
OB_STAT_INC(OBMYSQL, SQL_AUTOCOMMIT_OFF_COUNT);
}
}
}
}
else
{
// set global system variable
char key_varchar_buff[OB_MAX_ROWKEY_COLUMN_NUMBER + 1][OB_MAX_VARCHAR_LENGTH];
ObObj casted_cells[OB_MAX_ROWKEY_COLUMN_NUMBER + 1];
ObObj rowkey_objs[OB_MAX_ROWKEY_COLUMN_NUMBER];
const ObObj *res_cell = NULL;
ObRowkey rowkey;
ObObj value;
// construct rowkey
for (int64_t j = 0; ret == OB_SUCCESS && j < rowkey_info_.get_size(); ++j)
{
uint64_t cid = OB_INVALID_ID;
ObString varchar;
varchar.assign_ptr(key_varchar_buff[j], OB_MAX_VARCHAR_LENGTH);
casted_cells[j].set_varchar(varchar);
const ObRowkeyColumn *rowkey_column = rowkey_info_.get_column(j);
if (rowkey_column == NULL)
{
ret = OB_ERROR;
TBSYS_LOG(ERROR, "Get rowkey error");
break;
}
else if (OB_SUCCESS != (ret = rowkey_info_.get_column_id(j, cid)))
{
TBSYS_LOG(USER_ERROR, "Primary key can not be empty");
ret = OB_ERR_GEN_PLAN;
break;
}
else
{
ObObj data_type;
data_type.set_type(rowkey_column->type_);
if (cid != name_cid_)
{
value.set_int(0);
}
else
{
value.set_varchar(node.variable_name_);
}
if (OB_SUCCESS != (ret = obj_cast(value, data_type, casted_cells[j], res_cell)))
{
TBSYS_LOG(USER_ERROR, "Primary key can not be empty");
ret = OB_ERR_GEN_PLAN;
break;
}
else
{
rowkey_objs[j] = *res_cell;
}
}
}
if (ret == OB_SUCCESS)
{
rowkey.assign(rowkey_objs, rowkey_info_.get_size());
}
else
{
break;
}
// add type and value
if (ret == OB_SUCCESS)
{
ObString varchar;
varchar.assign_ptr(key_varchar_buff[OB_MAX_ROWKEY_COLUMN_NUMBER], OB_MAX_VARCHAR_LENGTH);
ObObj &casted_cell = casted_cells[OB_MAX_ROWKEY_COLUMN_NUMBER];
casted_cell.set_varchar(varchar);
ObObj value_type;
value_type.set_type(value_type_);
if (OB_SUCCESS != (ret = obj_cast(*value_obj, value_type, casted_cell, res_cell)))
{
TBSYS_LOG(WARN, "Failed to cast obj, err=%d", ret);
break;
}
else if (OB_SUCCESS != (ret = mutator_.update(table_id_, rowkey, value_cid_, *res_cell)))
{
TBSYS_LOG(WARN, "Failed to update cell, err=%d", ret);
break;
}
else
{
need_global_change = true;
}
}
}
}
// send mutator
ObScanner scanner;
if (OB_SUCCESS == ret && need_global_change
&& OB_SUCCESS != (ret = rpc_->ups_mutate(mutator_, false, scanner)))
{
TBSYS_LOG(WARN, "failed to send mutator to ups, err=%d", ret);
}
return ret;
}
TEST_F(TestSimpleFilter, test_check_cond)
{
ObSimpleFilter filter;
// 2, LIKE test_test
ObLogicOperator operate = LIKE;
char * ptr = "test_test";
ObString sub_string;
sub_string.assign(ptr, strlen(ptr));
ObObj operand;
operand.set_varchar(sub_string);
EXPECT_TRUE(filter.add_cond(2, operate, operand) == OB_SUCCESS);
// 1, NE 23
operate = NE;
operand.set_int(23);
EXPECT_TRUE(filter.add_cond(1, operate, operand) == OB_SUCCESS);
// 3, LT test_test
operate = LT;
operand.set_varchar(sub_string);
EXPECT_TRUE(filter.add_cond(3, operate, operand) == OB_SUCCESS);
ObCellInfo cell;
cell.table_id_ = 1;
cell.column_id_ = 2;
ObCellInfo * out_cell;
ObObj obj;
obj.set_int(1234);
cell.value_ = obj;
bool result = false;
// true
BLOCK_FUNC()
{
// 0
ObCellArray cells;
EXPECT_TRUE(cells.append(cell, out_cell) == OB_SUCCESS);
// 1
obj.set_int(22);
cell.value_ = obj;
EXPECT_TRUE(cells.append(cell, out_cell) == OB_SUCCESS);
// 2
ObString temp_string;
char * temp = "1234test_test_1234";
temp_string.assign(temp, strlen(temp));
obj.set_varchar(temp_string);
cell.value_ = obj;
EXPECT_TRUE(cells.append(cell, out_cell) == OB_SUCCESS);
// 3
EXPECT_TRUE(cells.append(cell, out_cell) == OB_SUCCESS);
// only one cell
EXPECT_TRUE(filter.check(cells, 0, 10, result) == OB_SUCCESS);
EXPECT_TRUE(result == true);
}
// first false
BLOCK_FUNC()
{
ObCellArray cells;
EXPECT_TRUE(cells.append(cell, out_cell) == OB_SUCCESS);
// 1
obj.set_int(23);
cell.value_ = obj;
EXPECT_TRUE(cells.append(cell, out_cell) == OB_SUCCESS);
// 2
ObString temp_string;
char * temp = "1234test_test_1234";
temp_string.assign(temp, strlen(temp));
obj.set_varchar(temp_string);
cell.value_ = obj;
EXPECT_TRUE(cells.append(cell, out_cell) == OB_SUCCESS);
// 3
EXPECT_TRUE(cells.append(cell, out_cell) == OB_SUCCESS);
EXPECT_TRUE(filter.check(cells, 0, 10, result) == OB_SUCCESS);
EXPECT_TRUE(result == false);
}
// second false
BLOCK_FUNC()
{
ObCellArray cells;
EXPECT_TRUE(cells.append(cell, out_cell) == OB_SUCCESS);
// 1
obj.set_int(22);
cell.value_ = obj;
EXPECT_TRUE(cells.append(cell, out_cell) == OB_SUCCESS);
// 2
ObString temp_string;
char * temp = "1234tes_est_1234";
temp_string.assign(temp, strlen(temp));
obj.set_varchar(temp_string);
cell.value_ = obj;
EXPECT_TRUE(cells.append(cell, out_cell) == OB_SUCCESS);
// 3
EXPECT_TRUE(cells.append(cell, out_cell) == OB_SUCCESS);
EXPECT_TRUE(filter.check(cells, 0, 10, result) == OB_SUCCESS);
EXPECT_TRUE(result == false);
}
// last false
BLOCK_FUNC()
{
ObCellArray cells;
EXPECT_TRUE(cells.append(cell, out_cell) == OB_SUCCESS);
// 1
obj.set_int(22);
cell.value_ = obj;
EXPECT_TRUE(cells.append(cell, out_cell) == OB_SUCCESS);
// 2
ObString temp_string;
char * temp = "1234test_test_1234";
temp_string.assign(temp, strlen(temp));
obj.set_varchar(temp_string);
cell.value_ = obj;
EXPECT_TRUE(cells.append(cell, out_cell) == OB_SUCCESS);
// 3
temp = "ztest";
temp_string.assign(temp, strlen(temp));
obj.set_varchar(temp_string);
cell.value_ = obj;
EXPECT_TRUE(cells.append(cell, out_cell) == OB_SUCCESS);
EXPECT_TRUE(filter.check(cells, 0, 10, result) == OB_SUCCESS);
EXPECT_TRUE(result == false);
}
// last error
BLOCK_FUNC()
{
ObCellArray cells;
EXPECT_TRUE(cells.append(cell, out_cell) == OB_SUCCESS);
// 1
obj.set_int(22);
cell.value_ = obj;
EXPECT_TRUE(cells.append(cell, out_cell) == OB_SUCCESS);
// 2
ObString temp_string;
char * temp = "1234test_test_1234";
temp_string.assign(temp, strlen(temp));
obj.set_varchar(temp_string);
cell.value_ = obj;
EXPECT_TRUE(cells.append(cell, out_cell) == OB_SUCCESS);
// 3
obj.set_int(32);
cell.value_ = obj;
EXPECT_TRUE(cells.append(cell, out_cell) == OB_SUCCESS);
result = true;
EXPECT_TRUE(filter.check(cells, 0, 1, result) != OB_SUCCESS);
EXPECT_TRUE(filter.check(cells, 0, 10, result) == OB_SUCCESS);
EXPECT_TRUE(result == false);
}
}
TEST_F(TestSimpleFilter, test_serialize)
{
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;
EXPECT_TRUE(filter.add_cond(2, operate, operand) == OB_SUCCESS);
operate = GE;
operand.set_int(23);
EXPECT_TRUE(filter.add_cond(1, operate, operand) == OB_SUCCESS);
operate = NE;
operand.set_varchar(sub_string);
EXPECT_TRUE(filter.add_cond(3, operate, operand) == OB_SUCCESS);
ObString column_name;
char name[1024] = "";
for (int64_t i = 0; i < 1; ++i)
{
snprintf(name, sizeof(name), "column_name_%ld", i);
column_name.assign(name, strlen(name));
EXPECT_TRUE(filter.add_cond(column_name, operate, operand) == OB_SUCCESS);
}
char buffer[1024];
int64_t pos = 0;
EXPECT_TRUE(filter.serialize(buffer, filter.get_serialize_size() - 1, pos) != OB_SUCCESS);
pos = 0;
EXPECT_TRUE(filter.serialize(buffer, filter.get_serialize_size(), pos) == OB_SUCCESS);
int64_t size = 0;
ObSimpleFilter filter1;
EXPECT_TRUE(filter1.deserialize(buffer, pos, size) == OB_SUCCESS);
EXPECT_TRUE(pos == size);
EXPECT_TRUE(filter1 == filter);
// add some much string
for (int64_t i = 10; i < 1024 * 1024L; ++i)
//for (int64_t i = 0; i < 1; ++i)
{
operate = NE;
snprintf(name, sizeof(name), "obj_value_%ld", i);
sub_string.assign(name, strlen(name));
operand.set_varchar(sub_string);
EXPECT_TRUE(filter.add_cond(i, operate, operand) == OB_SUCCESS);
}
char * temp_buffer = new char[filter.get_serialize_size()];
EXPECT_TRUE(NULL != temp_buffer);
pos = 0;
EXPECT_TRUE(filter.serialize(temp_buffer, filter.get_serialize_size(), pos) == OB_SUCCESS);
EXPECT_TRUE(pos == filter.get_serialize_size());
size = 0;
EXPECT_TRUE(filter1.deserialize(temp_buffer, filter.get_serialize_size(), size) == OB_SUCCESS);
EXPECT_TRUE(pos == size);
EXPECT_TRUE(filter1 == filter);
delete []temp_buffer;
temp_buffer = NULL;
}
void test_write_one_file()
{
ObSSTableSchemaColumnDef column_def;
ObSSTableSchema schema;
ObSSTableRow row;
char *compressor_name = (char*)COMPRESSOR_NAME;
ObSSTableWriter writer;
ObString file_name(static_cast<int32_t>(strlen(sstable_path) + 1),
static_cast<int32_t>(strlen(sstable_path) + 1), sstable_path);
ObString compressor(static_cast<int32_t>(strlen(compressor_name) + 1),
static_cast<int32_t>(strlen(compressor_name) + 1), compressor_name);
int64_t disk_usage = 0;
int64_t trailer_offset = 0;
ObObj obj;
ObObj key_obj;
uint64_t table_id = 0;
uint64_t column_group_id = 0;
char value_data[1024 + 1];
char rowkey_str[32];
ObString row_key;
ObRowkey key;
char *ptr;
int ret;
// 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();
// create sstable file
if (OB_ERROR == (ret = writer.create_sstable(schema, file_name,
compressor, 2)))
{
TBSYS_LOG(ERROR, "Failed to create sstable file: %s", sstable_path);
}
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, disk_usage)))
{
TBSYS_LOG(ERROR, "add row failed, i=%ld", i);
return;
}
}
if (OB_ERROR == (ret = writer.close_sstable(trailer_offset)))
{
TBSYS_LOG(ERROR, "close sstable failed ------------------");
}
printf("test_write_one_file, run_time=%ld\n",
tbsys::CTimeUtil::getTime() - start_time);
//remove(sstable_path);
}
int ObUpsFileTable::parse_line(const ObRow *&row)
{
int ret = OB_SUCCESS;
ObObj value;
int64_t int_value;
ObString str_value;
if (column_count_ + 1 == count_)
{
for (int32_t i=1;(OB_SUCCESS == ret) && i<count_;i++)
{
if( tokens_[0][0] == '-' )
{
curr_ups_row_.set_delete_row(true);
}
else
{
curr_ups_row_.set_delete_row(false);
}
if(0 == strcmp(tokens_[i], "NOP"))
{
value.set_ext(ObActionFlag::OP_NOP);
}
else
{
if(ObIntType == column_type_[i-1])
{
bool is_add = false;
if( tokens_[i][strlen(tokens_[i]) - 1] == '+' )
{
tokens_[i][strlen(tokens_[i]) - 1] = '\0';
is_add = true;
}
int_value = atoi(tokens_[i]);
value.set_int(int_value, is_add);
}
else if(ObVarcharType == column_type_[i-1])
{
str_value.assign_ptr(tokens_[i], strlen(tokens_[i]));
value.set_varchar(str_value);
}
else if(ObExtendType == column_type_[i-1])
{
value.set_ext(ObActionFlag::OP_DEL_ROW);
}
else
{
ret = OB_ERROR;
TBSYS_LOG(WARN, "unsupport type [%d]", column_type_[i-1]);
}
}
if(OB_SUCCESS == ret)
{
ret = curr_ups_row_.set_cell(table_id_, column_ids_[i-1], value);
}
}
}
else
{
ret = OB_ERROR;
TBSYS_LOG(WARN, "column_count_[%d], count_[%d], line_[%s]", column_count_, count_, line_);
}
if (OB_SUCCESS == ret)
{
row = &curr_ups_row_;
}
return ret;
}
TEST_F(TestSimpleFilter, test_add_cond)
{
ObLogicOperator operate = LIKE;
char * ptr = "test_test";
ObString sub_string;
sub_string.assign(ptr, strlen(ptr));
ObObj operand;
operand.set_varchar(sub_string);
int64_t count = 0;
ObSimpleFilter filter;
EXPECT_TRUE(filter.add_cond(2, operate, operand) == OB_SUCCESS);
++count;
const ObSimpleCond * cond = filter[1];
EXPECT_TRUE(cond == NULL);
cond = filter[0];
EXPECT_TRUE(cond != NULL);
EXPECT_TRUE(cond->get_column_index() == 2);
EXPECT_TRUE(cond->get_logic_operator() == operate);
EXPECT_TRUE(cond->get_right_operand() == operand);
operate = GE;
operand.set_int(23);
EXPECT_TRUE(filter.add_cond(1, operate, operand) == OB_SUCCESS);
++count;
// add some much string
for (int64_t i = 3; i < 1024 * 1024L; ++i)
{
operate = NE;
operand.set_varchar(sub_string);
EXPECT_TRUE(filter.add_cond(i, operate, operand) == OB_SUCCESS);
++count;
cond = filter[count - 1];
EXPECT_TRUE(cond != NULL);
EXPECT_TRUE(cond->get_column_index() == i);
EXPECT_TRUE(cond->get_logic_operator() == operate);
EXPECT_TRUE(cond->get_right_operand() == operand);
}
char name[1024] = "";
ObString column_name;
int64_t old_count = count;
for (int64_t i = count; i < 1024; ++i)
{
snprintf(name, sizeof(name), "column_%ld", i);
column_name.assign(name, strlen(name));
operand.set_varchar(sub_string);
EXPECT_TRUE(filter.add_cond(column_name, operate, operand) == OB_SUCCESS);
++count;
}
for (int64_t i = old_count; i < count; ++i)
{
cond = filter[i];
snprintf(name, sizeof(name), "column_%ld", i);
column_name.assign(name, strlen(name));
EXPECT_TRUE(cond != NULL);
EXPECT_TRUE(cond->get_column_name() == column_name);
EXPECT_TRUE(cond->get_column_index() == ObSimpleCond::INVALID_INDEX);
EXPECT_TRUE(cond->get_logic_operator() == operate);
EXPECT_TRUE(cond->get_right_operand() == operand);
}
filter.reset();
for (int64_t i = 0; i < 1024; ++i)
{
snprintf(name, sizeof(name), "column_%ld", i);
column_name.assign(name, strlen(name));
operand.set_varchar(sub_string);
EXPECT_TRUE(filter.add_cond(column_name, operate, operand) == OB_SUCCESS);
}
for (int64_t i = 0; i < 1024; ++i)
{
cond = filter[i];
snprintf(name, sizeof(name), "column_%ld", i);
column_name.assign(name, strlen(name));
EXPECT_TRUE(cond != NULL);
EXPECT_TRUE(cond->get_column_name() == column_name);
EXPECT_TRUE(cond->get_column_index() == ObSimpleCond::INVALID_INDEX);
EXPECT_TRUE(cond->get_logic_operator() == operate);
}
}
