int ObSystemConfigKey::set_int(const ObString &key, int64_t intval)
{
int ret = OB_SUCCESS;
if (key == ObString::make_string("cluster_id"))
{
cluster_id_ = intval;
}
else if (key == ObString::make_string("svr_port"))
{
server_port_ = intval;
}
else
{
ret = OB_INVALID_ARGUMENT;
TBSYS_LOG(ERROR, "unknow sys config column name: %.*s",
key.length(), key.ptr());
}
return ret;
}
int ObMetaTable3::get_table_schema(const ObString &tname, TableSchema &table_schema)
{
int ret = OB_SUCCESS;
if (OB_SUCCESS != (ret = schema_service_.get_table_schema(tname, table_schema)))
{
TBSYS_LOG(WARN, "failed to get table schema, err=%d", ret);
}
else if (TableSchema::META != table_schema.table_type_)
{
ret = OB_ERR_UNEXPECTED;
TBSYS_LOG(ERROR, "this table is not meta table, tname=%.*s type=%d",
tname.length(), tname.ptr(), table_schema.table_type_);
}
else if (0 >= table_schema.rowkey_column_num_)
{
ret = OB_ERR_UNEXPECTED;
TBSYS_LOG(ERROR, "BUG rowkey column num=%d", table_schema.rowkey_column_num_);
}
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;
}
int ObInnerTableOperator::update_all_trigger_event(ObString & sql, const int64_t timestamp,
const ObServer & server, const int64_t type, const int64_t param)
{
UNUSED(param);
int ret = OB_SUCCESS;
if ((sql.ptr() == NULL) || (0 == sql.size()))
{
TBSYS_LOG(WARN, "Check SQL buffer size failed! ptr[%p], size[%d]", sql.ptr(), sql.size());
ret = OB_INVALID_ARGUMENT;
}
else
{
char buf[OB_MAX_SERVER_ADDR_SIZE] = "";
if (server.ip_to_string(buf, sizeof(buf)) != true)
{
ret = OB_CONVERT_ERROR;
}
else
{
const char * format = "REPLACE INTO %s"
"(event_ts, src_ip, event_type, event_param) "
"values (%ld, '%s', %ld, %ld);";
int size = snprintf(sql.ptr(), sql.size(), format,
OB_ALL_TRIGGER_EVENT_TABLE_NAME, timestamp, buf, type, param);
if (size >= sql.size())
{
TBSYS_LOG(ERROR, "SQL buffer size not enough! size: [%d], need: [%d], sql: [%.*s]",
sql.size(), size, sql.length(), sql.ptr());
ret = OB_SIZE_OVERFLOW;
}
else
{
sql.assign_ptr(sql.ptr(), size);
}
}
}
return ret;
}
int ObInnerTableOperator::update_all_server(ObString & sql, const int64_t cluster_id,
const char * server_type, const ObServer & server, const uint32_t inner_port, const char * version)
{
int ret = OB_SUCCESS;
if ((sql.ptr() == NULL) || (0 == sql.size()))
{
TBSYS_LOG(WARN, "Check SQL buffer size failed! ptr[%p], size[%d]", sql.ptr(), sql.size());
ret = OB_INVALID_ARGUMENT;
}
else
{
char buf[OB_MAX_SERVER_ADDR_SIZE] = "";
if (server.ip_to_string(buf, sizeof(buf)) != true)
{
ret = OB_CONVERT_ERROR;
}
else
{
const char * format = "REPLACE INTO %s"
"(cluster_id, svr_type, svr_ip, svr_port, inner_port, svr_role, svr_version) "
"values (%d, '%s', '%s', %u, %u, %d, '%s');";
int size = snprintf(sql.ptr(), sql.size(), format, OB_ALL_SERVER, cluster_id,
server_type, buf, server.get_port(), inner_port, 0, version);
if (size >= sql.size())
{
TBSYS_LOG(ERROR, "SQL buffer size not enough! size: [%d], need: [%d], sql: [%.*s]",
sql.size(), size, sql.length(), sql.ptr());
ret = OB_SIZE_OVERFLOW;
}
else
{
sql.assign_ptr(sql.ptr(), size);
}
}
}
return ret;
}
static int get_table_id(ResultPlan* result_plan, const ObString &table_name, uint64_t &table_id)
{
int ret = OB_SUCCESS;
OB_ASSERT(NULL != result_plan);
ObLogicalPlan* logical_plan = static_cast<ObLogicalPlan*>(result_plan->plan_tree_);
ObSchemaChecker* schema_checker = static_cast<ObSchemaChecker*>(result_plan->schema_checker_);
if (logical_plan == NULL)
{
ret = OB_ERR_UNEXPECTED;
PARSER_LOG("unexpected branch, logical_plan is NULL");
}
else if (NULL == schema_checker)
{
ret = OB_ERR_SCHEMA_UNSET;
PARSER_LOG("unexpected branch, schema_checker is NULL");
}
else if (OB_INVALID_ID == (table_id = schema_checker->get_table_id(table_name)))
{
ret = OB_ERR_TABLE_UNKNOWN;
PARSER_LOG("Table `%.*s' does not exist", table_name.length(), table_name.ptr());
}
return ret;
}
int TaskFactory::init_new_task(const ObString & table_name, const ObRowkey & start_key,
const ObRowkey & end_key, ObScanParam & scan_param, TaskInfo & task) const
{
int ret = OB_SUCCESS;
if (!check_string(table_name))
{
TBSYS_LOG(WARN, "check table name or end key failed:name[%.*s]",
table_name.length(), table_name.ptr());
ret = OB_ERROR;
}
else
{
ObNewRange range;
range.border_flag_.unset_inclusive_start();
range.border_flag_.set_inclusive_end();
if (NULL == start_key.ptr())
{
range.border_flag_.set_min_value();
}
else
{
range.start_key_ = start_key;
range.border_flag_.unset_min_value();
}
range.border_flag_.unset_max_value();
range.end_key_ = end_key;
scan_param.set(OB_INVALID_ID, table_name, range);
// deep copy the param to task info param
ret = task.set_param(scan_param);
if (ret != OB_SUCCESS)
{
TBSYS_LOG(ERROR, "set param failed:ret[%d]", ret);
}
}
return ret;
}
int ObInnerTableOperator::delete_all_server(ObString & sql, const int64_t cluster_id,
const char * server_type, const ObServer & server)
{
int ret = OB_SUCCESS;
if ((sql.ptr() == NULL) || (0 == sql.size()))
{
TBSYS_LOG(WARN, "Check SQL buffer size failed! ptr[%p], size[%d]", sql.ptr(), sql.size());
ret = OB_INVALID_ARGUMENT;
}
else
{
char buf[OB_MAX_SERVER_ADDR_SIZE] = "";
if (server.ip_to_string(buf, sizeof (buf)) != true)
{
ret = OB_CONVERT_ERROR;
}
else
{
const char * format = "DELETE FROM %s WHERE cluster_id = %d AND svr_type = '%s' "
"AND svr_ip = '%s' AND svr_port = %u;";
int size = snprintf(sql.ptr(), sql.size(), format, OB_ALL_SERVER,
cluster_id, server_type, buf, server.get_port());
if (size >= sql.size())
{
TBSYS_LOG(ERROR, "SQL buffer size not enough! size: [%d], need: [%d], sql: [%.*s]",
sql.size(), size, sql.length(), sql.ptr());
ret = OB_SIZE_OVERFLOW;
}
else
{
sql.assign_ptr(sql.ptr(), size);
}
}
}
return ret;
}
void ObTabletJoinTest::test_big_data(ObTabletJoin &tablet_join)
{
system("python gen_test_data.py join");
ObTabletJoin::TableJoinInfo tablet_join_info;
tablet_join_info.left_table_id_ = LEFT_TABLE_ID;
tablet_join_info.right_table_id_ = RIGHT_TABLE_ID;
ObTabletJoin::JoinInfo join_info;
OK(tablet_join_info.join_condition_.push_back(1));
OK(read_join_info(tablet_join_info, "tablet_join_test_data/join_info.ini"));
tablet_join.set_table_join_info(tablet_join_info);
ObFakeUpsMultiGet fake_ups_multi_get("tablet_join_test_data/big_ups_scan2.ini");
ObFileTable result("tablet_join_test_data/big_result2.ini");
ObFakeSSTableScan sstable("tablet_join_test_data/big_sstable2.ini");
ObFakeUpsScan ups_scan("tablet_join_test_data/none_ups.ini");
ObTabletScanFuse tablet_fuse;
OK(tablet_fuse.set_sstable_scan(&sstable));
OK(tablet_fuse.set_incremental_scan(&ups_scan));
tablet_join.set_child(0, tablet_fuse);
tablet_join.set_batch_count(30000);
tablet_join.set_ups_multi_get(&fake_ups_multi_get);
OK(sstable.open());
OK(sstable.close());
uint64_t table_id = OB_INVALID_ID;
uint64_t column_id = OB_INVALID_ID;
const ObRowDesc *row_desc = NULL;
sstable.get_row_desc(row_desc);
for(int64_t i=0;i<row_desc->get_column_num();i++)
{
row_desc->get_tid_cid(i, table_id, column_id);
tablet_join.add_column_id(column_id);
}
ObGetParam get_param(true);
const ObRow *row = NULL;
const ObRow *result_row = NULL;
const ObObj *value = NULL;
const ObObj *result_value = NULL;
OK(result.open());
OK(tablet_join.open());
int err = OB_SUCCESS;
int64_t count = 0;
while(OB_SUCCESS == (err = tablet_join.get_next_row(row)))
{
OK(result.get_next_row(result_row));
count ++;
for(int64_t i=0;i<row->get_column_num();i++)
{
OK(row->raw_get_cell(i, value, table_id, column_id));
OK(result_row->get_cell(table_id, column_id, result_value));
if( *value != *result_value )
{
printf("row:[%ld], column[%ld]===========\n", count, i);
ObString rowkey;
get_rowkey(*row, rowkey);
printf("row rowkey: %.*s\n", rowkey.length(), rowkey.ptr());
printf("row: %s\n", print_obj(*value));
get_rowkey(*result_row, rowkey);
printf("result rowkey: %.*s\n", rowkey.length(), rowkey.ptr());
printf("result: %s\n", print_obj(*result_value));
}
ASSERT_TRUE((*value) == (*result_value));
}
}
ASSERT_TRUE(OB_SUCCESS == err || OB_ITER_END == err);
OK(result.close());
OK(tablet_join.close());
}
bool TaskFactory::check_string(const ObString & name)
{
return ((NULL != name.ptr()) && (0 != name.length()));
}
const char *print_obj(const ObObj &obj)
{
static __thread char buffer[1024 * 10];
switch (obj.get_type())
{
case ObNullType:
sprintf(buffer, "obj_type=null");
break;
case ObIntType:
{
bool is_add = false;
int64_t tmp = 0;
obj.get_int(tmp, is_add);
sprintf(buffer, "obj_type=int value=%ld is_add=%s", tmp, STR_BOOL(is_add));
}
break;
case ObFloatType:
{
bool is_add = false;
float tmp = 0.0;
obj.get_float(tmp, is_add);
sprintf(buffer, "obj_type=float value=%f is_add=%s", tmp, STR_BOOL(is_add));
}
break;
case ObDoubleType:
{
bool is_add = false;
double tmp = 0.0;
obj.get_double(tmp, is_add);
sprintf(buffer, "obj_type=double value=%lf is_add=%s", tmp, STR_BOOL(is_add));
}
break;
case ObDateTimeType:
{
bool is_add = false;
ObDateTime tmp;
obj.get_datetime(tmp, is_add);
sprintf(buffer, "obj_type=data_time value=%s is_add=%s", time2str(tmp), STR_BOOL(is_add));
}
break;
case ObPreciseDateTimeType:
{
bool is_add = false;
ObDateTime tmp;
obj.get_precise_datetime(tmp, is_add);
sprintf(buffer, "obj_type=precise_data_time value=%s is_add=%s", time2str(tmp), STR_BOOL(is_add));
}
break;
case ObVarcharType:
{
ObString tmp;
obj.get_varchar(tmp);
sprintf(buffer, "obj_type=var_char value=[%.*s]", tmp.length(), tmp.ptr());
}
break;
case ObSeqType:
{
sprintf(buffer, "obj_type=seq");
}
break;
case ObCreateTimeType:
{
ObCreateTime tmp = 0;
obj.get_createtime(tmp);
snprintf(buffer, BUFFER_SIZE, "obj_type=create_time value=%s", time2str(tmp));
}
break;
case ObModifyTimeType:
{
ObModifyTime tmp = 0;
obj.get_modifytime(tmp);
snprintf(buffer, BUFFER_SIZE, "obj_type=modify_time value=%s", time2str(tmp));
}
break;
case ObExtendType:
{
int64_t tmp = 0;
obj.get_ext(tmp);
sprintf(buffer, "obj_type=extend value=%ld", tmp);
}
break;
default:
break;
}
return buffer;
}
int ObAlterSysCnf::open()
{
int ret = OB_SUCCESS;
if (sys_cnf_items_.count() <= 0)
{
ret = OB_NOT_INIT;
TBSYS_LOG(USER_ERROR, "No param to be changed, ret=%d", ret);
}
else if ((local_context_.schema_manager_ =
local_context_.merger_schema_mgr_->get_user_schema(0)) == NULL)
{
ret = OB_ERROR;
TBSYS_LOG(USER_ERROR, "Fail to get schema manager, ret=%d", ret);
}
else if ((ret = execute_transaction_stmt(START_TRANSACTION)) != OB_SUCCESS)
{
TBSYS_LOG(WARN, "Start transaction failed, ret=%d", ret);
}
else
{
for (int64_t i = 0; i < sys_cnf_items_.count(); i++)
{
ObSysCnfItem& cnf_item = sys_cnf_items_.at(i);
if (cnf_item.server_ip_.length() > 15)
{
ret = OB_ERROR;
TBSYS_LOG(USER_ERROR, "Invalid server ip: %.*s",
cnf_item.server_ip_.length(), cnf_item.server_ip_.ptr());
break;
}
else if (cnf_item.server_ip_.length() > 0)
{
// check ip address
uint32_t ip = 0;
char buf[16];
memcpy(buf, cnf_item.server_ip_.ptr(), cnf_item.server_ip_.length());
buf[cnf_item.server_ip_.length()] = '\0';
if ((ip = inet_addr(buf)) == INADDR_NONE)
{
ret = OB_ERROR;
TBSYS_LOG(USER_ERROR, "Invalid server ip: %.*s",
cnf_item.server_ip_.length(), cnf_item.server_ip_.ptr());
break;
}
}
else
{
cnf_item.server_ip_ = ObString::make_string("ANY"); // @see
}
/**
mysql> desc __all_sys_config;
+--------------+--------------+----------+------+---------+-------+
| field | type | nullable | key | default | extra |
+--------------+--------------+----------+------+---------+-------+
| gm_create | createtime | | 0 | NULL | |
| gm_modify | modifytime | | 0 | NULL | |
| cluster_id | int | | 1 | NULL | |
| svr_type | varchar(16) | | 2 | NULL | |
| svr_ip | varchar(32) | | 3 | NULL | |
| svr_port | int | | 4 | NULL | |
| name | varchar(256) | | 5 | NULL | |
| section | varchar(256) | | 0 | NULL | |
| data_type | varchar(256) | | 0 | NULL | |
| value | varchar(256) | | 0 | NULL | |
| value_strict | varchar(512) | | 0 | NULL | |
| info | varchar(512) | | 0 | NULL | |
+--------------+--------------+----------+------+---------+-------+
*/
int64_t pos = 0;
char sql_buff[OB_MAX_VARCHAR_LENGTH];
databuff_printf(sql_buff, OB_MAX_VARCHAR_LENGTH, pos,
"replace into %s"
"(cluster_id, svr_type, svr_ip, "
"svr_port, name, section, data_type, "
"value, value_strict, info) "
"values(%lu, '%s', '%.*s', %lu, '%.*s', 'unknown', '%s', '",
OB_ALL_SYS_CONFIG_TABLE_NAME,
cnf_item.cluster_id_ != OB_INVALID_ID ? cnf_item.cluster_id_ : 0,
print_role(cnf_item.server_type_),
cnf_item.server_ip_.length(), cnf_item.server_ip_.ptr(),
cnf_item.server_port_ != OB_INVALID_ID ? cnf_item.server_port_ : 0,
cnf_item.param_name_.length(), cnf_item.param_name_.ptr(),
ob_obj_type_str(cnf_item.param_value_.get_type()));
if (cnf_item.param_value_.get_type() == ObNullType)
{
databuff_printf(sql_buff, OB_MAX_VARCHAR_LENGTH, pos, "NULL");
}
else
{
char varchar_buf[OB_MAX_VARCHAR_LENGTH];
ObString varchar(OB_MAX_VARCHAR_LENGTH, OB_MAX_VARCHAR_LENGTH, varchar_buf);
ObObj casted_cell;
casted_cell.set_varchar(varchar);
const ObObj *res_value = NULL;
ObObj data_type;
data_type.set_type(ObVarcharType);
ObString val;
if ((ret = obj_cast(cnf_item.param_value_, data_type, casted_cell, res_value)) != OB_SUCCESS)
{
TBSYS_LOG(WARN, "Fail to cast obj, err=%d", ret);
break;
}
else if ((ret = res_value->get_varchar(val)) != OB_SUCCESS)
{
TBSYS_LOG(WARN, "Get casted value failed, err=%d", ret);
break;
}
databuff_printf(sql_buff, OB_MAX_VARCHAR_LENGTH, pos, "%.*s", val.length(), val.ptr());
}
databuff_printf(sql_buff, OB_MAX_VARCHAR_LENGTH, pos, "', 'unknown', '%.*s')",
cnf_item.comment_.length(), cnf_item.comment_.ptr());
ObString sql_string(OB_MAX_VARCHAR_LENGTH, static_cast<int32_t>(pos), sql_buff);
ObResultSet tmp_result;
if (OB_SUCCESS != (ret = tmp_result.init()))
{
TBSYS_LOG(WARN, "Init temp result set failed, ret=%d", ret);
}
else if (OB_SUCCESS != (ret = ObSql::direct_execute(sql_string, tmp_result, local_context_)))
{
TBSYS_LOG(USER_ERROR, "Direct_execute failed, sql=%.*s ret=%d",
sql_string.length(), sql_string.ptr(), ret);
break;
}
else if (OB_SUCCESS != (ret = tmp_result.open()))
{
TBSYS_LOG(WARN, "Open result set failed, sql=%.*s ret=%d",
sql_string.length(), sql_string.ptr(), ret);
break;
}
else
{
/*
if (tmp_result.get_affected_rows() <= 0)
{
TBSYS_LOG(WARN, "Fail to update param %.*s, sql=%.*s",
cnf_item.param_name_.length(), cnf_item.param_name_.ptr(),
sql_string.length(), sql_string.ptr());
}
*/
if ((ret = tmp_result.close()) != OB_SUCCESS)
{
TBSYS_LOG(WARN, "Failed to close temp result set, sql=%.*s ret=%d",
sql_string.length(), sql_string.ptr(), ret);
break;
}
}
}
if (ret == OB_SUCCESS)
{
if ((ret = execute_transaction_stmt(COMMIT)) != OB_SUCCESS)
{
TBSYS_LOG(WARN, "Commit transaction failed, ret=%d", ret);
}
else
{
// notify all servers to update config
ObResultSet tmp_result;
if (OB_SUCCESS != (ret = tmp_result.init()))
{
TBSYS_LOG(WARN, "Init temp result set failed, ret=%d", ret);
}
else if (OB_SUCCESS != (ret = ObDirectTriggerEventUtil::refresh_new_config(tmp_result, local_context_)))
{
TBSYS_LOG(ERROR, "fail to refresh new config. ret=%d", ret);
}
// to release resouce, call open & close
else if (OB_SUCCESS != (ret = tmp_result.open()))
{
TBSYS_LOG(WARN, "fail to open tmp result. ret=%d", ret);
}
else if (OB_SUCCESS != (ret = tmp_result.close()))
{
TBSYS_LOG(WARN, "fail to close tmp result. ret=%d", ret);
}
}
}
else
{
if (execute_transaction_stmt(ROLLBACK) != OB_SUCCESS)
{
TBSYS_LOG(WARN, "Rollback transaction failed");
}
}
}
if (local_context_.schema_manager_ != NULL)
{
local_context_.merger_schema_mgr_->release_schema(local_context_.schema_manager_);
local_context_.schema_manager_ = NULL;
}
return ret;
}
int ObSelectStmt::check_having_ident(
ResultPlan& result_plan,
ObString& column_name,
TableItem* table_item,
ObRawExpr*& ret_expr) const
{
ObSqlRawExpr *sql_expr;
ObRawExpr *expr;
ret_expr = NULL;
int& ret = result_plan.err_stat_.err_code_ = OB_SUCCESS;
ObLogicalPlan* logical_plan = static_cast<ObLogicalPlan*>(result_plan.plan_tree_);
if (logical_plan == NULL)
{
ret = OB_ERR_LOGICAL_PLAN_FAILD;
snprintf(result_plan.err_stat_.err_msg_, MAX_ERROR_MSG,
"Wrong invocation of ObStmt::add_table_item, logical_plan must exist!!!");
}
ObSchemaChecker* schema_checker = NULL;
if (ret == OB_SUCCESS)
{
schema_checker = static_cast<ObSchemaChecker*>(result_plan.schema_checker_);
if (schema_checker == NULL)
{
ret = OB_ERR_SCHEMA_UNSET;
snprintf(result_plan.err_stat_.err_msg_, MAX_ERROR_MSG,
"Schema(s) are not set");
}
}
for (int32_t i = 0; ret == OB_SUCCESS && i < select_items_.size(); i++)
{
const SelectItem& select_item = get_select_item(i);
// for single column expression, we already set it as alias name
if (column_name == select_item.alias_name_)
{
sql_expr = logical_plan->get_expr(select_item.expr_id_);
expr = sql_expr->get_expr();
if (table_item)
{
if (expr->get_expr_type() == T_REF_COLUMN)
{
ObBinaryRefRawExpr* col_expr = dynamic_cast<ObBinaryRefRawExpr *>(expr);
if (col_expr && col_expr->get_first_ref_id() == table_item->table_id_)
{
ColumnItem* column_item = get_column_item_by_id(col_expr->get_first_ref_id(), col_expr->get_second_ref_id());
if (column_item && column_item->column_name_ == column_name)
{
ObBinaryRefRawExpr *b_expr = (ObBinaryRefRawExpr*)parse_malloc(sizeof(ObBinaryRefRawExpr), name_pool_);
b_expr = new(b_expr) ObBinaryRefRawExpr();
b_expr->set_expr_type(T_REF_COLUMN);
b_expr->set_first_ref_id(col_expr->get_first_ref_id());
b_expr->set_second_ref_id(col_expr->get_second_ref_id());
ret_expr = b_expr;
break;
}
}
}
}
else
{
if (ret_expr)
{
ret = OB_ERR_COLUMN_AMBIGOUS;
snprintf(result_plan.err_stat_.err_msg_, MAX_ERROR_MSG,
"column %.*s of having clause is ambiguous", column_name.length(), column_name.ptr());
parse_free(ret_expr);
ret_expr = NULL;
break;
}
// for having clause: having cc > 0
// type 1: select t1.cc
if (expr->get_expr_type() == T_REF_COLUMN && !select_item.is_real_alias_)
{
ObBinaryRefRawExpr *col_expr = dynamic_cast<ObBinaryRefRawExpr *>(expr);
ObBinaryRefRawExpr *b_expr = (ObBinaryRefRawExpr*)parse_malloc(sizeof(ObBinaryRefRawExpr), name_pool_);
b_expr = new(b_expr) ObBinaryRefRawExpr();
b_expr->set_expr_type(T_REF_COLUMN);
b_expr->set_first_ref_id(col_expr->get_first_ref_id());
b_expr->set_second_ref_id(col_expr->get_second_ref_id());
ret_expr = b_expr;
}
// type 2: select t1.cc as cc
// type 3: select t1.c1 as cc
// type 4: select t1.c1 + t2.c1 as cc
else
{
ObBinaryRefRawExpr *b_expr = (ObBinaryRefRawExpr*)parse_malloc(sizeof(ObBinaryRefRawExpr), name_pool_);
b_expr = new(b_expr) ObBinaryRefRawExpr();
b_expr->set_expr_type(T_REF_COLUMN);
b_expr->set_first_ref_id(OB_INVALID_ID);
b_expr->set_second_ref_id(sql_expr->get_column_id());
ret_expr = b_expr;
}
}
}
}
// No non-duplicated ident found
if (ret == OB_SUCCESS && ret_expr == NULL)
{
for (int32_t i = 0; ret == OB_SUCCESS && i < group_expr_ids_.size(); i++)
{
sql_expr = logical_plan->get_expr(group_expr_ids_[i]);
expr = sql_expr->get_expr();
//ObRawExpr* expr = logical_plan->get_expr(group_expr_ids_[i])->get_expr();
if (expr->get_expr_type() != T_REF_COLUMN)
continue;
ObBinaryRefRawExpr* col_expr = dynamic_cast<ObBinaryRefRawExpr *>(expr);
// Only need to check original columns, alias columns are already checked before
if (table_item == NULL || table_item->table_id_ == col_expr->get_first_ref_id())
{
ColumnItem* column_item = get_column_item_by_id(
col_expr->get_first_ref_id(),
col_expr->get_second_ref_id());
if (column_item && column_name == column_item->column_name_)
{
ObBinaryRefRawExpr *b_expr = (ObBinaryRefRawExpr*)parse_malloc(sizeof(ObBinaryRefRawExpr), name_pool_);
b_expr = new(b_expr) ObBinaryRefRawExpr();
b_expr->set_expr_type(T_REF_COLUMN);
b_expr->set_first_ref_id(column_item->table_id_);
b_expr->set_second_ref_id(column_item->column_id_);
ret_expr = b_expr;
break;
}
}
}
}
if (ret == OB_SUCCESS && ret_expr == NULL)
{
ret = OB_ERR_COLUMN_UNKNOWN;
snprintf(result_plan.err_stat_.err_msg_, MAX_ERROR_MSG,
"Unknown %.*s in having clause", column_name.length(), column_name.ptr());
}
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());
}
TEST(TestMemTable, trans_set)
{
MemTable mt;
mt.init();
PageArena<char> allocer;
ObUpsMutator ups_mutator;
//ObMutator &mutator = ups_mutator.get_mutator();
ObMutator result;
ObScanParam scan_param;
read_scan_param("test_cases/test_mt_set.scan.ini", "MT_SET_SCAN", allocer, scan_param);
MemTableTransDescriptor td;
EXPECT_EQ(OB_SUCCESS, mt.start_transaction(WRITE_TRANSACTION, td));
EXPECT_NE(OB_SUCCESS, mt.start_transaction(WRITE_TRANSACTION, td));
_US_
// case begin
// 对于hash engine，测试在已经有rowkey A 的情况下，开一个事务按A B A的顺序写入，在结束事务的时候是否正常
// 避免出现结束事务时引用的rowkey是mutator临时申请的
ObUpsMutator ups_mutator;
ObMutator &mutator = ups_mutator.get_mutator();
ObMutator result;
read_cell_infos("test_cases/test_mt_set_unsorted.ci.ini", "MT_SET_UNSORTED_CI", allocer, mutator, result);
EXPECT_EQ(OB_SUCCESS, mt.start_mutation(td));
EXPECT_EQ(OB_SUCCESS, mt.set(td, ups_mutator));
EXPECT_EQ(OB_SUCCESS, mt.end_mutation(td, false));
EXPECT_EQ(OB_SUCCESS, mt.end_transaction(td, false));
EXPECT_EQ(OB_SUCCESS, mt.start_transaction(WRITE_TRANSACTION, td));
EXPECT_EQ(OB_SUCCESS, mt.start_mutation(td));
EXPECT_EQ(OB_SUCCESS, mt.set(td, ups_mutator));
// 此处模拟mutator被析构或重置
while (OB_SUCCESS == mutator.next_cell())
{
ObMutatorCellInfo *mutator_ci = NULL;
if (OB_SUCCESS == mutator.get_cell(&mutator_ci))
{
ObString rk = mutator_ci->cell_info.row_key_;
memset(rk.ptr(), 0, rk.length());
}
}
mutator.reset_iter();
EXPECT_EQ(OB_SUCCESS, mt.end_mutation(td, false));
EXPECT_EQ(OB_SUCCESS, mt.end_transaction(td, false));
mutator.reset();
result.reset();
read_cell_infos("test_cases/test_mt_ret_unsorted.ci.ini", "MT_RET_UNSORTED_CI", allocer, mutator, result);
MemTableIterator iter;
EXPECT_EQ(OB_SUCCESS, mt.start_transaction(READ_TRANSACTION, td));
EXPECT_EQ(OB_SUCCESS, mt.scan(td, *(scan_param.get_range()), false, iter));
ObRowCompaction rc;
rc.set_iterator(&iter);
while (OB_SUCCESS == result.next_cell())
{
ObMutatorCellInfo *ci_orig = NULL;
ObCellInfo *ci_scan = NULL;
EXPECT_EQ(OB_SUCCESS, rc.next_cell());
EXPECT_EQ(OB_SUCCESS, rc.get_cell(&ci_scan));
if (ObModifyTimeType == ci_scan->value_.get_type())
{
EXPECT_EQ(OB_SUCCESS, rc.next_cell());
EXPECT_EQ(OB_SUCCESS, rc.get_cell(&ci_scan));
}
if (ObCreateTimeType == ci_scan->value_.get_type())
{
EXPECT_EQ(OB_SUCCESS, rc.next_cell());
EXPECT_EQ(OB_SUCCESS, rc.get_cell(&ci_scan));
}
result.get_cell(&ci_orig);
EXPECT_EQ(true, equal(ci_orig->cell_info, *ci_scan));
}
EXPECT_EQ(OB_SUCCESS, mt.end_transaction(td, false));
mt.clear();
_UE_
// case end
EXPECT_EQ(OB_SUCCESS, mt.start_transaction(WRITE_TRANSACTION, td));
EXPECT_EQ(OB_SUCCESS, mt.start_mutation(td));
EXPECT_EQ(OB_SUCCESS, mt.set(td, ups_mutator));
// 事务没有提交，scan结果应该为空
_US_
MemTableTransDescriptor td;
MemTableIterator iter;
EXPECT_EQ(OB_SUCCESS, mt.start_transaction(READ_TRANSACTION, td));
_US_
MemTableTransDescriptor td;
EXPECT_EQ(OB_SUCCESS, mt.start_transaction(READ_TRANSACTION, td));
EXPECT_EQ(OB_SUCCESS, mt.end_transaction(td, false));
_UE_
EXPECT_EQ(OB_SUCCESS, mt.scan(td, *(scan_param.get_range()), false, iter));
EXPECT_EQ(OB_SUCCESS, mt.end_transaction(td, false));
EXPECT_EQ(OB_ITER_END, iter.next_cell());
_UE_
EXPECT_EQ(OB_SUCCESS, mt.end_mutation(td, false));
EXPECT_EQ(OB_SUCCESS, mt.end_transaction(td, false));
ObUpsMutator ups_mutator2;
ObMutator &mutator2 = ups_mutator2.get_mutator();
ObMutator result2;
read_cell_infos("test_cases/test_mt_trans_set.ci.ini", "MT_TRANS_SET_CI", allocer, mutator2, result2);
ups_mutator2.set_mutate_timestamp(tbsys::CTimeUtil::getTime());
EXPECT_EQ(OB_ERROR, mt.set(td, ups_mutator2));
EXPECT_EQ(OB_SUCCESS, mt.start_transaction(WRITE_TRANSACTION, td));
EXPECT_EQ(OB_SUCCESS, mt.start_mutation(td));
EXPECT_EQ(OB_SUCCESS, mt.set(td, ups_mutator2));
// 只能scan到第一个事务的结果
_US_
MemTableTransDescriptor td;
MemTableIterator iter;
EXPECT_EQ(OB_SUCCESS, mt.start_transaction(READ_TRANSACTION, td));
EXPECT_EQ(OB_SUCCESS, mt.scan(td, *(scan_param.get_range()), false, iter));
ObRowCompaction rc;
rc.set_iterator(&iter);
result.reset_iter();
while (OB_SUCCESS == result.next_cell())
{
ObMutatorCellInfo *ci_orig = NULL;
ObCellInfo *ci_scan = NULL;
EXPECT_EQ(OB_SUCCESS, rc.next_cell());
EXPECT_EQ(OB_SUCCESS, rc.get_cell(&ci_scan));
if (ObModifyTimeType == ci_scan->value_.get_type())
{
EXPECT_EQ(OB_SUCCESS, rc.next_cell());
EXPECT_EQ(OB_SUCCESS, rc.get_cell(&ci_scan));
}
if (ObCreateTimeType == ci_scan->value_.get_type())
{
EXPECT_EQ(OB_SUCCESS, rc.next_cell());
EXPECT_EQ(OB_SUCCESS, rc.get_cell(&ci_scan));
}
result.get_cell(&ci_orig);
EXPECT_EQ(true, equal(ci_orig->cell_info, *ci_scan));
}
EXPECT_EQ(OB_SUCCESS, mt.end_transaction(td));
_UE_
// 第二个事务提交后可以看到全部结果
EXPECT_EQ(OB_SUCCESS, mt.end_mutation(td, false));
EXPECT_EQ(OB_SUCCESS, mt.end_transaction(td, false));
_US_
MemTableTransDescriptor td;
ObUpsMutator ups_mutator;
ObMutator &mutator = ups_mutator.get_mutator();
ObMutator result;
read_cell_infos("test_cases/test_mt_trans_set.ret.ini", "MT_TRANS_SET_RET", allocer, mutator, result);
MemTableIterator iter;
EXPECT_EQ(OB_SUCCESS, mt.start_transaction(READ_TRANSACTION, td));
EXPECT_EQ(OB_SUCCESS, mt.scan(td, *(scan_param.get_range()), false, iter));
ObRowCompaction rc;
rc.set_iterator(&iter);
while (OB_SUCCESS == result.next_cell())
{
ObMutatorCellInfo *ci_orig = NULL;
ObCellInfo *ci_scan = NULL;
EXPECT_EQ(OB_SUCCESS, rc.next_cell());
EXPECT_EQ(OB_SUCCESS, rc.get_cell(&ci_scan));
if (ObModifyTimeType == ci_scan->value_.get_type())
{
EXPECT_EQ(OB_SUCCESS, rc.next_cell());
EXPECT_EQ(OB_SUCCESS, rc.get_cell(&ci_scan));
}
if (ObCreateTimeType == ci_scan->value_.get_type())
{
EXPECT_EQ(OB_SUCCESS, rc.next_cell());
EXPECT_EQ(OB_SUCCESS, rc.get_cell(&ci_scan));
}
result.get_cell(&ci_orig);
EXPECT_EQ(true, equal(ci_orig->cell_info, *ci_scan));
}
EXPECT_EQ(OB_SUCCESS, mt.end_transaction(td));
_UE_
// 第三个事务被会滚 看到的结果与第二个一样
ObUpsMutator ups_mutator3;
ObUpsMutator ups_result3;
ObMutator &mutator3 = ups_mutator3.get_mutator();
ObMutator &result3 = ups_result3.get_mutator();
read_cell_infos("test_cases/test_mt_trans_set.ci.ini", "MT_TRANS_SET_CI", allocer, mutator3, result3);
EXPECT_EQ(OB_ERROR, mt.set(td, ups_mutator3));
EXPECT_EQ(OB_SUCCESS, mt.start_transaction(WRITE_TRANSACTION, td));
EXPECT_EQ(OB_SUCCESS, mt.start_mutation(td));
EXPECT_EQ(OB_SUCCESS, mt.set(td, ups_mutator3));
EXPECT_EQ(OB_SUCCESS, mt.end_mutation(td, true));
EXPECT_EQ(OB_SUCCESS, mt.end_transaction(td, true));
_US_
MemTableTransDescriptor td;
ObUpsMutator ups_mutator;
ObMutator &mutator = ups_mutator.get_mutator();
ObMutator result;
read_cell_infos("test_cases/test_mt_trans_set.ret.ini", "MT_TRANS_SET_RET", allocer, mutator, result);
MemTableIterator iter;
EXPECT_EQ(OB_SUCCESS, mt.start_transaction(READ_TRANSACTION, td));
EXPECT_EQ(OB_SUCCESS, mt.scan(td, *(scan_param.get_range()), false, iter));
ObRowCompaction rc;
rc.set_iterator(&iter);
while (OB_SUCCESS == result.next_cell())
{
ObMutatorCellInfo *ci_orig = NULL;
ObCellInfo *ci_scan = NULL;
EXPECT_EQ(OB_SUCCESS, rc.next_cell());
EXPECT_EQ(OB_SUCCESS, rc.get_cell(&ci_scan));
if (ObModifyTimeType == ci_scan->value_.get_type())
{
EXPECT_EQ(OB_SUCCESS, rc.next_cell());
EXPECT_EQ(OB_SUCCESS, rc.get_cell(&ci_scan));
}
if (ObCreateTimeType == ci_scan->value_.get_type())
{
EXPECT_EQ(OB_SUCCESS, rc.next_cell());
EXPECT_EQ(OB_SUCCESS, rc.get_cell(&ci_scan));
}
result.get_cell(&ci_orig);
EXPECT_EQ(true, equal(ci_orig->cell_info, *ci_scan));
}
EXPECT_EQ(OB_SUCCESS, mt.end_transaction(td));
_UE_
mt.destroy();
}
uint64_t ObMetaTableColumnSchema::get_cid(const CF cf, const int32_t i) const
{
uint64_t ret = OB_INVALID_ID;
if (i >= ObTabletMetaTableRow::MAX_REPLICA_COUNT || 0 > i)
{
TBSYS_LOG(ERROR, "BUG invalid index, i=%d", i);
}
else
{
ObString cname;
const int buf_len = meta_table_cname::STARTKEY_OBJ_PREFIX.length() + 8;
char cname_buf[buf_len];
cname_buf[0] = '\0';
int print_len = 0;
switch(cf)
{
case CF_TID:
cname = COLUMNS_NAME[CIDX_TID];
break;
case CF_VERSION:
cname = COLUMNS_NAME[CIDX_REPLICA1_VERSION + i * COLUMNS_PER_REPLICA];
break;
case CF_CHECKSUM:
cname = COLUMNS_NAME[CIDX_REPLICA1_CHECKSUM + i * COLUMNS_PER_REPLICA];
break;
case CF_ROW_COUNT:
cname = COLUMNS_NAME[CIDX_REPLICA1_ROW_COUNT + i * COLUMNS_PER_REPLICA];
break;
case CF_SIZE:
cname = COLUMNS_NAME[CIDX_REPLICA1_SIZE + i * COLUMNS_PER_REPLICA];
break;
case CF_IPV4:
cname = COLUMNS_NAME[CIDX_REPLICA1_IPV4 + i * COLUMNS_PER_REPLICA];
break;
case CF_IPV6_HIGH:
cname = COLUMNS_NAME[CIDX_REPLICA1_IPV6_HIGH + i * COLUMNS_PER_REPLICA];
break;
case CF_IPV6_LOW:
cname = COLUMNS_NAME[CIDX_REPLICA1_IPV6_LOW + i * COLUMNS_PER_REPLICA];
break;
case CF_PORT:
cname = COLUMNS_NAME[CIDX_REPLICA1_IP_PORT + i * COLUMNS_PER_REPLICA];
break;
case CF_STARTKEY_COL:
print_len = snprintf(cname_buf, buf_len, "%.*s%d", meta_table_cname::STARTKEY_OBJ_PREFIX.length(),
meta_table_cname::STARTKEY_OBJ_PREFIX.ptr(), i + 1);
cname.assign_ptr(cname_buf, print_len);
break;
default:
TBSYS_LOG(ERROR, "BUG invalid meta table column, cf=%d", cf);
break;
} // end switch
if (OB_SUCCESS != get_cid_by_name(cname, ret))
{
TBSYS_LOG(ERROR, "meta table column not found, cname=%.*s tid=%lu",
cname.length(), cname.ptr(), table_schema_.table_id_);
}
}
return ret;
}
uint64_t ObStringSearch::cal_print(const ObString & pattern)
{
const char* pat = pattern.ptr();
const int64_t pat_len = pattern.length();
return cal_print(pat, pat_len);
}
bool check_result(const ObScanParam &scan_param, ObScanner &ob_scanner,
ObFinalResult & local_result)
{
int err = OB_SUCCESS;
bool res = true;
ObScanner local_scanner;
ObCellInfo *ob_cell = NULL;
ObCellInfo *local_cell = NULL;
err = local_result.scan(scan_param,local_scanner);
if (OB_SUCCESS != err)
{
TBSYS_LOG(WARN,"fail to scan local result");
}
int64_t row_number = 0;
bool ob_end = false;
ObString rowkey;
while (OB_SUCCESS == err)
{
for (int64_t scan_idx = 0; scan_idx < scan_param.get_column_name_size(); scan_idx ++)
{
if (OB_SUCCESS == err)
{
err = ob_scanner.next_cell();
}
if (OB_ITER_END == err && scan_idx == 0)
{
ob_end = true;
err = OB_SUCCESS;
}
else if (OB_SUCCESS == err)
{
err = ob_scanner.get_cell(&ob_cell);
}
if (OB_SUCCESS != err)
{
TBSYS_LOG(WARN,"fail to get cell from ob result [row_idx:%lld,idx:%lld]",
row_number, scan_idx);
}
if (OB_SUCCESS == err)
{
err = local_scanner.next_cell();
if (ob_end && OB_ITER_END != err)
{
TBSYS_LOG(WARN,"local result return more cells than ob result");
err = OB_INVALID_ARGUMENT;
}
if ( !ob_end && OB_ITER_END == err)
{
TBSYS_LOG(WARN,"ob result return more cells than local result");
err = OB_INVALID_ARGUMENT;
}
if (ob_end && OB_ITER_END == err)
{
err = OB_ITER_END;
break;
}
if (OB_SUCCESS == err)
{
err = local_scanner.get_cell(&local_cell);
}
if (OB_SUCCESS != err)
{
TBSYS_LOG(WARN,"fail to get cell from local result [row_idx:%lld,idx:%lld]",
row_number, scan_idx);
}
}
if (OB_SUCCESS == err)
{
if (0 == scan_idx)
{
rowkey = ob_cell->row_key_;
}
/// check ob result
if (ob_cell->table_name_ != scan_param.get_table_name())
{
TBSYS_LOG(WARN,"ob result table name error [row_idx:%lld,idx:%lld,ob.table_name_:%.*s,"
"param.table_name_:%.*s]", row_number, scan_idx,ob_cell->table_name_.length(),
ob_cell->table_name_.ptr(), scan_param.get_table_name().length(),
scan_param.get_table_name().ptr());
err = OB_INVALID_ARGUMENT;
}
if (ob_cell->column_name_ != scan_param.get_column_name()[scan_idx])
{
TBSYS_LOG(WARN,"ob result rowkey error [row_idx:%lld,idx:%lld,ob.column_name_:%.*s,"
"param.column_name_:%.*s]", row_number, scan_idx,ob_cell->column_name_.length(),
ob_cell->column_name_.ptr(), scan_param.get_column_name()[scan_idx].length(),
scan_param.get_column_name()[scan_idx].ptr());
err = OB_INVALID_ARGUMENT;
}
/// check local result
if (local_cell->table_name_ != scan_param.get_table_name())
{
TBSYS_LOG(WARN,"ob result table name error [row_idx:%lld,idx:%lld,ob.table_name_:%.*s,"
"param.table_name_:%.*s]", row_number, scan_idx,local_cell->table_name_.length(),
local_cell->table_name_.ptr(), scan_param.get_table_name().length(),
scan_param.get_table_name().ptr());
err = OB_INVALID_ARGUMENT;
}
if (local_cell->column_name_ != scan_param.get_column_name()[scan_idx])
{
TBSYS_LOG(WARN,"ob result rowkey error [row_idx:%lld,idx:%lld,ob.column_name_:%.*s,"
"param.column_name_:%.*s]", row_number,scan_idx,local_cell->column_name_.length(),
local_cell->column_name_.ptr(), scan_param.get_column_name()[scan_idx].length(),
scan_param.get_column_name()[scan_idx].ptr());
err = OB_INVALID_ARGUMENT;
}
if (local_cell->row_key_ != ob_cell->row_key_)
{
TBSYS_LOG(WARN,"rowkey error [row_idx:%lld,idx:%lld,ob.row_key_:%.*s,"
"local.row_key_:%.*s]", row_number, scan_idx,ob_cell->row_key_.length(),
ob_cell->row_key_.ptr(), local_cell->row_key_.length(),
local_cell->row_key_.ptr());
err = OB_INVALID_ARGUMENT;
}
if (local_cell->row_key_ != rowkey)
{
TBSYS_LOG(WARN,"rowkey error [row_idx:%lld,idx:%lld,ob.row_key_:%.*s,"
"row_first_cell.row_key_:%.*s]", row_number,scan_idx,local_cell->row_key_.length(),
local_cell->row_key_.ptr(), rowkey.length(), rowkey.ptr());
err = OB_INVALID_ARGUMENT;
}
if (OB_SUCCESS == err)
{
if (ob_cell->value_.get_ext() != local_cell->value_.get_ext())
{
TBSYS_LOG(WARN,"ext info not coincident [row_idx:%lld,idx:%lld,"
"ob.ext:%lld,local.ext:%lld]",
row_number, scan_idx, ob_cell->value_.get_ext(), local_cell->value_.get_ext());
err = OB_INVALID_ARGUMENT;
}
if (ob_cell->value_.get_type() == ObNullType
&& ob_cell->value_.get_type() == local_cell->value_.get_type())
{
/// check pass
}
else
{
int64_t ob_value = 0;
int64_t local_value = 0;
if (OB_SUCCESS == err)
{
err = ob_cell->value_.get_int(ob_value);
}
if (OB_SUCCESS == err)
{
err = local_cell->value_.get_int(local_value);
}
if (OB_SUCCESS != err)
{
TBSYS_LOG(WARN,"fail to get int value [row_idx:%lld,idx:%lld]",row_number, scan_idx);
err = OB_INVALID_ARGUMENT;
}
else
{
if (ob_value != local_value)
{
TBSYS_LOG(WARN,"value not coincident [row_idx:%lld,idx:%lld,ob.value:%lld,"
"local.value:%lld]",row_number, scan_idx, ob_value, local_value);
err = OB_INVALID_ARGUMENT;
}
}
}
}
}
}
if (OB_ITER_END == err)
{
err = OB_SUCCESS;
break;
}
row_number ++;
}
if (OB_SUCCESS != err)
{
res = false;
TBSYS_LOG(DEBUG, "check fail");
}
else
{
res = true;
TBSYS_LOG(DEBUG, "check pass");
}
return res;
}
int serialize_cell(ObCellInfo *cell, ObDataBuffer &buff)
{
int64_t cap = buff.get_remain();
int64_t len = -1;
int type = cell->value_.get_type();
char *data = buff.get_data();
int64_t pos = buff.get_position();
switch(type) {
case ObNullType:
// TBSYS_LOG(INFO, "Null Type");
len = 0;
break;
case ObIntType:
int64_t val;
if (cell->value_.get_int(val) != OB_SUCCESS) {
TBSYS_LOG(ERROR, "get_int error");
break;
}
len = snprintf(data + pos, cap, "%ld", val);
break;
case ObVarcharType:
{
ObString str;
if (cell->value_.get_varchar(str) != OB_SUCCESS ||
cap < str.length()) {
TBSYS_LOG(ERROR, "get_varchar error");
break;
}
memcpy(data + pos, str.ptr(), str.length());
escape_varchar(data + pos, str.length());
len = str.length();
}
break;
case ObPreciseDateTimeType:
{
int64_t value;
if (cell->value_.get_precise_datetime(value) != OB_SUCCESS) {
TBSYS_LOG(ERROR, "get_precise_datetime error");
break;
}
len = ObDateTime2MySQLDate(value, type, data + pos, cap);
}
break;
case ObDateTimeType:
{
int64_t value;
if (cell->value_.get_datetime(value) != OB_SUCCESS) {
TBSYS_LOG(ERROR, "get_datetime error ");
break;
}
len = ObDateTime2MySQLDate(value, type, data + pos, cap);
}
break;
case ObModifyTimeType:
{
int64_t value;
if (cell->value_.get_modifytime(value) != OB_SUCCESS) {
TBSYS_LOG(ERROR, "get_modifytime error ");
break;
}
len = ObDateTime2MySQLDate(value, type, data + pos, cap);
}
break;
case ObCreateTimeType:
{
int64_t value;
if (cell->value_.get_createtime(value) != OB_SUCCESS) {
TBSYS_LOG(ERROR, "get_createtime error");
break;
}
len = ObDateTime2MySQLDate(value, type, data + pos, cap);
}
break;
case ObFloatType:
{
float value;
if (cell->value_.get_float(value) != OB_SUCCESS) {
TBSYS_LOG(ERROR, "get_float error");
break;
}
len = snprintf(data + pos, cap, "%f", value);
}
break;
case ObDoubleType:
{
double value;
if (cell->value_.get_double(value) != OB_SUCCESS) {
TBSYS_LOG(ERROR, "get_double error");
break;
}
len = snprintf(data + pos, cap, "%f", value);
}
break;
default:
TBSYS_LOG(WARN, "Not Defined Type %d", cell->value_.get_type());
break;
}
if (len >= 0 ) {
buff.get_position() += len;
}
return len;
}
int ObMergeServerParams::update_item(const ObObj &item_name, const ObObj &item_value)
{
int ret = OB_SUCCESS;
static const int max_name_len = 256;
char name[max_name_len];
int64_t value = 0;
ObString str;
if (OB_SUCCESS != (ret = item_name.get_varchar(str)))
{
TBSYS_LOG(WARN, "fail to get item name value. ret=%d", ret);
}
else if (str.length() < max_name_len)
{
strncpy(name, str.ptr(), str.length());
name[str.length()] = '\0';
}
else
{
TBSYS_LOG(WARN, "item name too long. are you sure about this? item_name len=%d, max=%d", str.length(), max_name_len);
}
if ((OB_SUCCESS == ret) && (OB_SUCCESS != (ret = item_value.get_int(value))))
{
TBSYS_LOG(WARN, "fail to get value. expect int type");
}
if (OB_SUCCESS == ret)
{
if (0 == strcmp(name, OBMS_RETRY_TIMES))
{
retry_times_ = static_cast<int32_t>(value);
}
else if (0 == strcmp(name, OBMS_TASK_QUEUE_SIZE))
{
task_queue_size_ = static_cast<int32_t>(value);
}
else if (0 == strcmp(name, OBMS_TASK_THREAD_COUNT))
{
task_thread_count_ = static_cast<int32_t>(value);
}
else if (0 == strcmp(name, OBMS_TASK_LEFT_TIME))
{
task_left_time_ = value;
}
else if (0 == strcmp(name, OBMS_LOG_INTERVAL_COUNT))
{
log_interval_count_ = value;
}
else if (0 == strcmp(name, OBMS_NETWORK_TIMEOUT))
{
network_time_out_ = value;
}
else if (0 == strcmp(name, OBMS_LEASE_INTERVAL))
{
check_lease_interval_ = value;
}
else if (0 == strcmp(name, OBMS_MONITOR_INTERVAL))
{
monitor_interval_ = value;
}
else if (0 == strcmp(name, OBMS_UPSLIST_INTERVAL))
{
fetch_ups_interval_ = value;
}
else if (0 == strcmp(name, OBMS_UPSVERION_TIMEOT))
{
frozen_version_timeout_ = value;
}
else if (0 == strcmp(name, OBMS_BLACKLIST_TIMEOUT))
{
ups_blacklist_timeout_ = value;
}
else if (0 == strcmp(name, OBMS_BLACKLIST_FAIL_COUNT))
{
ups_fail_count_ = value;
}
else if (0 == strcmp(name, OBMS_LOCATION_CACHE_SIZE))
{
location_cache_size_ = static_cast<int32_t>(value) * 1024 * 1024L;
}
else if (0 == strcmp(name, OBMS_LOCATION_CACHE_TIMEOUT))
{
location_cache_timeout_ = value;
}
else if (0 == strcmp(name, OBMS_INTERMEDIATE_BUFFER_SIZE))
{
intermediate_buffer_size_ = value * (1024*1024);
}
else if (0 == strcmp(name, OBMS_MAX_REQ_PROCESS_TIME))
{
max_req_process_time_ = value;
}
else if (0 == strcmp(name, OBMS_MEMORY_SIZE_LIMIT_PERCENT))
{
memory_size_limit_ = value * (sysconf(_SC_PHYS_PAGES)*sysconf(_SC_PAGE_SIZE)) / 100;
}
else if (0 == strcmp(name, OBMS_MAX_CS_TIMEOUT_PERCENT))
{
max_cs_timeout_percent_ = static_cast<double>(value) / 100.0f;
}
else if (0 == strcmp(name, OBMS_ALLOW_RETURN_UNCOMPLETE_RESULT))
{
allow_return_uncomplete_result_ = static_cast<int32_t>(value);
}
else if (0 == strcmp(name, OBMS_MAX_PARELLEL_COUNT))
{
max_parellel_count_ = value;
}
else if (0 == strcmp(name, OBMS_MAX_GET_ROWS_PER_SUBREQ))
{
max_get_rows_per_subreq_ = value;
}
else if (0 == strcmp(name, OBMS_GET_REQUEST_FACTOR))
{
get_request_factor_ = value;
}
else if (0 == strcmp(name, OBMS_SCAN_REQUEST_FACTOR))
{
scan_request_factor_ = value;
}
else if (0 == strcmp(name, OBMS_SLOW_QUERY_THRESHOLD))
{
slow_query_threshold_ = value;
}
else
{
TBSYS_LOG(ERROR, "unexpected config item name. name=%s", name);
ret = OB_ERROR;
}
}
return ret;
}
int ObTabletJoin::get_next_row(const ObRow *&row)
{
int ret = OB_SUCCESS;
ObString rowkey;
ObString value;
ObRow tmp_row;
ObUpsRow tmp_ups_row;
tmp_row.set_row_desc(curr_row_desc_);
tmp_ups_row.set_row_desc(ups_row_desc_);
ObGetParam *get_param = NULL;
uint64_t right_table_id = OB_INVALID_ID;
if(NULL == (get_param = GET_TSI_MULT(ObGetParam, common::TSI_SQL_GET_PARAM_1)))
{
ret = OB_ALLOCATE_MEMORY_FAILED;
TBSYS_LOG(WARN, "get tsi get_param fail:ret[%d]", ret);
}
else
{
get_param->reset(true);
}
bool row_valid = false;
if(OB_SUCCESS == ret)
{
ret = fused_row_store_.get_next_row(tmp_row);
/* 如果fused cache里面的行已经使用完 */
if(OB_ITER_END == ret)
{
fused_row_store_.clear();
if(OB_SUCCESS != (ret = fetch_fused_row(get_param)))
{
if(OB_ITER_END != ret)
{
TBSYS_LOG(WARN, "fetch_fused_row fail :ret[%d]", ret);
}
}
else if(OB_SUCCESS != (ret = fetch_ups_row(get_param)))
{
TBSYS_LOG(WARN, "fetch_ups_row fail:ret[%d]", ret);
}
}
else if(OB_SUCCESS == ret)
{
row_valid = true;
}
else
{
TBSYS_LOG(WARN, "fused row store next row fail:ret[%d]", ret);
}
}
if(OB_SUCCESS == ret)
{
if(!row_valid)
{
ret = fused_row_store_.get_next_row(tmp_row);
if(OB_SUCCESS != ret || OB_ITER_END == ret)
{
TBSYS_LOG(WARN, "fused row store next row fail:ret[%d]", ret);
}
}
if(OB_SUCCESS == ret)
{
if(OB_SUCCESS != (ret = get_right_table_rowkey(tmp_row, right_table_id, rowkey)))
{
TBSYS_LOG(WARN, "get rowkey from tmp_row fail:ret[%d]", ret);
}
}
if(OB_SUCCESS == ret)
{
ret = ups_row_cache_.get(rowkey, value);
if(OB_SUCCESS == ret)
{
if(OB_SUCCESS != (ret = ObUpsRowUtil::convert(right_table_id, value, tmp_ups_row)))
{
TBSYS_LOG(WARN, "convert to ups row fail:ret[%d]", ret);
}
else
{
tmp_ups_row.set_row_desc(ups_row_desc_for_join_);
if(OB_SUCCESS != (ret = ObRowFuse::fuse_row(&tmp_ups_row, &tmp_row, &curr_row_)))
{
TBSYS_LOG(WARN, "fused ups row to row fail:ret[%d]", ret);
}
else
{
row = &curr_row_;
}
}
}
else if(OB_ENTRY_NOT_EXIST == ret)
{
curr_row_.assign(tmp_row);
row = &curr_row_;
ret = OB_SUCCESS;
}
else
{
TBSYS_LOG(WARN, "ups_row_cache_ get fail:ret[%d] rowkey[%.*s]", ret, rowkey.length(), rowkey.ptr());
}
}
}
return ret;
}
int DES_crypt::des_encrypt(const ObString &user_name, const int64_t timestamp, const int64_t skey, char *buffer, int64_t &buffer_length)
{
int err = OB_SUCCESS;
if(buffer_length <= (int64_t)(sizeof(int64_t) + 2 * sizeof(int32_t) + user_name.length()) || buffer_length % 8 != 0)
{
err = OB_INVALID_ARGUMENT;
TBSYS_LOG(WARN, "invalid argument. buffer_length = %ld, should be 80", buffer_length);
}
if(OB_SUCCESS == err)
{
if(user_name.length() == 0)
{
err = OB_INVALID_ARGUMENT;
TBSYS_LOG(WARN, "user_name should not be null. user_name.length=%d", user_name.length());
}
}
if(OB_SUCCESS == err)
{
data_.initialized = 0;
err = stringTobyte(keybyte_, OB_ENRYPT_KEY_BYTE, reinterpret_cast<const char*>(&skey), sizeof(int64_t));
if(err != OB_SUCCESS)
{
TBSYS_LOG(WARN, "fail to stringTobyte. err=%d", err);
}
else
{
setkey_r(keybyte_, &data_);
}
}
int64_t length = 0;
if(OB_SUCCESS == err)
{
length = 2 * sizeof(int32_t) + sizeof(int64_t) + user_name.length();
original_txt_length_ = static_cast<int32_t>(length);
err = pad(txtptr_, OB_MAX_TOKEN_BUFFER_LENGTH, length);
if(OB_SUCCESS != err)
{
TBSYS_LOG(WARN, "fail to pad array. err=%d", err);
}
}
int64_t pos = 0;
if(OB_SUCCESS == err)
{
*(reinterpret_cast<int32_t*>(txtptr_ + pos)) = OB_CRYPT_MAGIC_NUM;
pos += sizeof(int32_t);
*(reinterpret_cast<int32_t*>(txtptr_ + pos)) = user_name.length();
pos += sizeof(int32_t);
memcpy(txtptr_ + pos, user_name.ptr(), user_name.length());
pos += user_name.length();
*(reinterpret_cast<int64_t*>(txtptr_ + pos)) = timestamp;
pos += sizeof(int64_t);
}
if(OB_SUCCESS == err)
{
err = stringTobyte(txtbyte_, OB_ENCRYPT_TXT_BYTE, txtptr_, length);
if(err != OB_SUCCESS)
{
TBSYS_LOG(WARN, "fail to translate string to byte.err=%d", err);
}
}
if(OB_SUCCESS == err)
{
length = length * OB_BYTE_NUM;
char *ptr = txtbyte_;
for(int64_t i = 0; i < length; i += OB_CRYPT_UNIT)
{
ptr = &txtbyte_[i];
encrypt_r(ptr, ENCODE_FLAG, &data_);
}
}
if(OB_SUCCESS == err)
{
err = byteTostring(buffer, buffer_length, txtbyte_, length);
if(err != OB_SUCCESS)
{
TBSYS_LOG(WARN, "fail to translate to string.err=%d", err);
}
else
{
buffer_length = length / OB_BYTE_NUM;
}
}
return err;
}
const char *print_obj(const ObObj &obj)
{
static const int64_t BUFFER_SIZE = 128 * 1024;
static __thread char buffers[2][BUFFER_SIZE];
static __thread int64_t i = 0;
char *buffer = buffers[i++ % 2];
buffer[0] = '\0';
switch (obj.get_type())
{
case ObNullType:
snprintf(buffer, BUFFER_SIZE, "obj_type=null");
break;
case ObIntType:
{
bool is_add = false;
int64_t tmp = 0;
obj.get_int(tmp, is_add);
snprintf(buffer, BUFFER_SIZE, "obj_type=int value=%ld is_add=%s", tmp, STR_BOOL(is_add));
}
break;
case ObDateTimeType:
{
bool is_add = false;
ObDateTime tmp = 0;
obj.get_datetime(tmp, is_add);
snprintf(buffer, BUFFER_SIZE, "obj_type=data_time value=%s is_add=%s", time2str(tmp), STR_BOOL(is_add));
}
break;
case ObPreciseDateTimeType:
{
bool is_add = false;
ObDateTime tmp = 0;
obj.get_precise_datetime(tmp, is_add);
snprintf(buffer, BUFFER_SIZE, "obj_type=precise_data_time value=%s is_add=%s", time2str(tmp), STR_BOOL(is_add));
}
break;
case ObVarcharType:
{
ObString tmp;
obj.get_varchar(tmp);
if (NULL != tmp.ptr()
&& 0 != tmp.length()
&& !str_isprint(tmp.ptr(), tmp.length()))
{
char hex_buffer[BUFFER_SIZE] = {'\0'};
common::hex_to_str(tmp.ptr(), tmp.length(), hex_buffer, BUFFER_SIZE);
snprintf(buffer, BUFFER_SIZE, "obj_type=var_char value=[0x %s] value_ptr=%p value_length=%d",
hex_buffer, tmp.ptr(), tmp.length());
}
else
{
snprintf(buffer, BUFFER_SIZE, "obj_type=var_char value=[%.*s] value_ptr=%p value_length=%d",
tmp.length(), tmp.ptr(), tmp.ptr(), tmp.length());
}
}
break;
case ObSeqType:
snprintf(buffer, BUFFER_SIZE, "obj_type=seq");
break;
case ObCreateTimeType:
{
ObCreateTime tmp = 0;
obj.get_createtime(tmp);
snprintf(buffer, BUFFER_SIZE, "obj_type=create_time value=%s", time2str(tmp));
}
break;
case ObModifyTimeType:
{
ObModifyTime tmp = 0;
obj.get_modifytime(tmp);
snprintf(buffer, BUFFER_SIZE, "obj_type=modify_time value=%s", time2str(tmp));
}
break;
case ObExtendType:
{
int64_t tmp = 0;
obj.get_ext(tmp);
snprintf(buffer, BUFFER_SIZE, "obj_type=extend value=%ld", tmp);
}
break;
default:
break;
}
return buffer;
}
ObPermInfoKey::ObPermInfoKey(const uint64_t table_id, ObString& user_name) : table_id_(table_id),
user_name_(user_name.ptr()),
length_(user_name.length()),
buffer_(NULL)
{
}
ObUserInfoKey::ObUserInfoKey(ObString& user_name) : user_name_(user_name.ptr()),
length_(user_name.length()),
buffer_(NULL)
{
}
// waring:all return cell in a row must be same as root table's columns,
// and the second row is this row allocated chunkserver list
int ObMergerRootRpcProxy::scan_root_table(ObMergerTabletLocationCache * cache,
const uint64_t table_id, const ObString & row_key, const ObServer & addr,
ObMergerTabletLocationList & location)
{
assert(location.get_buffer() != NULL);
int ret = OB_SUCCESS;
bool find_right_tablet = false;
ObScanner scanner;
// root table id = 0
ret = rpc_stub_->fetch_tablet_location(rpc_timeout_, root_server_, 0,
table_id, row_key, scanner);
if (ret != OB_SUCCESS)
{
TBSYS_LOG(WARN, "fetch tablet location failed:table_id[%lu], length[%d], ret[%d]",
table_id, row_key.length(), ret);
hex_dump(row_key.ptr(), row_key.length(), true);
}
else
{
ObRange range;
range.border_flag_.unset_inclusive_start();
range.border_flag_.set_inclusive_end();
ObString start_key;
ObString end_key;
ObServer server;
ObCellInfo * cell = NULL;
bool row_change = false;
ObScannerIterator iter = scanner.begin();
TBSYS_LOG(DEBUG, "%s", "parse scanner result for get some tablet locations");
// all return cell in a row must be same as root table's columns
++iter;
while ((iter != scanner.end())
&& (OB_SUCCESS == (ret = iter.get_cell(&cell, &row_change))) && !row_change)
{
if (NULL == cell)
{
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;
bool second_row = true;
// next cell
ObMergerTabletLocationList 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))
{
range.table_id_ = table_id;
if (NULL == start_key.ptr())
{
range.border_flag_.set_min_value();
}
else
{
range.border_flag_.unset_min_value();
range.start_key_ = start_key;
}
range.border_flag_.unset_max_value();
range.end_key_ = end_key;
start_key = end_key;
end_key.assign(cell->row_key_.ptr(), cell->row_key_.length());
list.set_timestamp(tbsys::CTimeUtil::getTime());
list.sort(addr);
// not deep copy the range
list.set_tablet_range(range);
// the second row is this row allocated chunkserver list
if (second_row)
{
second_row = false;
if ((row_key <= range.end_key_) && (row_key > range.start_key_))
{
find_right_tablet = true;
location = list;
assert(location.get_buffer() != NULL);
location.set_tablet_range(range);
}
else
{
ret = OB_DATA_NOT_SERVE;
TBSYS_LOG(ERROR, "check range not include this key:ret[%d]", ret);
hex_dump(row_key.ptr(), row_key.length());
range.hex_dump();
break;
}
}
// add to cache
if (OB_SUCCESS != cache->set(range, list))
{
TBSYS_LOG(WARN, "%s", "add the range to cache failed");
}
list.clear();
}
else
{
end_key.assign(cell->row_key_.ptr(), cell->row_key_.length());
if ((cell->column_name_.compare("1_port") == 0)
|| (cell->column_name_.compare("2_port") == 0)
|| (cell->column_name_.compare("3_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);
if (OB_SUCCESS == ret)
{
if (port == 0)
{
TBSYS_LOG(WARN, "check port failed:ip[%ld], port[%ld]", ip, port);
}
server.set_ipv4_addr(static_cast<int32_t>(ip), static_cast<int32_t>(port));
ObTabletLocation addr(0, server);
if (OB_SUCCESS != (ret = list.add(addr)))
{
TBSYS_LOG(ERROR, "add addr failed:ip[%ld], port[%ld], ret[%d]",
ip, port, ret);
break;
}
else
{
TBSYS_LOG(DEBUG, "add addr succ:ip[%ld], port[%ld]", ip, port);
}
ip = port = 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))
{
range.table_id_ = table_id;
if (NULL == start_key.ptr())
{
range.border_flag_.set_min_value();
}
else
{
range.border_flag_.unset_min_value();
range.start_key_ = start_key;
}
range.border_flag_.unset_max_value();
range.end_key_ = end_key;
list.set_timestamp(tbsys::CTimeUtil::getTime());
// not deep copy the range
list.set_tablet_range(range);
list.sort(addr);
// double check add all range->locationlist to cache
if ((row_key <= range.end_key_) && (row_key > range.start_key_))
{
find_right_tablet = true;
location = list;
// deep copy range
assert(location.get_buffer() != NULL);
location.set_tablet_range(range);
}
else if (second_row)
{
range.hex_dump();
ret = OB_DATA_NOT_SERVE;
TBSYS_LOG(ERROR, "check range not include this key:ret[%d]", ret);
}
// add to list to cache
if (OB_SUCCESS != cache->set(range, list))
{
range.hex_dump();
TBSYS_LOG(WARN, "%s", "add the range to cache failed");
}
}
}
else
{
TBSYS_LOG(ERROR, "check get first row cell failed:ret[%d]", ret);
}
}
if ((OB_SUCCESS == ret) && (0 == location.size()))
{
TBSYS_LOG(ERROR, "check get location size failed:table_id[%ld], find[%d], count[%ld]",
table_id, find_right_tablet, location.size());
hex_dump(row_key.ptr(), row_key.length());
ret = OB_INNER_STAT_ERROR;
}
ms_get_counter_set().inc(ObMergerCounterIds::C_SCAN_ROOT_TABLE);
return ret;
}
ObUserInfoValue::ObUserInfoValue(ObString& password) : passwd_(password.ptr()),
length_(password.length())
{
}
int64_t MutatorBuilder::get_cur_seed_(const seed_map_t &seed_map, const ObSchema &schema, const ObString &row_key, const bool using_id)
{
int64_t cur_seed = 0;
TEKey te_key;
te_key.table_id = schema.get_table_id();
te_key.row_key = row_key;
int hash_ret = 0;
if (HASH_EXIST != (hash_ret = seed_map.get(te_key, cur_seed)))
{
ObGetParam get_param;
ObScanner scanner;
ObCellInfo cell_info;
cell_info.row_key_ = row_key;
if (using_id)
{
cell_info.table_id_ = schema.get_table_id();
cell_info.column_id_ = SEED_COLUMN_ID;
}
else
{
cell_info.table_name_.assign_ptr(const_cast<char*>(schema.get_table_name()), static_cast<int32_t>(strlen(schema.get_table_name())));
cell_info.column_name_.assign_ptr((char*)SEED_COLUMN_NAME, static_cast<int32_t>(strlen(SEED_COLUMN_NAME)));
}
get_param.add_cell(cell_info);
ObVersionRange version_range;
version_range.start_version_ = table_start_version_;
version_range.border_flag_.set_max_value();
version_range.border_flag_.set_inclusive_start();
get_param.set_version_range(version_range);
if (OB_SUCCESS == client_.get(get_param, scanner))
{
CellinfoBuilder::result_set_t result_set;
MemTank mem_tank;
while (OB_SUCCESS == scanner.next_cell())
{
ObCellInfo *ci = NULL;
if (OB_SUCCESS != scanner.get_cell(&ci))
{
break;
}
if (!using_id)
{
::trans_name2id(*ci, schema);
}
ObCellInfo *new_ci = copy_cell(mem_tank, ci);
CellinfoBuilder::merge_obj(new_ci, result_set);
}
if (0 != result_set.size())
{
ObCellInfo *ret_ci = NULL;
result_set.get(SEED_COLUMN_ID, ret_ci);
if (NULL != ret_ci)
{
ret_ci->value_.get_int(cur_seed);
}
TBSYS_LOG(DEBUG, "seed get from oceanbase %s", print_cellinfo(ret_ci));
}
}
else
{
abort();
}
}
if (0 == cur_seed)
{
cur_seed = SEED_START;
TBSYS_LOG(DEBUG, "first seed from cur_seed=%ld row_key=[%.*s]", cur_seed, row_key.length(), row_key.ptr());
}
else
{
cur_seed += 1;
}
TBSYS_LOG(DEBUG, "get cur_seed=%ld hash_ret=%d row_key=[%.*s]", cur_seed, hash_ret, row_key.length(), row_key.ptr());
return cur_seed;
}
int ObSelectStmt::check_alias_name(
ResultPlan& result_plan,
const ObString& alias_name) const
{
int& ret = result_plan.err_stat_.err_code_ = OB_SUCCESS;
ObLogicalPlan *logical_plan = static_cast<ObLogicalPlan*>(result_plan.plan_tree_);
ObSchemaChecker *schema_checker = static_cast<ObSchemaChecker*>(result_plan.schema_checker_);
if (schema_checker == NULL)
{
ret = OB_ERR_SCHEMA_UNSET;
snprintf(result_plan.err_stat_.err_msg_, MAX_ERROR_MSG,
"Schema(s) are not set");
}
for (int32_t i = 0; ret == OB_SUCCESS && i < table_items_.size(); i++)
{
/* check if it is column of base-table */
TableItem& item = table_items_[i];
if (item.type_ == TableItem::BASE_TABLE
|| item.type_ == TableItem::ALIAS_TABLE)
{
if (schema_checker->column_exists(item.table_name_, alias_name))
{
ret = OB_ERR_COLUMN_DUPLICATE;
snprintf(result_plan.err_stat_.err_msg_, MAX_ERROR_MSG,
"alias name %.*s is ambiguous", alias_name.length(), alias_name.ptr());
break;
}
}
else if (item.type_ == TableItem::GENERATED_TABLE)
{
/* check if it is column of generated-table */
ObSelectStmt* sub_query = static_cast<ObSelectStmt*>(logical_plan->get_query(item.ref_id_));
for (int32_t j = 0; ret == OB_SUCCESS && j < sub_query->get_select_item_size(); j++)
{
const SelectItem& select_item = sub_query->get_select_item(j);
if (select_item.alias_name_ == alias_name)
{
ret = OB_ERR_COLUMN_DUPLICATE;
snprintf(result_plan.err_stat_.err_msg_, MAX_ERROR_MSG,
"alias name %.*s is ambiguous", alias_name.length(), alias_name.ptr());
break;
}
}
}
}
/* check if it is alias name of self-select */
for (int32_t i = 0; ret == OB_SUCCESS && i < select_items_.size(); i++)
{
const SelectItem& select_item = get_select_item(i);
if (select_item.alias_name_ == alias_name)
{
ret = OB_ERR_COLUMN_DUPLICATE;
snprintf(result_plan.err_stat_.err_msg_, MAX_ERROR_MSG,
"alias name %.*s is ambiguous", alias_name.length(), alias_name.ptr());
break;
}
}
return ret;
}
int RowkeyWrapper::append_rowkey_item(const ObString &key, const RowkeyItem &item,
ObDataBuffer & buffer) const
{
int ret = OB_SUCCESS;
int type = item.type;
switch(type) {
case INT64:
case INT32:
case INT16:
{
int64_t value;
int key_part_len = 8;
char val_buf[8];
if (type == INT16)
{
key_part_len = 2;
}
else if (type == INT32)
{
key_part_len = 4;
}
if (key.length() < (item.start_pos + item.item_len) ||
item.item_len != key_part_len)
{
TBSYS_LOG(ERROR, "rowkey item config error, start_pos=%d, type=%d, key_part_len = %d",
item.start_pos, item.type, key_part_len);
ret = OB_ERROR;
break;
}
memset(val_buf, 0, 8);
memcpy(val_buf, key.ptr() + item.start_pos, key_part_len);
reverse(val_buf, val_buf + key_part_len);
memcpy(&value, val_buf, 8);
ret = append_int64(value, buffer);
}
break;
case INT8:
{
int8_t value;
if (key.length() < (item.start_pos + 1) ||
item.item_len != 1)
{
TBSYS_LOG(ERROR, "rowkey item config error, start_pos=%d, type=%d",
item.start_pos, item.type);
ret = OB_ERROR;
break;
}
value = key.ptr()[item.start_pos];
ret = append_int8(value, buffer);
break;
}
break;
case STR:
{
if (key.length() < item.start_pos + item.item_len)
{
TBSYS_LOG(ERROR, "configuration error, item.start_pos=%d, item.item_len=%d",
item.start_pos, item.item_len);
break;
}
ret = append_str(key.ptr() + item.start_pos, item.item_len, buffer);
}
break;
case VSTR:
{
if (key.length() < item.start_pos)
{
TBSYS_LOG(ERROR, "configuration error, item.start_pos=%d",
item.start_pos);
break;
}
int64_t len = key.length() - item.start_pos;
ret = append_str(key.ptr() + item.start_pos, len, buffer);
}
break;
default:
TBSYS_LOG(ERROR, "such type [%d] is not supported now", type);
break;
}
return ret;
}
