int ObScannerLoader::build_cell_info(int table_id, const ObRowkey& row_key, char *buf, ObScanner ¶m)
{
ObCellInfo info;
ObString tmpstr;
uint64_t column_id = OB_INVALID_ID;
char *p = NULL;
info.reset();
//info.table_name_ = table_name_;
info.table_id_ = table_id;
info.row_key_ = row_key;
info.column_id_ = column_id;
if(NULL == (p = strchr(buf, ':')))
{
p = buf;
auto_set_val(info.value_, p);
}
else
{
*p = '\0';
p++;
info.column_id_ = atoi(buf);
auto_set_val(info.value_, p);
}
TBSYS_LOG(DEBUG, "[%lu][%s] [%lu]:[%s]", info.table_id_,
to_cstring(info.row_key_), info.column_id_, p);
actual_fullfilled_item_num_++;
return param.add_cell(info);
}
int MockChunkServer::handle_get_table(ObPacket * ob_packet)
{
int ret = OB_SUCCESS;
ObDataBuffer* data = ob_packet->get_buffer();
if (NULL == data)
{
ret = OB_ERROR;
}
ObGetParam param;
if (OB_SUCCESS == ret)
{
ret = param.deserialize(data->get_data(), data->get_capacity(), data->get_position());
if (ret != OB_SUCCESS)
{
TBSYS_LOG(ERROR, "%s", "check 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 data cell
ObCellInfo cell;
ObScanner scanner;
ObRowkey row_key;
ObString column_name;
char temp[256] = "";
cell.table_id_ = 101;
for (uint64_t i = 0; i < 10; ++i)
{
snprintf(temp, 256, "chunk_%lu_get_row_key:%lu", i, i);
row_key = make_rowkey(temp, &allocator_);
cell.row_key_ = row_key;
cell.column_id_ = i + 1;
cell.value_.set_int(2234 + i);
scanner.add_cell(cell);
}
scanner.set_is_req_fullfilled(true, 1);
int32_t channel_id = ob_packet->getChannelId();
ret = scanner.serialize(out_buffer.get_data(), out_buffer.get_capacity(), out_buffer.get_position());
//
ret = send_response(OB_GET_RESPONSE, 1, out_buffer, connection, channel_id);
}
TBSYS_LOG(INFO, "handle get table result:ret[%d]", ret);
return ret;
}
int ObFinalResult::get(const ObGetParam &get_param, ObScanner &scanner,bool ret_null)
{
int err = OB_SUCCESS;
ObRowInfo row_info;
ObCellInfo cur_cell;
map<ObRowInfo, vector<ObCellInfo> >::iterator target;
bool prev_row_not_exist = false;
for (int64_t get_idx = 0 ; OB_SUCCESS == err && get_idx < get_param.get_cell_size(); get_idx ++)
{
row_info.table_name_ = get_param[get_idx]->table_name_;
row_info.row_key_ = get_param[get_idx]->row_key_;
cur_cell = *(get_param[get_idx]);
target = row_infos_->lower_bound(row_info);
if (get_idx > 0
&& prev_row_not_exist
&& get_param[get_idx]->table_name_ == get_param[get_idx-1]->table_name_
&& get_param[get_idx]->row_key_ == get_param[get_idx-1]->row_key_
)
{
continue;
}
if (row_infos_->end() == target
|| row_info < target->first
|| target->second.size() == 0)
{
prev_row_not_exist = true;
cur_cell.value_.set_ext(ObActionFlag::OP_ROW_DOES_NOT_EXIST);
}
else
{
prev_row_not_exist = false;
vector<ObCellInfo>::iterator beg = target->second.begin();
for (;beg != target->second.end(); beg ++)
{
if (beg->column_name_ == cur_cell.column_name_)
{
cur_cell = *beg;
break;
}
}
if (target->second.end() == beg)
{
if (ret_null)
{
cur_cell.value_.set_null();
}
else
{
cur_cell.value_.set_ext(ObActionFlag::OP_NOP);
}
}
}
cur_cell.table_id_ = OB_INVALID_ID;
cur_cell.column_id_ = OB_INVALID_ID;
err = scanner.add_cell(cur_cell);
}
return err;
}
void gen_scanner(ObScanner& scanner)
{
ObCellInfo cell_info;
strcpy(t, "test_table");
strcpy(c, "name");
strcpy(rowkey, "10000");
cell_info.table_name_.assign_ptr(t, static_cast<int32_t>(strlen(t)));
//cell_info.table_id_ = 3;
cell_info.column_name_.assign_ptr(c, static_cast<int32_t>(strlen(c)));
//cell_info.column_id_ = 2;
cell_info.row_key_.assign_ptr(rowkey, static_cast<int32_t>(strlen(rowkey)));
cell_info.value_.set_int(3);
ASSERT_EQ(OB_SUCCESS, scanner.add_cell(cell_info));
strcpy(c, "value");
cell_info.column_name_.assign_ptr(c, static_cast<int32_t>(strlen(c)));
//cell_info.column_id_ = 3;
cell_info.value_.set_varchar(ObString(0, static_cast<int32_t>(strlen(value_str)), (char*)value_str));
ASSERT_EQ(OB_SUCCESS, scanner.add_cell(cell_info));
cell_info.value_.set_int(3);
strcpy(c, "name");
cell_info.column_name_.assign_ptr(c, static_cast<int32_t>(strlen(c)));
//cell_info.column_id_ = 2;
strcpy(rowkey, "10001");
cell_info.row_key_.assign_ptr(rowkey, static_cast<int32_t>(strlen(rowkey)));
ASSERT_EQ(OB_SUCCESS, scanner.add_cell(cell_info));
cell_info.value_.set_varchar(ObString(0, static_cast<int32_t>(strlen(value_str)), (char*)value_str));
strcpy(c, "value");
cell_info.column_name_.assign_ptr(c, static_cast<int32_t>(strlen(c)));
//cell_info.column_id_ = 3;
ASSERT_EQ(OB_SUCCESS, scanner.add_cell(cell_info));
}
void build_scanner(ObIterator &iter, ObScanner &scanner, char *buffer, const int64_t buf_len, int64_t &pos)
{
ObCellInfo *ci = NULL;
while(OB_SUCCESS == iter.next_cell())
{
if (OB_SUCCESS == iter.get_cell(&ci)
&& NULL != ci)
{
scanner.add_cell(*ci);
}
}
scanner.serialize(buffer, buf_len, pos);
}
int ObMergerScannerEncoder::encode(const ObGetParam & get_param, const ObScanner & org_scanner,
ObScanner & encoded_scanner)
{
int ret = OB_SUCCESS;
ObCellInfo * cur_cell = NULL;
ObCellInfo * encode_cell = NULL;
int64_t cell_index = 0;
ObScanner & input = const_cast<ObScanner &> (org_scanner);
while (OB_SUCCESS == (ret = input.next_cell()))
{
ret = input.get_cell(&cur_cell);
if (ret != OB_SUCCESS)
{
TBSYS_LOG(WARN, "get cell from org scanner failed:ret[%d]", ret);
break;
}
// output(*cur_cell);
encode_cell = get_param[cell_index];
if (NULL == encode_cell)
{
ret = OB_ERROR;
TBSYS_LOG(WARN, "check encode cell failed:index[%ld]", cell_index);
break;
}
encode_cell->value_ = cur_cell->value_;
ret = encoded_scanner.add_cell(*encode_cell);
if (ret != OB_SUCCESS)
{
TBSYS_LOG(WARN, "add cell to encoded scanner failed:ret[%d]", ret);
break;
}
++cell_index;
}
// double check size
if (cell_index != get_param.get_cell_size())
{
ret = OB_ERROR;
TBSYS_LOG(WARN, "check result scanner cell count not equal get param cell size:"
"count[%ld], size[%ld]", cell_index, get_param.get_cell_size());
}
input.reset_iter();
// fill all data succ
if (OB_ITER_END == ret)
{
ret = OB_SUCCESS;
}
return ret;
}
int ObGetScanProxy::fill_compact_data(ObIterator& iterator,ObScanner& scanner)
{
int ret = OB_SUCCESS;
ObCellInfo* cell = NULL;
bool is_row_changed = false;
while (OB_SUCCESS == (ret = iterator.next_cell()))
{
ret = iterator.get_cell(&cell,&is_row_changed);
if (OB_SUCCESS != ret || NULL == cell)
{
TBSYS_LOG(WARN, "failed to get cell, cell=%p, err=%d", cell, ret);
}
else
{
ret = scanner.add_cell(*cell, false, is_row_changed);
if (OB_SIZE_OVERFLOW == ret)
{
//TODO
TBSYS_LOG(INFO, "ObScanner size full, cannot add any cell.");
scanner.rollback();
ret = OB_SUCCESS;
break;
}
else if (OB_SUCCESS != ret)
{
TBSYS_LOG(WARN, "failed to add cell to scanner, ret=%d", ret);
}
}
if (OB_SUCCESS != ret)
{
break;
}
}
if (OB_ITER_END == ret)
{
ret = OB_SUCCESS;
}
else if (OB_SUCCESS != ret)
{
TBSYS_LOG(WARN, "retor occurs while iterating, ret=%d", ret);
}
return ret;
}
TEST(TestObScanner, add_cell)
{
ObScanner fem;
fem.set_is_req_fullfilled(true, 1011);
fem.set_data_version(170);
char buf[BUFSIZ];
int64_t pospos = 0;
fem.serialize(buf, BUFSIZ, pospos);
FILE *fd;
fd = fopen("tmptest", "w+");
fwrite(buf, 1, pospos, fd);
fclose(fd);
ObScanner os;
ObScanner ost;
/*** added by wushi ***/
int64_t fullfilled_item = 0;
int64_t tmp = 0;
bool is_fullfilled = true;
bool tmp_bool = false;
/// initialize
ASSERT_EQ(os.get_is_req_fullfilled(tmp_bool, fullfilled_item),0);
EXPECT_FALSE(tmp_bool);
ASSERT_EQ(fullfilled_item,0);
/// set fullfilled
is_fullfilled = true;
fullfilled_item = 1000;
os.set_is_req_fullfilled(is_fullfilled,fullfilled_item);
ASSERT_EQ(os.get_is_req_fullfilled(tmp_bool, tmp),0);
ASSERT_EQ(tmp_bool,is_fullfilled);
ASSERT_EQ(tmp,fullfilled_item);
/*** added by wushi ***/
ObCellInfo oci;
oci.table_name_.assign((char*)"table1", 6);
oci.row_key_.assign((char*)"row1", 4);
oci.column_name_.assign((char*)"column1", 7);
oci.value_.set_int(0xff);
ost.set_mem_size_limit(20);
ASSERT_EQ(OB_SIZE_OVERFLOW, ost.add_cell(oci));
os.set_mem_size_limit(1024 * 1024 * 2);
ASSERT_EQ(OB_SUCCESS, os.add_cell(oci));
oci.column_name_.assign((char*)"column2", 7);
oci.value_.set_int(0xfe);
ASSERT_EQ(OB_SUCCESS, os.add_cell(oci));
ObScannerIterator iter = os.begin();
ObCellInfo tci;
ASSERT_EQ(OB_SUCCESS, iter.get_cell(tci));
ASSERT_EQ(string("table1"), string(tci.table_name_.ptr(), tci.table_name_.length()));
ASSERT_EQ(string("row1"), string(tci.row_key_.ptr(), tci.row_key_.length()));
ASSERT_EQ(string("column1"), string(tci.column_name_.ptr(), tci.column_name_.length()));
ASSERT_EQ(OB_SUCCESS, tci.value_.get_int(tmp));
ASSERT_EQ(0xff, tmp);
iter++;
ASSERT_EQ(OB_SUCCESS, iter.get_cell(tci));
ASSERT_EQ(string("table1"), string(tci.table_name_.ptr(), tci.table_name_.length()));
ASSERT_EQ(string("row1"), string(tci.row_key_.ptr(), tci.row_key_.length()));
ASSERT_EQ(string("column2"), string(tci.column_name_.ptr(), tci.column_name_.length()));
ASSERT_EQ(OB_SUCCESS, tci.value_.get_int(tmp));
ASSERT_EQ(0xfe, tmp);
iter++;
ASSERT_EQ(true, os.end() == iter);
//ObCellInfo oci;
char row_key_buffer[1024];
oci.table_name_.assign((char*)"table1", 6);
sprintf(row_key_buffer, "row1");
oci.row_key_.assign(row_key_buffer, 4);
oci.column_name_.assign((char*)"column1", 7);
oci.value_.set_int(0xff);
ASSERT_EQ(OB_SUCCESS, os.add_cell(oci));
oci.table_name_.assign((char*)"table1", 6);
sprintf(row_key_buffer, "row1");
oci.row_key_.assign(row_key_buffer, 4);
oci.column_name_.assign((char*)"column2", 7);
oci.value_.set_int(0xee);
os.set_mem_size_limit(20);
ASSERT_EQ(OB_SIZE_OVERFLOW, os.add_cell(oci));
os.set_mem_size_limit(1024 * 1024 * 2);
ASSERT_EQ(OB_SUCCESS, os.add_cell(oci));
oci.table_name_.assign((char*)"table1", 6);
sprintf(row_key_buffer, "row2");
oci.row_key_.assign(row_key_buffer, 4);
oci.column_name_.assign((char*)"column1", 7);
oci.value_.set_int(0xdd);
ASSERT_EQ(OB_SUCCESS, os.add_cell(oci));
oci.table_name_.assign((char*)"table2", 6);
sprintf(row_key_buffer, "row2");
oci.row_key_.assign(row_key_buffer, 4);
oci.column_name_.assign((char*)"column1", 7);
oci.value_.set_int(0xcc);
ASSERT_EQ(OB_SUCCESS, os.add_cell(oci));
oci.table_name_.assign((char*)"table3", 6);
sprintf(row_key_buffer, "row2");
oci.row_key_.assign(row_key_buffer, 4);
oci.column_name_.assign((char*)"column1", 7);
oci.value_.set_int(0xbb);
ASSERT_EQ(OB_SUCCESS, os.add_cell(oci));
fprintf(stdout, "size=%ld\n", os.get_serialize_size());
char buffer[2048];
int64_t pos = 0;
ASSERT_EQ(OB_SUCCESS, os.serialize(buffer, 1024, pos));
ASSERT_EQ(pos, os.get_serialize_size());
fd = fopen("./test.data.before_rollback", "w+");
fwrite(buffer, 1, 1024, fd);
fclose(fd);
for (iter = os.begin(); iter != os.end(); iter++)
{
ObCellInfo ci;
ASSERT_EQ(OB_SUCCESS, iter.get_cell(ci));
fprintf(stdout, "table_name=[%.*s] row_key=[%.*s] column_name=[%.*s]\n",
ci.table_name_.length(), ci.table_name_.ptr(),
ci.row_key_.length(), ci.row_key_.ptr(),
ci.column_name_.length(), ci.column_name_.ptr());
}
fprintf(stdout, "==============================\n");
while (OB_SUCCESS == os.next_cell())
{
ObCellInfo *ci = NULL;
bool is_row_changed;
ASSERT_EQ(OB_SUCCESS, os.get_cell(&ci, &is_row_changed));
fprintf(stdout, "table_name=[%.*s] row_key=[%.*s] column_name=[%.*s] "
"table_id=[%lu] column_id=[%lu] row_changed=[%d]\n",
ci->table_name_.length(), ci->table_name_.ptr(),
ci->row_key_.length(), ci->row_key_.ptr(),
ci->column_name_.length(),ci->column_name_.ptr(),
ci->table_id_, ci->column_id_, is_row_changed);
}
os.reset_iter();
fprintf(stdout, "==============================\n");
ASSERT_EQ(OB_SUCCESS, os.rollback());
fprintf(stdout, "size=%ld\n", os.get_serialize_size());
pos = 0;
ASSERT_EQ(OB_SUCCESS, os.serialize(buffer, 1024, pos));
ASSERT_EQ(pos, os.get_serialize_size());
fd = fopen("./test.data.after_rollback", "w+");
fwrite(buffer, 1, 1024, fd);
fclose(fd);
for (iter = os.begin(); iter != os.end(); iter++)
{
ObCellInfo ci;
ASSERT_EQ(OB_SUCCESS, iter.get_cell(ci));
fprintf(stdout, "table_name=[%.*s] row_key=[%.*s] column_name=[%.*s]\n",
ci.table_name_.length(), ci.table_name_.ptr(),
ci.row_key_.length(), ci.row_key_.ptr(),
ci.column_name_.length(), ci.column_name_.ptr());
ASSERT_EQ(OB_SUCCESS, iter.get_cell(ci));
fprintf(stdout, "table_name=[%.*s] row_key=[%.*s] column_name=[%.*s]\n",
ci.table_name_.length(), ci.table_name_.ptr(),
ci.row_key_.length(), ci.row_key_.ptr(),
ci.column_name_.length(), ci.column_name_.ptr());
}
fprintf(stdout, "==============================\n");
while (OB_SUCCESS == os.next_cell())
{
ObCellInfo *ci = NULL;
bool is_row_changed;
ASSERT_EQ(OB_SUCCESS, os.get_cell(&ci, &is_row_changed));
fprintf(stdout, "table_name=[%.*s] row_key=[%.*s] column_name=[%.*s] "
"table_id=[%lu] column_id=[%lu] row_changed=[%d]\n",
ci->table_name_.length(), ci->table_name_.ptr(),
ci->row_key_.length(), ci->row_key_.ptr(),
ci->column_name_.length(),ci->column_name_.ptr(),
ci->table_id_, ci->column_id_, is_row_changed);
ASSERT_EQ(OB_SUCCESS, os.get_cell(&ci, &is_row_changed));
fprintf(stdout, "table_name=[%.*s] row_key=[%.*s] column_name=[%.*s] "
"table_id=[%lu] column_id=[%lu] row_changed=[%d]\n",
ci->table_name_.length(), ci->table_name_.ptr(),
ci->row_key_.length(), ci->row_key_.ptr(),
ci->column_name_.length(),ci->column_name_.ptr(),
ci->table_id_, ci->column_id_, is_row_changed);
}
os.reset_iter();
fprintf(stdout, "==============================\n");
pos = 0;
ASSERT_EQ(OB_SUCCESS, os.deserialize(buffer, os.get_serialize_size(), pos));
ASSERT_EQ(pos, os.get_serialize_size());
for (iter = os.begin(); iter != os.end(); iter++)
{
ObCellInfo ci;
ASSERT_EQ(OB_SUCCESS, iter.get_cell(ci));
fprintf(stdout, "table_name=[%.*s] row_key=[%.*s] column_name=[%.*s]\n",
ci.table_name_.length(), ci.table_name_.ptr(),
ci.row_key_.length(), ci.row_key_.ptr(),
ci.column_name_.length(), ci.column_name_.ptr());
ASSERT_EQ(OB_SUCCESS, iter.get_cell(ci));
fprintf(stdout, "table_name=[%.*s] row_key=[%.*s] column_name=[%.*s]\n",
ci.table_name_.length(), ci.table_name_.ptr(),
ci.row_key_.length(), ci.row_key_.ptr(),
ci.column_name_.length(), ci.column_name_.ptr());
}
fprintf(stdout, "==============================\n");
while (OB_SUCCESS == os.next_cell())
{
ObCellInfo *ci = NULL;
bool is_row_changed;
ASSERT_EQ(OB_SUCCESS, os.get_cell(&ci, &is_row_changed));
fprintf(stdout, "table_name=[%.*s] row_key=[%.*s] column_name=[%.*s] "
"table_id=[%lu] column_id=[%lu] row_changed=[%d]\n",
ci->table_name_.length(), ci->table_name_.ptr(),
ci->row_key_.length(), ci->row_key_.ptr(),
ci->column_name_.length(),ci->column_name_.ptr(),
ci->table_id_, ci->column_id_, is_row_changed);
}
os.reset_iter();
/// set fullfilled
// ASSERT_EQ(os.get_is_req_fullfilled(tmp_bool, tmp),0);
// ASSERT_EQ(tmp_bool,is_fullfilled);
// ASSERT_EQ(tmp,fullfilled_item);
{
ObRange range;
range.border_flag_.set_inclusive_start();
range.start_key_.assign((char*)"11111", 5);
range.end_key_.assign((char*)"22222", 5);
ObRange range2;
range2.border_flag_.set_inclusive_start();
range2.start_key_.assign((char*)"11111", 5);
range2.end_key_.assign((char*)"22222", 5);
int64_t pos = 0;
int64_t data_len = 0;
is_fullfilled = true;
fullfilled_item = 1212;
ObScanner os1;
ObScanner os2;
ASSERT_EQ(os1.set_is_req_fullfilled(is_fullfilled, fullfilled_item),0);
os1.set_data_version(100);
ASSERT_EQ(os1.set_range(range),0);
range.border_flag_.set_inclusive_end();
char buf[1024];
ASSERT_EQ(os1.serialize(buf,sizeof(buf),pos),0);
data_len = pos;
pos = 0;
ASSERT_EQ(os2.deserialize(buf, data_len, pos),0);
memset(buf, 0x00, 1024);
ASSERT_EQ(os2.get_is_req_fullfilled(tmp_bool, tmp),0);
EXPECT_EQ(is_fullfilled, tmp_bool);
ASSERT_EQ(fullfilled_item, tmp);
ASSERT_EQ(os1.get_data_version(),100);
ObRange range3;
ASSERT_EQ(OB_SUCCESS, os2.get_range(range3));
ASSERT_EQ(range2.border_flag_.get_data(), range3.border_flag_.get_data());
ASSERT_EQ(string(range3.start_key_.ptr(), range3.start_key_.length()),
string(range2.start_key_.ptr(), range2.start_key_.length()));
ASSERT_EQ(string(range3.end_key_.ptr(), range3.end_key_.length()),
string(range2.end_key_.ptr(), range2.end_key_.length()));
const int times = 1000000;
ObScanner os3;
ObCellInfo cinull;
cinull.table_name_.assign((char*)"hello", 5);
cinull.value_.set_ext(ObActionFlag::OP_INSERT);
ASSERT_EQ(OB_ERROR, os3.add_cell(cinull));
cinull.value_.set_ext(ObActionFlag::OP_DEL_ROW);
ASSERT_EQ(OB_SUCCESS, os3.add_cell(cinull));
cinull.value_.set_ext(ObActionFlag::OP_ROW_DOES_NOT_EXIST);
ASSERT_EQ(OB_SUCCESS, os3.add_cell(cinull));
int i = 0;
for (; i < times; i++)
{
if (OB_SUCCESS != os3.add_cell(oci))
{
break;
}
}
const int64_t buf_len = 1 << 22;
char* buff = (char*)ob_malloc(buf_len);
int64_t ppos = 0;
int64_t len = os3.get_serialize_size();
ASSERT_EQ(OB_BUF_NOT_ENOUGH, os3.serialize(buff, len - 4, ppos));
ASSERT_EQ(OB_SUCCESS, os3.serialize(buff, buf_len, ppos));
int64_t npos = 0;
ObScanner os4;
ASSERT_EQ(OB_ERROR, os4.deserialize(buff, 10, npos));
ASSERT_EQ(OB_SUCCESS, os4.deserialize(buff, ppos, npos));
ASSERT_EQ(npos, ppos);
int64_t otmp;
oci.value_.get_int(otmp);
ObCellInfo *oo;
int t = 0;
ASSERT_EQ(OB_SUCCESS, os4.next_cell());
ASSERT_EQ(OB_SUCCESS, os4.get_cell(&oo));
ASSERT_EQ(0, oo->row_key_.length());
ASSERT_EQ(string(cinull.table_name_.ptr(), cinull.table_name_.length()), string(oo->table_name_.ptr(), oo->table_name_.length()));
ASSERT_EQ(OB_SUCCESS, oo->value_.get_ext(tmp));
ASSERT_EQ(+ObActionFlag::OP_DEL_ROW, tmp);
ASSERT_EQ(OB_SUCCESS, os4.next_cell());
ASSERT_EQ(OB_SUCCESS, os4.get_cell(&oo));
ASSERT_EQ(string(cinull.table_name_.ptr(), cinull.table_name_.length()), string(oo->table_name_.ptr(), oo->table_name_.length()));
ASSERT_EQ(OB_SUCCESS, oo->value_.get_ext(tmp));
ASSERT_EQ(+ObActionFlag::OP_ROW_DOES_NOT_EXIST, tmp);
while (OB_SUCCESS == os4.next_cell())
{
ASSERT_EQ(OB_SUCCESS, os4.get_cell(&oo));
t++;
ASSERT_EQ(string(oci.table_name_.ptr(), oci.table_name_.length()), string(oo->table_name_.ptr(), oo->table_name_.length()));
ASSERT_EQ(string(oci.row_key_.ptr(), oci.row_key_.length()), string(oo->row_key_.ptr(), oo->row_key_.length()));
ASSERT_EQ(string(oci.column_name_.ptr(), oci.column_name_.length()), string(oo->column_name_.ptr(), oo->column_name_.length()));
ASSERT_EQ(OB_SUCCESS, oo->value_.get_int(tmp));
ASSERT_EQ(otmp, tmp);
}
ASSERT_EQ(t, i);
ob_free(buff);
}
ObCellInfo st;
st.table_name_.assign((char*)"table1", 6);
st.row_key_.assign((char*)"row1", 4);
st.column_name_.assign((char*)"column1", 7);
st.value_.set_int(0xff);
ObScanner ss;
ss.add_cell(st);
st.table_name_.assign((char*)"table2", 6);
st.row_key_.assign((char*)"row1", 4);
st.column_name_.assign((char*)"column1", 7);
st.value_.set_int(0xff);
ss.add_cell(st);
ObCellInfo *sto;
bool is_row_changed;
ASSERT_EQ(OB_SUCCESS, ss.next_cell());
ASSERT_EQ(OB_SUCCESS, ss.get_cell(&sto, &is_row_changed));
ASSERT_EQ(true, is_row_changed);
ASSERT_EQ(OB_SUCCESS, ss.next_cell());
ASSERT_EQ(OB_SUCCESS, ss.get_cell(&sto, &is_row_changed));
ASSERT_EQ(true, is_row_changed);
ASSERT_EQ(OB_ITER_END, ss.next_cell());
}
int MockRootServer::handle_get_root(ObPacket * ob_packet)
{
int ret = OB_SUCCESS;
ObDataBuffer* data = ob_packet->get_buffer();
if (NULL == data)
{
ret = OB_ERROR;
}
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 location cell
ObScanner scanner;
char table[128] = "";
char rowkey[128] = "";
char temp[128] = "";
ObCellInfo cell;
// the first row
sprintf(table, "root_table");
cell.table_name_.assign(table, static_cast<int32_t>(strlen(table)));
sprintf(rowkey, "row_100");
cell.row_key_.assign(rowkey, static_cast<int32_t>(strlen(rowkey)));
sprintf(temp, "2_ipv4");
cell.column_name_.assign(temp, static_cast<int32_t>(strlen(temp)));
cell.value_.set_int(16777343);
scanner.add_cell(cell);
sprintf(temp, "2_port");
cell.column_name_.assign(temp, static_cast<int32_t>(strlen(temp)));
cell.value_.set_int(10240);
scanner.add_cell(cell);
// the second row
sprintf(rowkey, "row_200");
cell.row_key_.assign(rowkey, static_cast<int32_t>(strlen(rowkey)));
for (int i = 1; i <= 3; ++i)
{
sprintf(temp, "%d_ipv4", i);
cell.column_name_.assign(temp, static_cast<int32_t>(strlen(temp)));
cell.value_.set_int(16777343);
scanner.add_cell(cell);
sprintf(temp, "%d_port", i);
cell.column_name_.assign(temp, static_cast<int32_t>(strlen(temp)));
cell.value_.set_int(12341);
scanner.add_cell(cell);
}
// the third row
sprintf(rowkey, "row_999");
cell.row_key_.assign(rowkey, static_cast<int32_t>(strlen(rowkey)));
for (int i = 1; i <= 3; ++i)
{
sprintf(temp, "%d_ipv4", i);
cell.column_name_.assign(temp, static_cast<int32_t>(strlen(temp)));
cell.value_.set_int(16777343);
scanner.add_cell(cell);
sprintf(temp, "%d_port", i);
cell.column_name_.assign(temp, static_cast<int32_t>(strlen(temp)));
cell.value_.set_int(12341);
scanner.add_cell(cell);
}
int32_t channel_id = ob_packet->getChannelId();
ret = scanner.serialize(out_buffer.get_data(), out_buffer.get_capacity(), out_buffer.get_position());
ret = send_response(OB_REPORT_TABLETS_RESPONSE, 1, out_buffer, connection, channel_id);
TBSYS_LOG(INFO, "send get root response:ret[%d]", ret);
}
TBSYS_LOG(INFO, "handle get root table result:ret[%d]", ret);
return ret;
}
TEST(TestObScanner, get_row)
{
ObScanner scanner;
const int table_num = 10;
const int row_num = 20;
const int column_num = 10;
buffer table_name[table_num];
buffer row_key[row_num];
buffer column_name[column_num];
for (int i = 0; i < table_num; i++)
{
table_name[i].assigne("T").appende(i);
}
for (int i = 0; i < row_num; i++)
{
row_key[i].assigne("R").appende(i);
}
for (int i = 0; i < column_num; i++)
{
column_name[i].assigne("C").appende(i);
}
for (int i = 0; i < table_num; i++)
{
for (int j = 0; j < row_num; j++)
{
for (int k = 0; k < column_num; k++)
{
ObCellInfo cell;
cell.table_name_ = table_name[i].get_obstring();
cell.row_key_ = row_key[j].get_obstring();
cell.column_name_ = column_name[k].get_obstring();
cell.value_.set_int(1);
scanner.add_cell(cell);
}
}
}
ObScanner::RowIterator it = scanner.row_begin();
ASSERT_EQ(it == scanner.row_begin(), true);
for (int i = 0; i < table_num; i++)
{
for (int j = 0; j < row_num; j++)
{
ObCellInfo *row;
int64_t num = 0;
ASSERT_EQ(OB_SUCCESS, scanner.next_row());
ASSERT_EQ(OB_SUCCESS, scanner.get_row(&row, &num));
ASSERT_EQ(column_num, num);
}
}
ASSERT_EQ(OB_ITER_END, scanner.next_row());
buffer buf(1 << 21);
scanner.serialize(buf.ptre(), buf.capacity(), buf.length());
printf("%ld\n", buf.length());
ObScanner dscanner;
int64_t pos = 0;
dscanner.deserialize(buf.ptre(), buf.length(), pos);
for (int i = 0; i < table_num; i++)
{
for (int j = 0; j < row_num; j++)
{
ObCellInfo *row;
int64_t num = 0;
ASSERT_EQ(OB_SUCCESS, dscanner.next_row());
ASSERT_EQ(OB_SUCCESS, dscanner.get_row(&row, &num));
ASSERT_EQ(column_num, num);
}
}
ASSERT_EQ(OB_ITER_END, dscanner.next_row());
scanner.clear();
scanner.set_mem_size_limit(256);
int j = 0, k = 0;
int err = OB_SUCCESS;
for (; j < row_num; j++)
{
for (k = 0; k < column_num; k++)
{
ObCellInfo cell;
cell.table_name_ = table_name[0].get_obstring();
cell.row_key_ = row_key[j].get_obstring();
cell.column_name_ = column_name[k].get_obstring();
cell.value_.set_int(1);
if (OB_SUCCESS != (err = scanner.add_cell(cell)))
{
break;
}
}
if (OB_SUCCESS != err)
{
break;
}
}
if (OB_SUCCESS != err)
{
scanner.rollback();
}
for (int i = 0; i < j; i++)
{
ObCellInfo *row;
int64_t num = 0;
ASSERT_EQ(OB_SUCCESS, scanner.next_row());
ASSERT_EQ(OB_SUCCESS, scanner.get_row(&row, &num));
ASSERT_EQ(column_num, num);
}
ASSERT_EQ(OB_ITER_END, scanner.next_row());
buf.length() = 0;
scanner.serialize(buf.ptre(), buf.capacity(), buf.length());
printf("%ld\n", buf.length());
dscanner.reset();
pos = 0;
dscanner.deserialize(buf.ptre(), buf.length(), pos);
printf("row_num=%ld\n", dscanner.get_row_num());
for (int i = 0; i < j; i++)
{
ObCellInfo *row;
int64_t num = 0;
ASSERT_EQ(OB_SUCCESS, dscanner.next_row());
ASSERT_EQ(OB_SUCCESS, dscanner.get_row(&row, &num));
ASSERT_EQ(column_num, num);
}
ASSERT_EQ(OB_ITER_END, dscanner.next_row());
}
TEST(TestObScanner, row_num)
{
ObScanner scanner;
const int table_num = 3;
const int row_num = 20;
const int column_num = 5;
buffer table_name[table_num];
buffer row_key[row_num];
buffer column_name[column_num];
for (int i = 0; i < table_num; i++)
{
table_name[i].assigne("T").appende(i);
}
for (int i = 0; i < row_num; i++)
{
row_key[i].assigne("R").appende(i);
}
for (int i = 0; i < column_num; i++)
{
column_name[i].assigne("C").appende(i);
}
for (int i = 0; i < table_num; i++)
{
for (int j = 0; j < row_num; j++)
{
for (int k = 0; k < column_num; k++)
{
ObCellInfo cell;
cell.table_name_ = table_name[i].get_obstring();
cell.row_key_ = row_key[j].get_obstring();
cell.column_name_ = column_name[k].get_obstring();
cell.value_.set_int(1);
scanner.add_cell(cell);
}
}
}
ASSERT_EQ(scanner.get_row_num(), table_num * row_num);
ASSERT_EQ(scanner.get_cell_num(), table_num * row_num * column_num);
scanner.set_whole_result_row_num(1000);
buffer buf(1 << 21);
scanner.serialize(buf.ptre(), buf.capacity(), buf.length());
printf("%ld\n", buf.length());
ObScanner dscanner;
int64_t pos = 0;
dscanner.deserialize(buf.ptre(), buf.length(), pos);
EXPECT_EQ(dscanner.get_row_num(), table_num * row_num);
EXPECT_EQ(dscanner.get_cell_num(), table_num * row_num * column_num);
EXPECT_EQ(dscanner.get_whole_result_row_num(), 1000);
scanner.clear();
scanner.set_mem_size_limit(256);
int j = 0, k = 0;
int err = OB_SUCCESS;
for (; j < row_num; j++)
{
k = 0;
for (; k < column_num; k++)
{
ObCellInfo cell;
cell.table_name_ = table_name[0].get_obstring();
cell.row_key_ = row_key[j].get_obstring();
cell.column_name_ = column_name[k].get_obstring();
cell.value_.set_int(1);
if (OB_SUCCESS != (err = scanner.add_cell(cell)))
{
break;
}
}
if (OB_SUCCESS != err)
{
break;
}
}
if (OB_SUCCESS != err)
{
scanner.rollback();
}
EXPECT_EQ(scanner.get_row_num(), j);
EXPECT_EQ(scanner.get_cell_num(), j * column_num);
buf.length() = 0;
scanner.serialize(buf.ptre(), buf.capacity(), buf.length());
printf("%ld\n", buf.length());
dscanner.reset();
pos = 0;
dscanner.deserialize(buf.ptre(), buf.length(), pos);
EXPECT_EQ(dscanner.get_row_num(), j);
EXPECT_EQ(dscanner.get_cell_num(), j * column_num);
}
int MockUpdateServer::handle_get_table(ObPacket * ob_packet)
{
int ret = OB_SUCCESS;
ObDataBuffer* data = ob_packet->get_buffer();
if (NULL == data)
{
ret = OB_ERROR;
}
ObGetParam param;
if (OB_SUCCESS == ret)
{
ret = param.deserialize(data->get_data(), data->get_capacity(), data->get_position());
if (ret != OB_SUCCESS)
{
TBSYS_LOG(ERROR, "%s", "check 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 data cell
ObCellInfo cell;
ObScanner scanner;
ObString row_key;
ObString column_name;
char temp[256] = "";
ObString table_name;
char * name = "update_test_table";
table_name.assign(name, strlen(name));
cell.table_name_ = table_name;
for (uint64_t i = 0; i < 10; ++i)
{
snprintf(temp, 256, "update_%lu_get_row_key:%lu", i, i);
row_key.assign(temp, strlen(temp));
cell.row_key_ = row_key;
column_name.assign(temp, strlen(temp));
cell.column_name_ = column_name;
cell.value_.set_int(2234 + i);
scanner.add_cell(cell);
}
int32_t channel_id = ob_packet->getChannelId();
ret = scanner.serialize(out_buffer.get_data(), out_buffer.get_capacity(), out_buffer.get_position());
//
ret = send_response(OB_SCAN_RESPONSE, 1, out_buffer, connection, channel_id);
}
TBSYS_LOG(INFO, "handle scan root table result:ret[%d]", ret);
return ret;
}
int MockUpdateServer::handle_mock_get(ObPacket *ob_packet)
{
int ret = OB_SUCCESS;
ObDataBuffer* data = ob_packet->get_buffer();
if (NULL == data)
{
ret = OB_ERROR;
}
ObGetParam get_param;
if (OB_SUCCESS == ret)
{
ret = get_param.deserialize(data->get_data(), data->get_capacity(), data->get_position());
if (ret != OB_SUCCESS)
{
TBSYS_LOG(ERROR, "%s", "check 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;
for (int32_t i = 0; i < get_param.get_cell_size(); i ++)
{
cell.table_id_ = get_param[i]->table_id_;
cell.column_id_ = get_param[i]->column_id_;
if (mock::join_table_id == cell.table_id_)
{
if (mock::join_column1_id == cell.column_id_)
{
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 == cell.column_id_)
{
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 if (0 == cell.column_id_)
{
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);
}
if (OB_SUCCESS == ret)
{
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);
}
}
cell.column_id_ = 0;
}
else
{
TBSYS_LOG(ERROR, "unepxected column id [tableid:%lu,columnid:%lu]", cell.table_id_,
cell.column_id_);
ret = OB_ERR_UNEXPECTED;
}
}
else if (mock::table_id == cell.table_id_)
{
if (mock::column1_id == cell.column_id_)
{
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 == cell.column_id_)
{
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_,
cell.column_id_);
ret = OB_ERR_UNEXPECTED;
}
}
else
{
TBSYS_LOG(ERROR, "unexpected table id [tableid:%lu]", cell.table_id_);
ret = OB_ERR_UNEXPECTED;
}
}
if (OB_SUCCESS == ret)
{
int64_t fullfilled_item_num = 0;
if(0 == cell.column_id_)
{
fullfilled_item_num = 1;
}
else
{
fullfilled_item_num = 2;
}
ret = scanner.set_is_req_fullfilled(true,fullfilled_item_num);
//scanner.set_timestamp(mock::schema_timestamp);
}
int32_t channel_id = ob_packet->getChannelId();
ret = scanner.serialize(out_buffer.get_data(), out_buffer.get_capacity(), out_buffer.get_position());
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;
}
int ObFinalResult::scan(const ObScanParam &scan_param, ObScanner &scanner)
{
UNUSED(scanner);
int err = OB_SUCCESS;
char max_key_buf[512];
memset(max_key_buf,0xff, sizeof(max_key_buf));
ObString max_key;
max_key.assign(max_key_buf,sizeof(max_key_buf));
ObRowInfo start;
ObRowInfo end;
map<ObRowInfo, vector<ObCellInfo> >::iterator start_it;
map<ObRowInfo, vector<ObCellInfo> >::iterator end_it;
ObCellInfo cur_cell;
start.table_name_ = scan_param.get_table_name();
end.table_name_ = scan_param.get_table_name();
if (!scan_param.get_range()->border_flag_.is_min_value())
{
start.row_key_ = scan_param.get_range()->start_key_;
}
if (!scan_param.get_range()->border_flag_.is_max_value())
{
end.row_key_ = scan_param.get_range()->end_key_;
}
else
{
end.row_key_ = max_key;
}
if (scan_param.get_range()->border_flag_.inclusive_start())
{
start_it = row_infos_->lower_bound(start);
}
else
{
start_it = row_infos_->upper_bound(start);
}
if (scan_param.get_range()->border_flag_.inclusive_end())
{
end_it = row_infos_->upper_bound(end);
}
else
{
end_it = row_infos_->lower_bound(end);
}
for (;start_it != end_it && OB_SUCCESS == err; start_it ++)
{
for (int64_t scan_idx = 0;
scan_idx < scan_param.get_column_name_size() && OB_SUCCESS == err;
scan_idx ++)
{
vector<ObCellInfo>::iterator cell_it = start_it->second.begin();
cur_cell.table_name_ = scan_param.get_table_name();
cur_cell.row_key_ = start_it->first.row_key_;
cur_cell.column_name_ = scan_param.get_column_name()[scan_idx];
cur_cell.value_.set_null();
for (;cell_it != start_it->second.end(); cell_it ++)
{
if (cell_it->column_name_ == scan_param.get_column_name()[scan_idx])
{
break;
}
}
if (cell_it != start_it->second.end())
{
cur_cell.value_ = cell_it->value_;
}
err = scanner.add_cell(cur_cell);
}
}
return err;
}
int MockChunkServer::handle_scan_table(ObPacket * ob_packet)
{
int ret = OB_SUCCESS;
ObDataBuffer* data = ob_packet->get_buffer();
if (NULL == data)
{
ret = OB_ERROR;
}
ObScanParam param;
if (OB_SUCCESS == ret)
{
ret = param.deserialize(data->get_data(), data->get_capacity(), data->get_position());
if (ret != OB_SUCCESS)
{
TBSYS_LOG(ERROR, "%s", "check 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;
ObRowkey row_key;
ObString column_name;
char temp[256] = "";
#if 1
cell.table_id_ = 101;
for (uint64_t i = 0; i < 10; ++i)
{
snprintf(temp, 256, "chunk_%lu_scan_row_key:%lu", i, i);
row_key = make_rowkey(temp, &allocator_);
cell.row_key_ = row_key;
cell.column_id_ = i + 1;
cell.value_.set_int(2234 + i);
scanner.add_cell(cell);
}
#else
cell.table_id_ = 123;
for (uint64_t i = 100; i < 200; ++i)
{
snprintf(temp, 256, "row_%lu", i);
row_key = make_rowkey(temp, &allocator_);
cell.row_key_ = row_key;
cell.column_id_ = 101;
cell.value_.set_int(2234 + i);
scanner.add_cell(cell);
}
#endif
/* begin add by xiaochu */
//Scanner Range must be set other wise the ms client will report error
ObNewRange range;
/*
/// This will cause rowkey mismatch
//char *start= "chunk_0_scan_row_key:0";
//char *end = "chunk_9_scan_row_key:9";
*/
char *start= (char*)"row_100";
char *end = (char*)"row_200";
range.start_key_ = make_rowkey(start, &allocator_);;
range.end_key_ = make_rowkey(end, &allocator_);
range.table_id_ = 103;
scanner.set_range(range);
scanner.set_is_req_fullfilled(true, 10);
/* end add by xiaochu */
int32_t channel_id = ob_packet->getChannelId();
ret = scanner.serialize(out_buffer.get_data(), out_buffer.get_capacity(), out_buffer.get_position());
ObScannerIterator iter;
for (iter = scanner.begin(); iter != scanner.end(); ++iter)
{
iter.get_cell(cell);
printf("server_temp:%s\n", to_cstring(cell.row_key_));
}//
ret = send_response(OB_SCAN_RESPONSE, 1, out_buffer, connection, channel_id);
}
TBSYS_LOG(INFO, "handle scan table result:ret[%d]", ret);
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;
}
int ObGetScanProxy::get_compact_row(ObTablet& tablet,ObRowkey& rowkey,const int64_t compactsstable_version,
const ColumnFilter *cf,
ObScanner& compact_scanner)
{
int32_t compactsstable_num = tablet.get_compactsstable_num();
ObCompactSSTableMemNode* mem_node = tablet.get_compactsstable_list();
ObCompactMemIteratorArray *its = GET_TSI_MULT(ObCompactMemIteratorArray,TSI_CS_COMPACTSSTABLE_ITERATOR_1);
ObCompactSSTableMem* mem = NULL;
int ret = OB_SUCCESS;
int32_t m = 0;
uint64_t table_id = OB_INVALID_ID;
bool add_row_not_exist = false;
ObMerger merger;
for(m=0; (OB_SUCCESS == ret) &&
(mem_node != NULL) && (m < compactsstable_num); )
{
mem = &mem_node->mem_;
if (NULL == mem)
{
TBSYS_LOG(WARN,"unexpect error,compactsstable is null");
ret = OB_ERROR;
}
else if (ObVersion::compare(mem->get_data_version(),compactsstable_version) <= 0)
{
if (OB_INVALID_ID == table_id)
{
table_id = mem->get_table_id();
}
if (!mem->is_row_exist(rowkey))
{
//row not exists,do nothing
TBSYS_LOG(DEBUG,"row not exist,%s", to_cstring(rowkey));
add_row_not_exist = true;
}
else if ((ret = its->iters_[m].init(mem)) != OB_SUCCESS)
{
TBSYS_LOG(WARN,"init iterator failed,ret=%d",ret);
}
else if ((ret = its->iters_[m].set_get_param(rowkey,cf)) != OB_SUCCESS)
{
TBSYS_LOG(WARN,"set get param failed,ret=%d",ret);
}
else if ((ret = merger.add_iterator(&(its->iters_[m]))) != OB_SUCCESS)
{
TBSYS_LOG(WARN,"add iterator to merger failed,ret=%d",ret);
}
else
{
++m;
//success
}
}
else
{
break; //got enough data
}
mem_node = mem_node->next_;
}
if ((m > 0) && (OB_SUCCESS == ret))
{
if ((ret = fill_compact_data(merger,compact_scanner)) != OB_SUCCESS)
{
TBSYS_LOG(WARN,"fill compact data failed,ret=%d",ret);
}
}
else if ((OB_SUCCESS == ret) && add_row_not_exist)
{
//not exist
ObCellInfo cell;
cell.table_id_ = table_id;
cell.column_id_ = OB_INVALID_ID;
cell.value_.set_ext(ObActionFlag::OP_ROW_DOES_NOT_EXIST);
cell.row_key_ = rowkey;
if ((ret = compact_scanner.add_cell(cell,false,true)) != OB_SUCCESS)
{
TBSYS_LOG(WARN,"add not exist cell failed,ret=%d",ret);
}
}
return ret;
}
int ObMergerGetRequest::fill_result(ObScanner & scanner, ObGetParam &org_param,
bool &got_all_result)
{
int err = OB_SUCCESS;
ObInnerCellInfo *cur_cell = NULL;
bool size_over_flow = false;
bool row_changed = false;
int64_t got_cell_count = 0;
if (!sealed_)
{
TBSYS_LOG(WARN,"request not finished yet");
err = OB_INVALID_ARGUMENT;
}
for (int64_t i = 0; (i < cur_row_cell_cnt_) && (OB_SUCCESS == err); i ++, poped_cell_count_ ++)
{
if ((OB_SUCCESS != (err = scanner.add_cell(row_cells_[i]))))
{
TBSYS_LOG(WARN,"fail to add cell to scanner [err:%d]", err);
}
}
while ((OB_SUCCESS == err) && (!size_over_flow))
{
if ((OB_SUCCESS != (err = merger_operator_.next_cell())) && (OB_ITER_END != err))
{
TBSYS_LOG(WARN,"fail to call next_cell [err:%d]", err);
}
if ((OB_SUCCESS == err) && (OB_SUCCESS != (err = merger_operator_.get_cell(&cur_cell, &row_changed))))
{
TBSYS_LOG(WARN,"fail to get cell from ObGetMerger [err:%d]", err);
}
if (OB_SUCCESS == err)
{
got_cell_count ++;
}
if ((OB_SUCCESS == err) && row_changed)
{
cur_row_cell_cnt_ = 0;
last_not_exist_cell_.table_id_ = OB_INVALID_ID;
}
if ((OB_SUCCESS == err)
&& ((cur_cell->value_.get_ext() == ObActionFlag::OP_ROW_DOES_NOT_EXIST)
|| (cur_cell->value_.get_ext() == ObActionFlag::OP_DEL_TABLE)))
{
if ((OB_INVALID_ID != last_not_exist_cell_.table_id_) && (last_not_exist_cell_.table_id_ == cur_cell->table_id_)
&& (last_not_exist_cell_.row_key_ == cur_cell->row_key_))
{
poped_cell_count_ ++;
continue ;
}
else
{
last_not_exist_cell_ = *cur_cell;
}
}
if ((OB_SUCCESS == err) && (cur_row_cell_cnt_ >= MAX_ROW_COLUMN_COUNT))
{
TBSYS_LOG(WARN,"row cell count is too large [cur_row_cell_cnt_:%ld, MAX_ROW_COLUMN_COUNT:%ld]",
cur_row_cell_cnt_, MAX_ROW_COLUMN_COUNT);
//err = OB_ARRAY_OUT_OF_RANGE;
cur_row_cell_cnt_ = 0;
}
if (OB_SUCCESS == err)
{
row_cells_[cur_row_cell_cnt_].table_id_ = OB_INVALID_ID;
row_cells_[cur_row_cell_cnt_].table_name_ = org_param[poped_cell_count_]->table_name_;
row_cells_[cur_row_cell_cnt_].column_name_ = org_param[poped_cell_count_]->column_name_;
row_cells_[cur_row_cell_cnt_].column_id_ = OB_INVALID_ID;
row_cells_[cur_row_cell_cnt_].row_key_ = cur_cell->row_key_;
row_cells_[cur_row_cell_cnt_].value_ = cur_cell->value_;
++cur_row_cell_cnt_;
}
if (OB_SUCCESS == err)
{
if ((OB_SUCCESS != (err = scanner.add_cell(row_cells_[cur_row_cell_cnt_ - 1]))) && (OB_SIZE_OVERFLOW != err))
{
TBSYS_LOG(WARN,"fail to add cell to result [err:%d]", err);
}
else if (OB_SIZE_OVERFLOW == err)
{
if (OB_SUCCESS != (err = scanner.rollback()))
{
TBSYS_LOG(WARN,"fail to rollback ObScanner [err:%d]", err);
}
else
{
size_over_flow = true;
poped_cell_count_ -= cur_row_cell_cnt_ - 1;
got_cell_count -= cur_row_cell_cnt_;
}
}
else if (OB_SUCCESS == err)
{
poped_cell_count_ ++;
}
}
}
if (OB_ITER_END == err)
{
err = OB_SUCCESS;
}
if (OB_SUCCESS == err)
{
got_all_result = !size_over_flow;
}
if ((OB_SUCCESS == err) && (OB_SUCCESS != (err = scanner.set_is_req_fullfilled(got_all_result,got_cell_count))))
{
TBSYS_LOG(WARN,"fail to set fullfill infomation [err:%d]", err);
}
return err;
}
int ObFakeSqlUpsRpcProxy2::gen_new_scanner(uint64_t table_id, int64_t start_rowkey, int64_t end_rowkey, ObBorderFlag border_flag, ObNewScanner &new_scanner, bool is_fullfilled)
{
int ret = OB_SUCCESS;
char rowkey_buf[100];
ObString rowkey_str;
ObObj rowkey_obj;
ObRowkey rowkey;
ObScanner scanner;
ObNewRange range;
range.table_id_ = table_id;
range.border_flag_ = border_flag;
gen_new_range(start_rowkey, end_rowkey, range_buf_, range);
if(OB_SUCCESS != (ret = scanner.set_range(range)))
{
TBSYS_LOG(WARN, "scanner set range fail:ret[%d]", ret);
}
ObUpsRow ups_row;
ObRowDesc row_desc;
ObObj value;
if(OB_SUCCESS == ret)
{
for(uint64_t i = 0; OB_SUCCESS == ret && i<COLUMN_NUMS; i++)
{
if(OB_SUCCESS != (ret = row_desc.add_column_desc(TABLE_ID, i+OB_APP_MIN_COLUMN_ID)))
{
TBSYS_LOG(WARN, "add column desc fail:ret[%d]", ret);
}
}
ups_row.set_row_desc(row_desc);
}
int64_t start = border_flag.inclusive_start() ? start_rowkey : start_rowkey + 1;
int64_t end = border_flag.inclusive_end() ? end_rowkey : end_rowkey - 1;
ObCellInfo cell_info;
if(OB_SUCCESS == ret)
{
for(int64_t i=start; OB_SUCCESS == ret && i<=end; i++)
{
sprintf(rowkey_buf, "rowkey_%05ld", i);
rowkey_str.assign_ptr(rowkey_buf, (int32_t)strlen(rowkey_buf));
rowkey_obj.set_varchar(rowkey_str);
rowkey.assign(&rowkey_obj, 1);
for(int64_t j=0; OB_SUCCESS == ret && j<COLUMN_NUMS; j++)
{
cell_info.table_id_ = TABLE_ID;
cell_info.row_key_ = rowkey;
cell_info.column_id_ = j+OB_APP_MIN_COLUMN_ID;
cell_info.value_.set_int(i * 1000 + j);
if(OB_SUCCESS != (ret = scanner.add_cell(cell_info)))
{
TBSYS_LOG(WARN, "scanner add cell fail:ret[%d]", ret);
}
}
}
}
int64_t fullfilled_cell_num = (end - start + 1) * COLUMN_NUMS;
if(OB_SUCCESS == ret)
{
if(OB_SUCCESS != (ret = scanner.set_is_req_fullfilled(is_fullfilled, fullfilled_cell_num)))
{
TBSYS_LOG(WARN, "set fullfilled fail:ret[%d]", ret);
}
else if(OB_SUCCESS != (ret = ObNewScannerHelper::convert(scanner, &row_desc, new_scanner)))
{
TBSYS_LOG(WARN, "convert scanner to new scanner fail:ret[%d]", ret);
}
}
return ret;
}