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;
}
bool ObRange::intersect(const ObRange& r) const
{
// suppose range.start_key_ <= range.end_key_
if (table_id_ != r.table_id_) return false;
if (empty() || r.empty()) return false;
if (is_whole_range() || r.is_whole_range()) return true;
ObString lkey, rkey;
bool ret = false;
int8_t include_lborder = 0;
int8_t include_rborder = 0;
bool min_value = false;
int cmp = compare_with_endkey(r);
if (cmp < 0)
{
lkey = end_key_;
rkey = r.start_key_;
include_lborder = (border_flag_.inclusive_end());
include_rborder = (r.border_flag_.inclusive_start());
min_value = (r.border_flag_.is_min_value());
}
else if (cmp > 0)
{
lkey = r.end_key_;
rkey = start_key_;
include_lborder = (r.border_flag_.inclusive_end());
include_rborder = (border_flag_.inclusive_start());
min_value = (border_flag_.is_min_value());
}
else
{
ret = true;
}
if (cmp != 0)
{
if (min_value) ret = true;
else if (lkey < rkey) ret = false;
else if (lkey > rkey) ret = true;
else ret = (include_lborder != 0 && include_rborder != 0);
}
return ret;
}
int TabletManagerIniter::create_tablet(const ObRange& range,
const ObSSTableId& sst_id, bool serving,
const int64_t version)
{
int ret = OB_SUCCESS;
if (range.empty())
{
TBSYS_LOG(ERROR, "create_tablet error, input range is empty.");
ret = OB_INVALID_ARGUMENT;
}
if (OB_SUCCESS == ret)
{
ObTablet* tablet = NULL;
// find tablet if exist?
ObMultiVersionTabletImage &image = tablet_mgr_.get_serving_tablet_image() ;
ret = image.acquire_tablet(range, ObMultiVersionTabletImage::SCAN_FORWARD, version, tablet);
if (OB_SUCCESS == ret)
{
TBSYS_LOG(ERROR, "tablet already exists! dump input and exist:");
range.hex_dump(TBSYS_LOG_LEVEL_ERROR);
tablet->get_range().hex_dump(TBSYS_LOG_LEVEL_ERROR);
ret = OB_ERROR;
tablet = NULL;
image.release_tablet(tablet);
}
else
{
ret = image.alloc_tablet_object(range, version, tablet);
if (OB_SUCCESS == ret)
{
ret = tablet->add_sstable_by_id(sst_id);
}
if (OB_SUCCESS == ret)
{
tablet->set_disk_no(sst_id.sstable_file_id_ & DISK_NO_MASK);
ret = image.add_tablet(tablet, true, true);
}
}
}
return ret;
}
int scan_test_case_common(
BaseClient& client,
const ObServer& server,
const int64_t table_id,
const char* start_key_ptr,
const char* end_key_ptr,
const int64_t input_key_size,
const bool is_hex
)
{
ObScanParam input;
int64_t key_size = input_key_size;
if (is_hex)
{
key_size = input_key_size / 2;
}
char start_key[input_key_size];
char end_key[input_key_size];
char range_str[OB_RANGE_STR_BUFSIZ];
memset(start_key, 0, input_key_size);
memset(end_key, 0, input_key_size);
if (is_hex)
{
str_to_hex(start_key_ptr, static_cast<int32_t>(input_key_size), start_key, static_cast<int32_t>(key_size));
str_to_hex(end_key_ptr, static_cast<int32_t>(input_key_size), end_key, static_cast<int32_t>(key_size));
}
else
{
memcpy(start_key, start_key_ptr, key_size);
memcpy(end_key, end_key_ptr, key_size);
}
ObString ob_table_name(0, 0, NULL);
ObRange range;
range.table_id_= 0;
range.start_key_.assign_ptr(start_key, static_cast<int32_t>(key_size));
range.end_key_.assign_ptr(end_key, static_cast<int32_t>(key_size));
range.border_flag_.set_inclusive_start();
range.border_flag_.set_inclusive_end();
range.to_string(range_str, OB_RANGE_STR_BUFSIZ);
range.hex_dump();
fprintf(stderr, "input scan range = %s\n", range_str);
input.set(table_id, ob_table_name, range);
input.set_scan_size(100000);
input.add_column((uint64_t)0ull);
ObScanner scanner;
int64_t start = tbsys::CTimeUtil::getTime();
int ret = rpc_cs_scan(client.client_, server, input, scanner);
int64_t end = tbsys::CTimeUtil::getTime();
fprintf(stderr,"rpc_cs_scan time consume:%ld\n", end - start);
if (OB_SUCCESS != ret)
{
fprintf(stderr,"ret:%d\n", ret);
}
else
{
dump_scanner(scanner);
}
return ret;
}
int scan_test_case(
BaseClient& client,
const ObServer& server,
const uint64_t table_id,
const int64_t user_id,
const int8_t item_type,
const int32_t column_size
)
{
ObScanParam input;
const int32_t key_size = 17;
char start_key[key_size] ;
char end_key[key_size] ;
int64_t pos = 0;
encode_i64(start_key, key_size, pos, user_id);
if (item_type <= 1)
encode_i8(start_key, key_size, pos, item_type);
else
encode_i8(start_key, key_size, pos, 0x0);
memset(start_key + pos, 0x0, key_size - pos);
pos = 0;
encode_i64(end_key, key_size, pos, user_id);
if ( item_type <= 1)
encode_i8(end_key, key_size, pos, item_type);
else
encode_i8(end_key, key_size, pos, static_cast<int8_t>(0xFF));
memset(end_key + pos, 0xFF, key_size - pos);
hex_dump(start_key, key_size);
hex_dump(end_key, key_size);
ObString ob_table_name;
ObRange range;
range.table_id_= table_id;
range.start_key_.assign_ptr(start_key, key_size);
range.end_key_.assign_ptr(end_key, key_size);
range.border_flag_.set_inclusive_start();
range.border_flag_.set_inclusive_end();
range.hex_dump();
input.set(table_id, ob_table_name, range);
input.set_scan_size(100000);
for (int i = 0; i < column_size; ++i)
{
input.add_column(i + 2);
}
ObScanner scanner;
int64_t start = tbsys::CTimeUtil::getTime();
int ret = rpc_cs_scan(client.client_, server, input, scanner);
int64_t end = tbsys::CTimeUtil::getTime();
fprintf(stderr,"rpc_cs_scan time consume:%ld\n", end - start);
if (OB_SUCCESS != ret)
{
fprintf(stderr,"ret:%d\n", ret);
}
else
{
dump_scanner(scanner);
}
return ret;
}
int rpc_cs_migrate(ObClientManager& cp,
const ObServer& src,
const ObServer& dest,
const ObRange& range,
bool keep_src)
{
int ret = OB_SUCCESS;
int64_t start = 0, end = 0;
const int32_t BUFFER_SIZE = 2*1024*1024;
char* param_buffer = new char[BUFFER_SIZE];
ObDataBuffer ob_inout_buffer;
ObResultCode rc;
int64_t return_start_pos = 0;
if (NULL == param_buffer)
{
goto exit;
}
ob_inout_buffer.set_data(param_buffer, BUFFER_SIZE);
ret = range.serialize(ob_inout_buffer.get_data(),
ob_inout_buffer.get_capacity(), ob_inout_buffer.get_position());
if (OB_SUCCESS != ret)
{
fprintf(stderr,"serialize migrate range into buffer failed\n");
goto exit;
}
ret = dest.serialize(ob_inout_buffer.get_data(),
ob_inout_buffer.get_capacity(), ob_inout_buffer.get_position());
if (OB_SUCCESS != ret)
{
fprintf(stderr,"serialize dest_server into buffer failed\n");
goto exit;
}
ret = encode_bool(ob_inout_buffer.get_data(),ob_inout_buffer.get_capacity(),ob_inout_buffer.get_position(),keep_src);
if (OB_SUCCESS != ret)
{
fprintf(stderr,"serialize keep_src into buffer failed\n");
goto exit;
}
// send request;
start = tbsys::CTimeUtil::getTime();
ret = cp.send_request(src, OB_CS_MIGRATE, 1, 2000*2000, ob_inout_buffer);
end = tbsys::CTimeUtil::getTime();
fprintf(stderr,"time consume:%ld\n", end - start);
if (OB_SUCCESS != ret)
{
fprintf(stderr,"rpc failed\n");
goto exit;
}
ret = rc.deserialize(ob_inout_buffer.get_data(),
ob_inout_buffer.get_position(), return_start_pos);
if (OB_SUCCESS != ret)
{
fprintf(stderr,"deserialize failed\n");
goto exit;
}
fprintf(stderr,"return rc code:%d, msg:%s\n", rc.result_code_, rc.message_.ptr());
if (OB_SUCCESS != rc.result_code_)
{
goto exit;
}
fprintf(stderr,"return_start_pos:%ld, %ld\n", return_start_pos, ob_inout_buffer.get_position());
exit:
if (param_buffer) delete []param_buffer;
return ret;
}
int MockUpdateServer::handle_mock_scan(ObPacket *ob_packet)
{
int ret = OB_SUCCESS;
ObDataBuffer* data = ob_packet->get_buffer();
if (NULL == data)
{
ret = OB_ERROR;
}
ObScanParam scan_param;
if (OB_SUCCESS == ret)
{
ret = scan_param.deserialize(data->get_data(), data->get_capacity(), data->get_position());
if (ret != OB_SUCCESS)
{
TBSYS_LOG(ERROR, "%s", "check scan_param failed");
}
}
tbnet::Connection* connection = ob_packet->get_connection();
ThreadSpecificBuffer::Buffer* thread_buffer = response_packet_buffer_.get_buffer();
if (NULL == thread_buffer)
{
ret = OB_ERROR;
}
else
{
thread_buffer->reset();
ObDataBuffer out_buffer(thread_buffer->current(), thread_buffer->remain());
ObResultCode result_msg;
result_msg.result_code_ = ret;
ret = result_msg.serialize(out_buffer.get_data(), out_buffer.get_capacity(), out_buffer.get_position());
// fake cell
ObCellInfo cell;
ObScanner scanner;
ObString row_key;
ObString column_name;
cell.table_id_ = scan_param.get_table_id();
if (mock::join_table_id == cell.table_id_)
{
for (int32_t i = 0; i < scan_param.get_column_id_size(); i++)
{
if (mock::join_column1_id == scan_param.get_column_id()[i])
{
row_key.assign((char*)mock::join_rowkey,strlen(mock::join_rowkey));
cell.column_id_ = mock::join_column1_id;
cell.row_key_ = row_key;
cell.value_.set_int(mock::join_column1_ups_value_1,true);
ret = scanner.add_cell(cell);
if (OB_SUCCESS == ret)
{
cell.value_.set_int(mock::join_column1_ups_value_2,true);
ret = scanner.add_cell(cell);
}
}
else if (mock::join_column2_id == scan_param.get_column_id()[i])
{
row_key.assign((char*)mock::join_rowkey,strlen(mock::join_rowkey));
cell.column_id_ = mock::join_column2_id;
cell.row_key_ = row_key;
cell.value_.set_int(mock::join_column2_ups_value_1,true);
ret = scanner.add_cell(cell);
if (OB_SUCCESS == ret)
{
cell.value_.set_int(mock::join_column2_ups_value_2,true);
ret = scanner.add_cell(cell);
}
}
else
{
TBSYS_LOG(ERROR, "unepxected column id [tableid:%lu,columnid:%lu]", cell.table_id_,
scan_param.get_column_id()[i]);
ret = OB_ERR_UNEXPECTED;
}
}
}
else if (mock::table_id == cell.table_id_)
{
for (int32_t i = 0; i < scan_param.get_column_id_size(); i++)
{
if (mock::column1_id == scan_param.get_column_id()[i])
{
row_key.assign((char*)mock::rowkey,strlen(mock::rowkey));
cell.column_id_ = mock::column1_id;
cell.row_key_ = row_key;
cell.value_.set_int(mock::column1_ups_value_1,true);
ret = scanner.add_cell(cell);
if (OB_SUCCESS == ret)
{
cell.value_.set_int(mock::column1_ups_value_2,true);
ret = scanner.add_cell(cell);
}
}
else if (mock::column2_id == scan_param.get_column_id()[i])
{
row_key.assign((char*)mock::rowkey,strlen(mock::rowkey));
cell.column_id_ = mock::column2_id;
cell.row_key_ = row_key;
cell.value_.set_int(mock::column2_ups_value_1,true);
ret = scanner.add_cell(cell);
if (OB_SUCCESS == ret)
{
cell.value_.set_int(mock::column2_ups_value_2,true);
ret = scanner.add_cell(cell);
}
}
else
{
TBSYS_LOG(ERROR, "unepxected column id [tableid:%lu,columnid:%lu]", cell.table_id_,
scan_param.get_column_id()[i]);
ret = OB_ERR_UNEXPECTED;
}
}
}
else
{
TBSYS_LOG(ERROR, "unexpected table id [tableid:%lu]", cell.table_id_);
ret = OB_ERR_UNEXPECTED;
}
if (OB_SUCCESS == ret)
{
ret = scanner.set_is_req_fullfilled(true,1);
// scanner.set_timestamp(mock::schema_timestamp);
}
int64_t pos = 0;
char range_buf[512];
ObString range_str;
if (OB_SUCCESS == ret)
{
ObRange range;
range.border_flag_.set_min_value();
range.border_flag_.set_max_value();
ret = range.serialize(range_buf,sizeof(range_buf),pos);
if (OB_SUCCESS == ret)
{
range_str.assign(range_buf,pos);
// ret = scanner.set_ext_info(range_str);
}
pos = 0;
TBSYS_LOG(INFO, "pos:%ld,ret:%d",pos,
range.deserialize(range_str.ptr(),range_str.length(),pos));
}
int32_t channel_id = ob_packet->getChannelId();
if (OB_SUCCESS == ret)
{
ret = scanner.serialize(out_buffer.get_data(), out_buffer.get_capacity(), out_buffer.get_position());
}
if (OB_SUCCESS == ret)
{
ret = send_response(OB_GET_RESPONSE, 1, out_buffer, connection, channel_id);
}
}
TBSYS_LOG(INFO, "handle scan root table result:ret[%d]", ret);
return ret;
}
// 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;
}
int ObScanParamLoader::get_org_scan_param(ObScanParam ¶m)
{
ObRange range;
ObString column;
ObString table_name;
ObPostfixExpression comp;
if (config_loaded_)
{
TBSYS_LOG(INFO, "creating org scan param");
param.reset();
range.reset();
range.table_id_ = table_id_;
range.start_key_ = range_start_;
if (range_start_inclusive_)
range.border_flag_.set_inclusive_start();
else
range.border_flag_.unset_inclusive_start();
if (range_start_min_)
range.border_flag_.set_min_value();
range.end_key_ = range_end_;
if (range_end_inclusive_)
range.border_flag_.set_inclusive_end();
else
range.border_flag_.unset_inclusive_end();
if (range_end_max_)
range.border_flag_.set_max_value();
param.set(table_id_, table_name_, range, true);
param.set_scan_direction(scan_direction_==0?ObScanParam::FORWARD:ObScanParam::BACKWARD);
param.set_limit_info(limit_offset_, limit_count_);
int i = 0;
for (i = 0; i < column_id_count_; i++)
{
param.add_column(column_id_[i], column_is_return_[i]);
}
for (i = 0; i < complex_column_id_count_; i++)
{
param.add_column(complex_column_id_[i],complex_column_id_[i], complex_column_is_return_[i]);
}
for (i = 0; i < orderby_column_id_count_; i++)
{
param.add_orderby_column(orderby_column_id_[i],
orderby_column_order_[i]==0?ObScanParam::ASC:ObScanParam::DESC);
}
if (where_cond_.length() > 0 && where_cond_.ptr() != NULL)
{
param.add_where_cond(where_cond_);
}
// groupby param
for (i = 0; i < groupby_column_id_count_; i++)
{
param.get_group_by_param().add_groupby_column(groupby_column_id_[i], groupby_column_is_return_[i]);
}
for (i = 0; i < groupby_complex_column_id_count_; i++)
{
param.get_group_by_param().add_column(groupby_complex_column_id_[i],
groupby_complex_column_id_[i],
groupby_complex_column_is_return_[i]);
}
if (having_cond_.length() > 0 && having_cond_.ptr() != NULL)
{
param.get_group_by_param().add_having_cond(having_cond_);
}
/// FIXME: SUM占位, 需要添加OP域
for (i = 0; i < agg_column_id_count_; i++)
{
param.get_group_by_param().add_aggregate_column(agg_column_id_[i],
agg_column_as_name_[i],
(ObAggregateFuncType)agg_column_op_[i],
agg_column_is_return_[i]);
}
}
return OB_SUCCESS;
}
int ObMergerTabletLocationCache::set(const ObRange & range, const ObMergerTabletLocationList & location)
{
int ret = OB_SUCCESS;
if (!init_)
{
TBSYS_LOG(ERROR, "%s", "check init failed");
ret = OB_INNER_STAT_ERROR;
}
else
{
ObCachePair pair;
// malloc the pair mem buffer
int64_t size = range.get_serialize_size();
ret = tablet_cache_.malloc(pair, static_cast<int32_t>(size), static_cast<int32_t>(location.get_serialize_size()));
if (OB_SUCCESS != ret)
{
TBSYS_LOG(ERROR, "check malloc failed:key_size[%lu], ret[%d]", size, ret);
}
int64_t pos = 0;
// key serialize to the pair
if (OB_SUCCESS == ret)
{
ret = range.serialize(pair.get_key().ptr(), size, pos);
if (ret != OB_SUCCESS)
{
TBSYS_LOG(ERROR, "serialize range failed:ret[%d]", ret);
}
}
// value serialize to the pair
if (OB_SUCCESS == ret)
{
pos = 0;
ret = location.serialize(pair.get_value().ptr(), location.get_serialize_size(), pos);
if (ret != OB_SUCCESS)
{
TBSYS_LOG(ERROR, "serialize locationlist failed:ret[%d]", ret);
}
}
// delete the old cache item
if (OB_SUCCESS == ret)
{
ret = del(range.table_id_, range.end_key_);
if ((ret != OB_SUCCESS) && (ret != OB_ENTRY_NOT_EXIST))
{
TBSYS_LOG(WARN, "del the old item:table[%lu], ret[%d]", range.table_id_, ret);
}
else
{
ret = OB_SUCCESS;
}
}
// add new pair and return the old pair for deletion
if (OB_SUCCESS == ret)
{
ObCachePair oldpair;
ret = tablet_cache_.add(pair, oldpair);
if (ret != OB_SUCCESS)
{
TBSYS_LOG(ERROR, "add the pair failed:ret[%d]", ret);
}
else
{
TBSYS_LOG(DEBUG, "%s", "set tablet location cache succ");
}
}
}
return ret;
}
int ObRange::trim(const ObRange& r, ObStringBuf & string_buf)
{
int ret = OB_SUCCESS;
if(r.table_id_ != table_id_)
{
ret = OB_ERROR;
TBSYS_LOG(WARN, "table id is not equal table_id_[%ld] r.table_id_[%ld]",
table_id_, r.table_id_);
}
if(OB_SUCCESS == ret)
{
if( 0 == compare_with_startkey2(r) ) // left interval equal
{
if( 0 == compare_with_endkey2(r) ) // both interval equal
{
ret = OB_EMPTY_RANGE;
}
else
{
if( compare_with_endkey2(r) > 0 ) // right interval great
{
border_flag_.unset_min_value();
if(r.border_flag_.inclusive_end())
{
border_flag_.unset_inclusive_start();
}
else
{
border_flag_.set_inclusive_start();
}
ret = string_buf.write_string(r.end_key_, &start_key_);
if(OB_SUCCESS != ret)
{
TBSYS_LOG(WARN, "write start key fail:ret[%d]", ret);
}
}
else
{
ret = OB_ERROR;
TBSYS_LOG(DEBUG, "dump this range");
dump();
TBSYS_LOG(DEBUG, "dump r range");
r.dump();
TBSYS_LOG(WARN, "r should be included by this range");
}
}
}
else if( 0 == compare_with_endkey2(r) ) // right interval equal
{
if( compare_with_startkey2(r) < 0 ) // left interval less
{
border_flag_.unset_max_value();
if(r.border_flag_.inclusive_start())
{
border_flag_.unset_inclusive_end();
}
else
{
border_flag_.set_inclusive_end();
}
ret = string_buf.write_string(r.start_key_, &end_key_);
if(OB_SUCCESS != ret)
{
TBSYS_LOG(WARN, "write end key fail:ret[%d]", ret);
}
}
else
{
ret = OB_ERROR;
TBSYS_LOG(DEBUG, "dump this range");
dump();
TBSYS_LOG(DEBUG, "dump r range");
r.dump();
TBSYS_LOG(WARN, "r should be included by this range");
}
}
else
{
ret = OB_ERROR;
TBSYS_LOG(DEBUG, "dump this range");
dump();
TBSYS_LOG(DEBUG, "dump r range");
r.dump();
TBSYS_LOG(WARN, "r should be included by this range");
}
}
return ret;
}