int ObMergerTabletLocationCache::update(const uint64_t table_id, const ObString & rowkey, const ObMergerTabletLocationList & location) { int ret = OB_SUCCESS; if (!init_) { TBSYS_LOG(ERROR, "%s", "check init failed"); ret = OB_INNER_STAT_ERROR; } else if ((0 == rowkey.length()) || (NULL == rowkey.ptr())) { TBSYS_LOG(ERROR, "%s", "check rowkey length failed"); ret = OB_INPUT_PARAM_ERROR; } else { char * temp = (char *)ob_malloc(sizeof(table_id) + rowkey.length(),ObModIds::OB_MS_LOCATION_CACHE); if (NULL == temp) { TBSYS_LOG(ERROR, "check ob malloc failed:size[%lu], pointer[%p]", sizeof(table_id) + rowkey.length(), temp); ret = OB_ALLOCATE_MEMORY_FAILED; } else { ObRange range; ObString CacheKey; // encode table_id + rowkey as CacheKey *((uint64_t *) temp) = table_id; memcpy(temp + sizeof(uint64_t), rowkey.ptr(), rowkey.length()); CacheKey.assign(temp, static_cast<int32_t>(sizeof(table_id) + rowkey.length())); // get the pair according to the key ObCachePair pair; ret = tablet_cache_.get(CacheKey, pair); if (OB_SUCCESS != ret) { TBSYS_LOG(DEBUG, "find tablet from cache failed:table_id[%lu], length[%d]", table_id, rowkey.length()); } else { int64_t pos = 0; // TODO double check pair.key whether as equal with CacheKey ret = range.deserialize(pair.get_key().ptr(), pair.get_key().length(), pos); if (OB_SUCCESS != ret) { TBSYS_LOG(ERROR, "deserialize tablet range failed:table_id[%lu], ret[%d]", table_id, ret); } else { ret = set(range, location); } } // destory the temp buffer ob_free(temp); } } return ret; }
int64_t ObStringSearch::fast_search(const ObString & pattern, const ObString & text) { const char* pat = pattern.ptr(); const int64_t pat_len = pattern.length(); const char* txt = text.ptr(); const int64_t txt_len = text.length(); return fast_search(pat, pat_len, txt, txt_len); }
int ObUpsRowUtil::convert(const ObUpsRow &row, ObString &compact_row) { int ret = OB_SUCCESS; ObCompactCellWriter cell_writer; cell_writer.init(compact_row.ptr(), compact_row.size()); const ObObj *cell = NULL; uint64_t table_id = OB_INVALID_ID; uint64_t column_id = OB_INVALID_ID; ObObj cell_clone; if(row.get_is_delete_row()) { if(OB_SUCCESS != (ret = cell_writer.row_delete())) { TBSYS_LOG(WARN, "append delete row fail:ret[%d]", ret); } } for (int64_t i = 0; (OB_SUCCESS == ret) && i < row.get_column_num(); ++i) { if (OB_SUCCESS != (ret = row.raw_get_cell(i, cell, table_id, column_id))) { TBSYS_LOG(WARN, "failed to get cell, err=%d", ret); break; } else { if(ObExtendType == cell->get_type() && ObActionFlag::OP_NOP == cell->get_ext()) { //不用处理,OP_NOP不序列化 } else if (OB_SUCCESS != (ret = cell_writer.append(column_id, *cell))) { if (OB_SIZE_OVERFLOW != ret) { TBSYS_LOG(WARN, "failed to append cell, err=%d", ret); } break; } } } // end for i if (OB_SUCCESS == ret) { if (OB_SUCCESS != (ret = cell_writer.row_finish())) { if (OB_SIZE_OVERFLOW != ret) { TBSYS_LOG(WARN, "failed to append cell, err=%d", ret); } } else { compact_row.assign_ptr(compact_row.ptr(), (int32_t)(cell_writer.size())); } } return ret; }
int ObFileService::check_dir(const ObString& local_dir, const int64_t file_size) { int ret = OB_SUCCESS; char path_buf[OB_MAX_FILE_NAME_LENGTH]; if (OB_SUCCESS == ret) { // check if the dir is allowed to write struct stat dir_stat; int n = snprintf(path_buf, OB_MAX_FILE_NAME_LENGTH, "%.*s", local_dir.length(), local_dir.ptr()); if (n<0 || n>=OB_MAX_FILE_NAME_LENGTH) { ret = OB_SIZE_OVERFLOW; TBSYS_LOG(ERROR, "local_dir length is overflow, length[%d] str[%.*s]", local_dir.length(), local_dir.length(), local_dir.ptr()); } else if (stat(path_buf, &dir_stat) != 0) { TBSYS_LOG(WARN, "get local directory[%s] stat fail: %s", path_buf, strerror(errno)); ret = OB_IO_ERROR; } else if (!(S_IWUSR & dir_stat.st_mode)) { TBSYS_LOG(WARN, "local dir[%s] cannot be written", path_buf); ret = OB_IO_ERROR; } } if (OB_SUCCESS == ret) { // check the free space struct statvfs dir_statvfs; if (statvfs(path_buf, &dir_statvfs) != 0) { TBSYS_LOG(WARN, "get disk free space of %s info fail: %s", path_buf, strerror(errno)); ret = OB_IO_ERROR; } else { int64_t free_space = dir_statvfs.f_bavail * dir_statvfs.f_bsize; if(file_size > free_space) { TBSYS_LOG(WARN, "free disk space of %s is not enough: file_size[%ld]" " free_space[%ld]", path_buf, file_size, free_space); ret = OB_CS_OUTOF_DISK_SPACE; } } } return ret; }
int ObStringBuf :: write_string(const ObString& str, ObString* stored_str) { int err = OB_SUCCESS; if (0 == str.length() || NULL == str.ptr()) { if (NULL != stored_str) { stored_str->assign(NULL, 0); } } else { int64_t str_length = str.length(); if (NULL == block_tail_ || (NULL != block_tail_ && block_tail_->block_size - block_tail_->cur_pos <= str_length)) { err = alloc_a_block_(); if (OB_SUCCESS != err) { TBSYS_LOG(WARN, "failed to alloc_a_block_, err=%d", err); } } if (OB_SUCCESS == err) { if (NULL == block_tail_ || (NULL != block_tail_ && block_tail_->block_size - block_tail_->cur_pos <= str_length)) { // buffer still not enough err = OB_ERROR; } else { memcpy(block_tail_->data + block_tail_->cur_pos, str.ptr(), str.length()); if (NULL != stored_str) { stored_str->assign(block_tail_->data + block_tail_->cur_pos, str.length()); } block_tail_->cur_pos += str_length; total_res_ += str_length; } } } return err; }
int ObUserInfoKey::set_user_name(ObString name) { int ret = OB_SUCCESS; if (NULL == name.ptr()) { TBSYS_LOG(WARN, "illegal argument name[%p]", name.ptr()); ret = OB_ERROR; } else { user_name_ = name.ptr(); length_ = name.length(); } return ret; }
int ObUserInfoValue::set_passwd(ObString pass) { int ret = OB_SUCCESS; if (NULL == pass.ptr()) { TBSYS_LOG(WARN, "illegal argument passwd[%p]", pass.ptr()); ret = OB_ERROR; } else { passwd_ = pass.ptr(); length_ = pass.length(); } return ret; }
int ObSKeyInfoValue::set_skey(ObString key) { int ret = OB_SUCCESS; if (NULL == key.ptr()) { TBSYS_LOG(WARN, "illegal argument skey[%p]", key.ptr()); ret = OB_ERROR; } else { skey_ = key.ptr(); length_ = key.length(); } return ret; }
int ObBlockIndexCache::get_block_position_info( const ObBlockIndexPositionInfo& block_index_info, const uint64_t table_id, const uint64_t column_group_id, const ObString& key, const SearchMode search_mode, ObBlockPositionInfos& pos_info) { int ret = OB_SUCCESS; bool revert_handle = false; ObSSTableBlockIndexV2 block_index; Handle handle; if (OB_SUCCESS != (ret = check_param(block_index_info, table_id, column_group_id))) { TBSYS_LOG(ERROR, "check_param error, table_id=%ld, column_group_id=%ld", table_id, column_group_id); } else if ( is_regular_mode(search_mode) && (NULL == key.ptr() || key.length() <= 0) ) { TBSYS_LOG(WARN, "invalid param, key_ptr=%p, key_len=%d", key.ptr(), key.length()); ret = OB_INVALID_ARGUMENT; } else if ( OB_SUCCESS != (ret = load_block_index(block_index_info, block_index, table_id, handle)) ) { TBSYS_LOG(ERROR, "load block index error, ret=%d, table_id=%ld" "column_group_id=%ld, mode=%d, pos=%ld", ret, table_id, column_group_id, search_mode, pos_info.block_count_); } else { revert_handle = true; ret = block_index.search_batch_blocks_by_key( table_id, column_group_id, key, search_mode, pos_info); } if (revert_handle && OB_SUCCESS != kv_cache_.revert(handle)) { //must revert the handle TBSYS_LOG(WARN, "failed to revert block index cache handle"); } return ret; }
int get_rowkey_info_from_sm(const ObSchemaManagerV2* schema_mgr, const uint64_t table_id, const ObString& table_name, ObRowkeyInfo& rowkey_info) { int ret = OB_SUCCESS; const ObTableSchema* tbl = NULL; if (NULL == schema_mgr) { ret = OB_INVALID_ARGUMENT; } else if (table_id > 0 && table_id != OB_INVALID_ID) { tbl = schema_mgr->get_table_schema(table_id); } else if (NULL != table_name.ptr()) { tbl = schema_mgr->get_table_schema(table_name); } if (NULL == tbl) { ret = OB_INVALID_ARGUMENT; } else { rowkey_info = tbl->get_rowkey_info(); } return ret; }
TEST_F(ObSqlExpressionTest, copy_operator_test) { ObString stdstring; stdstring.assign((char*)"hello world", 11); ObSqlExpression p; ExprItem item_b; item_b.type_ = T_STRING; item_b.string_.assign((char*)"hello world", 11); p.add_expr_item(item_b); ObRow row; const ObObj *result = NULL; p.add_expr_item_end(); p.calc(row, result); //int64_t re; ObString mystring; EXPECT_EQ(OB_SUCCESS, result->get_varchar(mystring)); EXPECT_EQ(mystring, stdstring); // test deep copy ObSqlExpression q; q = p; p.~ObSqlExpression(); memset(&p, 0, sizeof(p)); EXPECT_EQ(OB_SUCCESS, q.calc(row, result)); EXPECT_EQ(OB_SUCCESS, result->get_varchar(mystring)); EXPECT_EQ(mystring, stdstring); TBSYS_LOG(INFO, "%.*s", mystring.length(), mystring.ptr()); //ASSERT_EQ(); }
int ObSystemConfigKey::set_varchar(const ObString &key, const char * strvalue) { int ret = OB_SUCCESS; if (NULL == strvalue) { TBSYS_LOG(WARN, "check varchar value failed"); ret = OB_INVALID_ARGUMENT; } else if (key == ObString::make_string("svr_type")) { strncpy(server_type_, strvalue, sizeof (server_type_)); server_type_[OB_SERVER_TYPE_LENGTH - 1] = '\0'; } else if (key == ObString::make_string("svr_ip")) { strncpy(server_ip_, strvalue, sizeof (server_ip_)); server_ip_[OB_MAX_SERVER_ADDR_SIZE - 1] = '\0'; } else { ret = OB_INVALID_ARGUMENT; TBSYS_LOG(ERROR, "unknow sys config column name: %.*s", key.length(), key.ptr()); } return ret; }
uint64_t ObMetaTableColumnSchema::get_cid_by_idx(const int64_t i) const { uint64_t ret = OB_INVALID_ID; if (i >= get_columns_num() || 0 > i) { TBSYS_LOG(ERROR, "invalid column index, i=%ld tid=%lu", i, table_schema_.table_id_); } else { ObString cname; const int buf_len = meta_table_cname::STARTKEY_OBJ_PREFIX.length() + 8; char cname_buf[buf_len]; cname_buf[0] = '\0'; if (i < static_cast<int64_t>(ARRAYSIZEOF(COLUMNS_NAME))) { cname = COLUMNS_NAME[i]; } else { // start_rowkey_obj1, start_rowkey_obj2, ... int len = snprintf(cname_buf, buf_len, "%.*s%ld", meta_table_cname::STARTKEY_OBJ_PREFIX.length(), meta_table_cname::STARTKEY_OBJ_PREFIX.ptr(), i - ARRAYSIZEOF(COLUMNS_NAME) + 1); cname.assign_ptr(cname_buf, len); } 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; }
int CellinfoBuilder::get_mutator(const ObString &row_key, const ObSchema &schema, int64_t &cur_seed, ObMutator &mutator, PageArena<char> &allocer) { int ret = OB_SUCCESS; int64_t sign = ob_crc64(row_key.ptr(), row_key.length()); uint64_t table_id = schema.get_table_id(); sign = ob_crc64(sign, &table_id, sizeof(uint64_t)); struct drand48_data rand_data; cur_seed += 1; srand48_r(sign + cur_seed, &rand_data); int64_t rand = 0; lrand48_r(&rand_data, &rand); int64_t op_num = range_rand(1, max_op_num_, rand); for (int64_t i = 0; i < op_num; i++) { ret = build_operator_(rand_data, row_key, schema, mutator, allocer); if (OB_SUCCESS != ret) { break; } } ObString table_name; table_name.assign_ptr(const_cast<char*>(schema.get_table_name()), strlen(schema.get_table_name())); ObString column_name; column_name.assign_ptr(SEED_COLUMN_NAME, strlen(SEED_COLUMN_NAME)); ObObj obj; obj.set_int(cur_seed); mutator.update(table_name, row_key, column_name, obj); return ret; }
int ObAlterTableStmt::set_new_table_name(ResultPlan& result_plan, const ObString& table_name) { int& ret = result_plan.err_stat_.err_code_ = OB_SUCCESS; ObSchemaChecker* schema_checker = NULL; if (name_pool_ == NULL) { ret = OB_NOT_INIT; snprintf(result_plan.err_stat_.err_msg_, MAX_ERROR_MSG, "Name pool need to be set, ret=%d", ret); } else if ((schema_checker = static_cast<ObSchemaChecker*>(result_plan.schema_checker_)) == NULL) { ret = OB_ERR_SCHEMA_UNSET; snprintf(result_plan.err_stat_.err_msg_, MAX_ERROR_MSG, "Schema(s) are not set"); } else if(schema_checker->get_table_id(table_name) != OB_INVALID_ID) { ret = OB_ERR_TABLE_UNKNOWN; snprintf(result_plan.err_stat_.err_msg_, MAX_ERROR_MSG, "Table '%.*s' already exist", table_name.length(), table_name.ptr()); } else if ((ret = ob_write_string(*name_pool_, table_name, new_table_name_)) != OB_SUCCESS) { snprintf(result_plan.err_stat_.err_msg_, MAX_ERROR_MSG, "Allocate memory for table name failed"); } return ret; }
int ObSSTableBlockIndexBuilder::add_entry(const uint64_t table_id, const uint64_t column_group_id, const ObString &key, const int32_t record_size) { int ret = OB_SUCCESS; ObSSTableBlockIndexItem index_item; if (record_size < 0 || key.length() <= 0 || NULL == key.ptr() || table_id == OB_INVALID_ID || table_id == 0 || OB_INVALID_ID == column_group_id) { TBSYS_LOG(WARN, "invalid param, table_id=%lu, key_len=%d," "key_ptr=%p, record_size=%d, column_group_id=%lu", table_id, key.length(), key.ptr(), record_size, column_group_id); ret = OB_ERROR; } if (OB_SUCCESS == ret) { index_item.rowkey_column_count_ = 0; index_item.column_group_id_ = static_cast<uint16_t>(column_group_id); index_item.table_id_ = static_cast<uint32_t>(table_id); index_item.block_record_size_ = record_size; index_item.block_end_key_size_ = static_cast<int16_t>(key.length()); index_item.reserved_ = 0; ret = index_items_buf_.add_index_item(index_item); if (OB_SUCCESS == ret) { ret = end_keys_buf_.add_key(key); if (OB_ERROR == ret) { TBSYS_LOG(WARN, "failed to add end key"); } else { index_block_header_.sstable_block_count_++; } } else { TBSYS_LOG(WARN, "failed to add index item"); ret = OB_ERROR; } } return ret; }
bool RowChecker::is_prefix_changed(const ObString &row_key) { bool bret = false; if (NULL == last_row_key_.ptr() && NULL != row_key.ptr()) { bret = true; } else if (NULL != last_row_key_.ptr() && NULL == row_key.ptr()) { bret = true; } else if (0 != memcmp(last_row_key_.ptr(), row_key.ptr(), RowkeyBuilder::I64_STR_LENGTH)) { bret = true; } return bret; }
int execute_sql(MockClient &client, const char* sql_query) { int ret = OB_SUCCESS; ObString query; query.assign_ptr(const_cast<char*>(sql_query), static_cast<int32_t>(strlen(sql_query))); printf("execute_sql, query=[%.*s]...\n", query.length(), query.ptr()); ret = client.execute_sql(query, timeout); printf("ret=%d\n", ret); return ret; }
TEST_F(ObRowkeyTest, cast) { // (1, '2013-1-7', 'yes', true) ==> (varchar, datetime, bool, varchar) ObRowkeyInfo rowkey_info; ObRowkeyColumn rowkey_col; rowkey_col.length_ = 0; rowkey_col.column_id_ = 0; rowkey_col.type_ = ObVarcharType; ASSERT_EQ(OB_SUCCESS, rowkey_info.add_column(rowkey_col)); rowkey_col.type_ = ObPreciseDateTimeType; ASSERT_EQ(OB_SUCCESS, rowkey_info.add_column(rowkey_col)); rowkey_col.type_ = ObBoolType; ASSERT_EQ(OB_SUCCESS, rowkey_info.add_column(rowkey_col)); rowkey_col.type_ = ObVarcharType; ASSERT_EQ(OB_SUCCESS, rowkey_info.add_column(rowkey_col)); ASSERT_EQ(4, rowkey_info.get_size()); // cons rowkey ObObj rowkey_objs[4]; rowkey_objs[0].set_int(1234); rowkey_objs[1].set_varchar(ObString::make_string("2013-1-7")); rowkey_objs[2].set_varchar(ObString::make_string("yes")); rowkey_objs[3].set_bool(true); ObRowkey rowkey; rowkey.assign(rowkey_objs, 4); // cast char buff[1024]; memset(buff, 0, 1024); int64_t used_len = 0; ASSERT_EQ(OB_SUCCESS, ob_cast_rowkey(rowkey_info, rowkey, buff, 1024, used_len)); // verify ObString varchar; ObPreciseDateTime dt; bool bool_val = false; ASSERT_EQ(OB_SUCCESS, rowkey.get_obj_ptr()[0].get_varchar(varchar)); ASSERT_STREQ("1234", varchar.ptr()); ASSERT_EQ(OB_SUCCESS, rowkey.get_obj_ptr()[1].get_precise_datetime(dt)); ASSERT_EQ(OB_SUCCESS, rowkey.get_obj_ptr()[2].get_bool(bool_val)); ASSERT_EQ(true, bool_val); ASSERT_EQ(OB_SUCCESS, rowkey.get_obj_ptr()[3].get_varchar(varchar)); ASSERT_STREQ("true", varchar.ptr()); ASSERT_EQ(8, used_len); }
bool ObSchemaChecker::is_rowkey_column(const ObString& table_name, const ObString& column_name) const { bool is_rowkey = false; const ObTableSchema *table_schema = NULL; uint64_t column_id = OB_INVALID_ID; if ((table_schema = get_table_schema(table_name)) == NULL) { TBSYS_LOG(DEBUG, "Get table '%.*s' schema failed", table_name.length(), table_name.ptr()); } else if ((column_id = get_column_id(table_name, column_name)) == OB_INVALID_ID) { TBSYS_LOG(DEBUG, "Get column id failed, column name = %.*s", column_name.length(), column_name.ptr()); } else if (table_schema->get_rowkey_info().is_rowkey_column(column_id)) { is_rowkey = true; } return is_rowkey; }
void print(const ObString& p) { char str[1024]; int i = 0; for (; i < p.length() && i < 1023; ++i) { str[i] = *(p.ptr() + i); } str[i]=0; TBSYS_LOG(INFO, "%s", str); }
int ObSSTableBlockIndexBuffer::add_key(const ObString& key) { int ret = OB_SUCCESS; if (0 >= key.length() || NULL == key.ptr()) { TBSYS_LOG(WARN, "invalid argument key_len=%d, key_ptr=%p", key.length(), key.ptr()); ret = OB_ERROR; } if (OB_SUCCESS == ret) { if (NULL == block_tail_ || (NULL != block_tail_ && block_tail_->block_size_ - block_tail_->cur_pos_ <= key.length())) { ret = alloc_block(); if (OB_ERROR == ret) { TBSYS_LOG(WARN, "failed to alloc mem block ret=%d",ret); } } if (OB_SUCCESS == ret) { if (NULL == block_tail_ || (NULL != block_tail_ && block_tail_->block_size_ - block_tail_->cur_pos_ <= key.length())) { ret = OB_ERROR; } else { memcpy(block_tail_->data_ + block_tail_->cur_pos_, key.ptr(), key.length()); data_size_ += key.length(); block_tail_->cur_pos_ += key.length(); } } } return ret; }
int64_t MutatorBuilder::get_schema_pos(const ObString &table_name) const { int64_t ret = -1; for (int64_t i = 0; i < table_num_; i++) { if (0 == memcmp(schema_mgr_.begin()[i].get_table_name(), table_name.ptr(), table_name.length())) { ret = i; break; } } 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; }
int ObAlterTableStmt::set_table_name(ResultPlan& result_plan, const ObString& table_name) { int& ret = result_plan.err_stat_.err_code_ = OB_SUCCESS; ObSchemaChecker* schema_checker = NULL; const ObTableSchema* table_schema = NULL; if ((schema_checker = static_cast<ObSchemaChecker*>(result_plan.schema_checker_)) == NULL) { ret = OB_ERR_SCHEMA_UNSET; snprintf(result_plan.err_stat_.err_msg_, MAX_ERROR_MSG, "Schema(s) are not set"); } else if ((table_schema = schema_checker->get_table_schema(table_name)) == NULL) { ret = OB_ERR_TABLE_UNKNOWN; snprintf(result_plan.err_stat_.err_msg_, MAX_ERROR_MSG, "Table '%.*s' doesn't exist", table_name.length(), table_name.ptr()); } else if((table_id_ = table_schema->get_table_id()) == OB_INVALID_ID) { ret = OB_ERR_TABLE_UNKNOWN; snprintf(result_plan.err_stat_.err_msg_, MAX_ERROR_MSG, "Table '%.*s' doesn't exist", table_name.length(), table_name.ptr()); } else if ((max_column_id_ = table_schema->get_max_column_id()) == OB_INVALID_ID) { ret = OB_ERROR; snprintf(result_plan.err_stat_.err_msg_, MAX_ERROR_MSG, "Get max column id of Table '%.*s' failed", table_name.length(), table_name.ptr()); } else if ((ret = ob_write_string(*name_pool_, table_name, table_name_)) != OB_SUCCESS) { snprintf(result_plan.err_stat_.err_msg_, MAX_ERROR_MSG, "Allocate memory for table name failed"); } return ret; }
int64_t ObFakeSqlUpsRpcProxy2::get_int(ObRowkey rowkey) { int64_t ret = 0; int num = strlen("rowkey_"); ObString key; rowkey.ptr()[0].get_varchar(key); int pow = 1; for(int i=5-1; i>=0; i--) { char c = key.ptr()[i+num]; ret += (c - '0') * pow; pow *= 10; } return ret; }
int TaskFactory::init_new_task(const ObString & table_name, const ObString & start_key, const ObString & end_key, ObScanParam & scan_param, TaskInfo & task) const { int ret = OB_SUCCESS; if (!check_string(table_name) || !check_string(end_key)) { TBSYS_LOG(WARN, "check table name or end key failed:name[%.*s], end_key[%.*s]", table_name.length(), table_name.ptr(), end_key.length(), end_key.ptr()); ret = OB_ERROR; } else { ObRange 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); 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 print_rowkey(FILE *fd, ObString &rowkey) { char* pchar = rowkey.ptr(); for (int i = 0; i < rowkey.length(); ++i, pchar++) { if (isprint(*pchar)) { fprintf(fd, "%c", *pchar); } else { fprintf(fd, "\\%hhu", *pchar); } } }