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);
ObRange range;
range.border_flag_.set_inclusive_start();
range.start_key_.assign("11111", 5);
range.end_key_.assign("22222", 5);
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);
ASSERT_EQ(OB_SUCCESS, os.set_range(range));
/*** added by wushi ***/
ObCellInfo oci;
oci.table_name_.assign("table1", 6);
oci.row_key_.assign("row1", 4);
oci.column_name_.assign("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("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("table1", 6);
sprintf(row_key_buffer, "row1");
oci.row_key_.assign(row_key_buffer, 4);
oci.column_name_.assign("column1", 7);
oci.value_.set_int(0xff);
ASSERT_EQ(OB_SUCCESS, os.add_cell(oci));
oci.table_name_.assign("table1", 6);
sprintf(row_key_buffer, "row1");
oci.row_key_.assign(row_key_buffer, 4);
oci.column_name_.assign("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("table1", 6);
sprintf(row_key_buffer, "row2");
oci.row_key_.assign(row_key_buffer, 4);
oci.column_name_.assign("column1", 7);
oci.value_.set_int(0xdd);
ASSERT_EQ(OB_SUCCESS, os.add_cell(oci));
oci.table_name_.assign("table2", 6);
sprintf(row_key_buffer, "row2");
oci.row_key_.assign(row_key_buffer, 4);
oci.column_name_.assign("column1", 7);
oci.value_.set_int(0xcc);
ASSERT_EQ(OB_SUCCESS, os.add_cell(oci));
oci.table_name_.assign("table3", 6);
sprintf(row_key_buffer, "row2");
oci.row_key_.assign(row_key_buffer, 4);
oci.column_name_.assign("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));
fprintf(stdout, "serialize_size=%ld pos=%ld", 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("11111", 5);
range.end_key_.assign("22222", 5);
ObRange range2;
range2.border_flag_.set_inclusive_start();
range2.start_key_.assign("11111", 5);
range2.end_key_.assign("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("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;
ASSERT_EQ(OB_BUF_NOT_ENOUGH, os3.serialize(buff, 10, 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("table1", 6);
st.row_key_.assign("row1", 4);
st.column_name_.assign("column1", 7);
st.value_.set_int(0xff);
ObScanner ss;
ss.add_cell(st);
st.table_name_.assign("table2", 6);
st.row_key_.assign("row1", 4);
st.column_name_.assign("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 ObScannerLoader::get_decoded_scanner(ObScanner ¶m)
{
ObNewRange range;
ObString column;
ObString table_name;
char value[4096];
if (config_loaded_)
{
TBSYS_LOG(INFO, "creating scanner");
param.reset();
range.reset();
range.table_id_ = table_id_;
TBSYS_LOG(DEBUG, "range_start_=%s", to_cstring(range_start_));
TBSYS_LOG(DEBUG, "range_end_=%s", to_cstring(range_end_));
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.start_key_.set_min_row();
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.end_key_.set_max_row();
param.set_range(range);
//param.set_is_req_fullfilled(is_fullfilled_, actual_fullfilled_item_num_);
param.set_is_req_fullfilled(is_fullfilled_, fullfilled_item_num_);
param.set_data_version(data_version_);
FILE *fp = NULL;
if ((fp = fopen(data_file_name_, "rb")) == NULL) {
TBSYS_LOG(ERROR, "Fail to open %s", data_file_name_);
}
else
{
while(fgets(value, 4096, fp))
{
/* only digit and string accepted. if not dig, then string */
int start = 0;
int end = 0;
int cnt = 0;
char buf[4096];
int table_id = 0;
int column_cnt = 0;
ObRowkey row_key;
while(true)
{
while(isspace(value[start]))
{
start++;
}
end = start;
while(!isspace(value[end]) && value[end] != '\0')
{
end++;
}
if (start != end)
{
memset(buf, 0, 4096);
cnt = end - start;
strncpy(buf, &value[start], cnt);
buf[cnt] = '\0';
if (column_cnt == 0)
{
table_id = atoi(buf);
}
else if(column_cnt == 1)
{
// TODO build rowkey
//strcpy(row_key_buf, buf);
//row_key.assign(row_key_buf, cnt);
}
else
{
build_cell_info(table_id, row_key, buf, param);
}
column_cnt++;
start = end;
}
if (value[end] == '\0')
{
break;
}
}
}
fclose(fp);
}
}
return OB_SUCCESS;
}
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 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;
}
