bool MultiGetP::check_result(const uint32_t min_key_include, const uint32_t max_key_include, ObScanner &result,
void *arg)
{
bool res = true;
int err = OB_SUCCESS;
UNUSED(min_key_include);
UNUSED(max_key_include);
ObGetParam *get_param = reinterpret_cast<ObGetParam*>(arg);
ObCellInfo *cur_cell = NULL;
if ((OB_SUCCESS == err) && (result.get_cell_num() != get_param->get_cell_size()))
{
TBSYS_LOG(WARN,"result cell count not correct [got_cell_count:%ld,request_cell_count:%ld]", result.get_cell_num(),
get_param->get_cell_size());
err = OB_ERR_UNEXPECTED;
}
for (int64_t i = 0; (i < get_param->get_cell_size()) && (OB_SUCCESS == err); i++)
{
if ((OB_SUCCESS == err) && (OB_SUCCESS != (err = result.next_cell())))
{
TBSYS_LOG(WARN,"fail to get next cell [err:%d]", err);
}
if ((OB_SUCCESS == err) && (OB_SUCCESS != (err = result.get_cell(&cur_cell))))
{
TBSYS_LOG(WARN,"fail to get next cell [err:%d]", err);
}
if (OB_SUCCESS == err)
{
if ((cur_cell->table_name_ != (*get_param)[i]->table_name_)
|| (cur_cell->column_name_ != (*get_param)[i]->column_name_)
|| (cur_cell->row_key_ != (*get_param)[i]->row_key_)
|| !(msolap::olap_check_cell(*cur_cell)))
{
TBSYS_LOG(WARN,"cell error");
err = OB_ERR_UNEXPECTED;
}
}
}
if ((OB_SUCCESS == err) && (result.next_cell() != OB_ITER_END))
{
TBSYS_LOG(WARN,"result not ended as expected");
err = OB_ERR_UNEXPECTED;
}
if (OB_SUCCESS != err)
{
res = false;
}
return res;
}
void total_scan(const char *fname, PageArena<char> &allocer, MockClient &client, const char *version_range)
{
ObScanner scanner;
ObScanParam scan_param;
read_scan_param(fname, SCAN_PARAM_SECTION, allocer, scan_param);
scan_param.set_version_range(str2range(version_range));
scan_param.set_is_read_consistency(false);
int64_t total_fullfilled_num = 0;
int64_t total_row_counter = 0;
int64_t total_timeu = 0;
while (true)
{
int64_t timeu = tbsys::CTimeUtil::getTime();
int err = client.ups_scan(scan_param, scanner, timeout);
timeu = tbsys::CTimeUtil::getTime() - timeu;
if (OB_SUCCESS != err)
{
fprintf(stdout, "[%s] err=%d\n", __FUNCTION__, err);
break;
}
else
{
int64_t row_counter = 0;
while (OB_SUCCESS == scanner.next_cell())
{
ObCellInfo *ci = NULL;
bool is_row_changed = false;
scanner.get_cell(&ci, &is_row_changed);
//fprintf(stdout, "%s\n", updateserver::print_cellinfo(ci, "CLI_SCAN"));
if (is_row_changed)
{
row_counter++;
}
}
bool is_fullfilled = false;
int64_t fullfilled_num = 0;
ObRowkey last_rk;
scanner.get_last_row_key(last_rk);
scanner.get_is_req_fullfilled(is_fullfilled, fullfilled_num);
fprintf(stdout, "[SINGLE_SCAN] is_fullfilled=%s fullfilled_num=%ld row_counter=%ld timeu=%ld last_row_key=[%s]\n",
STR_BOOL(is_fullfilled), fullfilled_num, row_counter, timeu, to_cstring(last_rk));
total_fullfilled_num += fullfilled_num;
total_row_counter += row_counter;
total_timeu += timeu;
if (is_fullfilled)
{
break;
}
else
{
const_cast<ObNewRange*>(scan_param.get_range())->start_key_ = last_rk;
const_cast<ObNewRange*>(scan_param.get_range())->border_flag_.unset_min_value();
const_cast<ObNewRange*>(scan_param.get_range())->border_flag_.unset_inclusive_start();
}
}
}
fprintf(stdout, "[TOTAL_SCAN] total_fullfilled_num=%ld total_row_counter=%ld total_timeu=%ld\n",
total_fullfilled_num, total_row_counter, total_timeu);
}
int print_scanner(const char * buffer, const int64_t len, int64_t & pos, FILE * file)
{
int ret = OB_SUCCESS;
if ((NULL == buffer) || (NULL == file))
{
TBSYS_LOG(ERROR, "check buffer failed:buff[%p], file[%p]", buffer, file);
ret = OB_ERROR;
}
else
{
ObScanner result;
ret = result.deserialize(buffer, len, pos);
if (ret != OB_SUCCESS)
{
TBSYS_LOG(ERROR, "check deserialize scanner failed:pos[%ld], ret[%d]", pos, ret);
}
else
{
bool first_cell = true;
ObCellInfo * cur_cell = NULL;
ObCellInfo * pre_cell = NULL;
while (result.next_cell() == OB_SUCCESS)
{
ret = result.get_cell(&cur_cell);
if (OB_SUCCESS == ret)
{
pre_cell = cur_cell;
if (first_cell)
{
first_cell = false;
fprintf(file, "table_name:%.*s, rowkey:%.*s\n", cur_cell->table_name_.length(), cur_cell->table_name_.ptr(),
cur_cell->row_key_.length(), cur_cell->row_key_.ptr());
}
/*
fprintf(file, "table_name:%.*s, rowkey:%.*s, column_name:%.*s, ext:%ld, type:%d\n",
cur_cell->table_name_.length(), cur_cell->table_name_.ptr(),
cur_cell->row_key_.length(), cur_cell->row_key_.ptr(),
cur_cell->column_name_.length(), cur_cell->column_name_.ptr(),
cur_cell->value_.get_ext(),cur_cell->value_.get_type());
//cur_cell->value_.dump();
*/
}
else
{
ret = OB_ERROR;
TBSYS_LOG(ERROR, "get cell failed:ret[%d]", ret);
break;
}
}
if (OB_SUCCESS == ret)
{
fprintf(file, "table_name:%.*s, rowkey:%.*s\n", pre_cell->table_name_.length(), pre_cell->table_name_.ptr(),
pre_cell->row_key_.length(), pre_cell->row_key_.ptr());
}
}
}
return ret;
}
bool GetNotExistRows::check_result(const uint32_t min_key_include, const uint32_t max_key_include, ObScanner &result,
void *arg)
{
bool res = true;
int err = OB_SUCCESS;
UNUSED(min_key_include);
UNUSED(max_key_include);
ObGetParam *get_param = reinterpret_cast<ObGetParam*>(arg);
if(result.get_cell_num() != get_param->get_cell_size())
{
TBSYS_LOG(WARN,"result cell number error [got:%ld,expcted:%ld]", result.get_cell_num(), get_param->get_cell_size());
err = OB_ERR_UNEXPECTED;
}
int64_t got_cell_num = 0;
ObCellInfo *cur_cell = NULL;
for (got_cell_num = 0; (got_cell_num < get_param->get_cell_size()) && (OB_SUCCESS == err); got_cell_num++)
{
if (OB_SUCCESS != (err = result.next_cell()))
{
TBSYS_LOG(WARN,"fail to get next cell from result [err:%d]", err);
}
if ((OB_SUCCESS == err) && (OB_SUCCESS != (err = result.get_cell(&cur_cell))))
{
TBSYS_LOG(WARN,"fail to get next cell from result [err:%d]", err);
}
if ((OB_SUCCESS == err)
&& ((cur_cell->table_name_ != msolap::target_table_name)
|| (cur_cell->row_key_ != (*get_param)[got_cell_num]->row_key_)
|| (ObActionFlag::OP_ROW_DOES_NOT_EXIST != cur_cell->value_.get_ext())))
{
TBSYS_LOG(WARN,"cell content error");
err = OB_ERR_UNEXPECTED;
}
}
if ((OB_SUCCESS == err) && (OB_ITER_END != result.next_cell()))
{
TBSYS_LOG(WARN,"fail to get enough cells from result");
err = OB_ERR_UNEXPECTED;
}
if (OB_SUCCESS != err)
{
res = false;
}
return res;
}
bool get_check_row(const ObSchema &schema, const ObString &row_key, CellinfoBuilder &cb,
MockClient &client, const int64_t table_start_version, const bool using_id)
{
bool bret = false;
ObGetParam get_param;
const ObColumnSchema *iter = NULL;
for (iter = schema.column_begin(); iter != schema.column_end(); iter++)
{
ObCellInfo ci;
ci.row_key_ = row_key;
if (using_id)
{
ci.table_id_ = schema.get_table_id();
ci.column_id_ = iter->get_id();
}
else
{
ci.table_name_.assign_ptr(const_cast<char*>(schema.get_table_name()), strlen(schema.get_table_name()));
ci.column_name_.assign_ptr(const_cast<char*>(iter->get_name()), strlen(iter->get_name()));
}
get_param.add_cell(ci);
}
ObVersionRange version_range;
version_range.start_version_ = table_start_version;
version_range.border_flag_.set_max_value();
version_range.border_flag_.set_inclusive_start();
get_param.set_version_range(version_range);
ObScanner scanner;
int ret = client.ups_get(get_param, scanner, TIMEOUT_MS);
if (OB_SUCCESS == ret)
{
RowChecker rc;
while (OB_SUCCESS == scanner.next_cell())
{
ObCellInfo *ci = NULL;
if (OB_SUCCESS == scanner.get_cell(&ci))
{
if (!using_id)
{
trans_name2id(*ci, schema);
}
rc.add_cell(ci);
}
}
bret = rc.check_row(cb, schema);
}
else
{
TBSYS_LOG(WARN, "get ret=%d", ret);
}
return bret;
return true;
}
void print_root_table(FILE* fd, ObScanner &scanner)
{
ObCellInfo* cell = NULL;
bool is_row_changed = false;
while(OB_SUCCESS == scanner.next_cell())
{
if (OB_SUCCESS == scanner.get_cell(&cell, &is_row_changed))
{
if (is_row_changed)
{
fprintf(fd, "\n");
print_rowkey(fd, cell->row_key_);
fprintf(fd, "|");
}
fprintf(fd, "%.*s ", cell->column_name_.length(), cell->column_name_.ptr());
cell->value_.print_value(fd);
fprintf(fd, "|");
}
}
fprintf(fd, "\n");
}
void print_scanner(ObScanner &scanner)
{
int64_t row_counter = 0;
while (OB_SUCCESS == scanner.next_cell())
{
ObCellInfo *ci = NULL;
bool is_row_changed = false;
scanner.get_cell(&ci, &is_row_changed);
fprintf(stdout, "%s\n", common::print_cellinfo(ci, "CLI_SCAN"));
if (is_row_changed)
{
row_counter++;
}
}
bool is_fullfilled = false;
int64_t fullfilled_num = 0;
ObRowkey last_rk;
scanner.get_last_row_key(last_rk);
scanner.get_is_req_fullfilled(is_fullfilled, fullfilled_num);
fprintf(stdout, "is_fullfilled=%s fullfilled_num=%ld row_counter=%ld last_row_key=[%s]\n",
STR_BOOL(is_fullfilled), fullfilled_num, row_counter, to_cstring(last_rk));
}
int param_get(const char *fname, MockClient &client)
{
int err = OB_SUCCESS;
int fd = open(fname, O_RDONLY);
if (-1 == fd)
{
fprintf(stdout, "open [%s] fail errno=%u\n", fname, errno);
err = OB_ERROR;
}
else
{
struct stat st;
fstat(fd, &st);
char *buf = (char*)malloc(st.st_size);
if (NULL == buf)
{
fprintf(stdout, "malloc buf fail size=%ld\n", st.st_size);
err = OB_ERROR;
}
else
{
ssize_t __attribute__((unused)) ret = read(fd, buf, st.st_size);
int64_t pos = 0;
ObGetParam get_param;
if (OB_SUCCESS != get_param.deserialize(buf, st.st_size, pos))
{
fprintf(stdout, "deserialize get_param fail\n");
err = OB_ERROR;
}
else
{
get_param.set_is_read_consistency(false);
ObScanner scanner;
int err = client.ups_get(get_param, scanner, timeout);
fprintf(stdout, "[%s] err=%d\n", __FUNCTION__, err);
if (OB_SUCCESS == err)
{
int64_t row_counter = 0;
while (OB_SUCCESS == scanner.next_cell())
{
ObCellInfo *ci = NULL;
bool is_row_changed = false;
scanner.get_cell(&ci, &is_row_changed);
fprintf(stdout, "%s\n", common::print_cellinfo(ci, "CLI_GET"));
if (is_row_changed)
{
row_counter++;
}
}
bool is_fullfilled = false;
int64_t fullfilled_num = 0;
ObRowkey last_rk;
scanner.get_last_row_key(last_rk);
scanner.get_is_req_fullfilled(is_fullfilled, fullfilled_num);
fprintf(stdout, "is_fullfilled=%s fullfilled_num=%ld row_counter=%ld last_row_key=[%s]\n",
STR_BOOL(is_fullfilled), fullfilled_num, row_counter, to_cstring(last_rk));
}
}
free(buf);
}
close(fd);
}
return err;
}
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());
}
TEST_F(TestGet, test_get_one_row)
{
int err = 0;
CommonSchemaManagerWrapper schema_mgr;
tbsys::CConfig config;
bool ret_val = schema_mgr.parse_from_file("scan_schema.ini", config);
ASSERT_TRUE(ret_val);
ObUpsTableMgr& mgr = ObUpdateServerMain::get_instance()->get_update_server().get_table_mgr();
err = mgr.init();
ASSERT_EQ(0, err);
err = mgr.set_schemas(schema_mgr);
ASSERT_EQ(0, err);
TestUpsTableMgrHelper test_helper(mgr);
TableMgr& table_mgr = test_helper.get_table_mgr();
table_mgr.sstable_scan_finished(10);
TableItem* active_memtable_item = table_mgr.get_active_memtable();
MemTable& active_memtable = active_memtable_item->get_memtable();
// construct multi-row mutator
static const int64_t ROW_NUM = 1;
static const int64_t COL_NUM = 10;
ObCellInfo cell_infos[ROW_NUM][COL_NUM];
char row_key_strs[ROW_NUM][50];
uint64_t table_id = 10;
// init cell infos
for (int64_t i = 0; i < ROW_NUM; ++i)
{
sprintf(row_key_strs[i], "row_key_%08ld", i);
for (int64_t j = 0; j < COL_NUM; ++j)
{
cell_infos[i][j].table_id_ = table_id;
cell_infos[i][j].row_key_.assign(row_key_strs[i], strlen(row_key_strs[i]));
cell_infos[i][j].column_id_ = j + 1;
cell_infos[i][j].value_.set_int(1000 + i * COL_NUM + j);
}
}
ObUpsMutator ups_mutator;
ObMutator &mutator = ups_mutator.get_mutator();
// add cell to array
for (int64_t i = 0; i < ROW_NUM; ++i)
{
for (int64_t j = 0; j < COL_NUM; ++j)
{
ObMutatorCellInfo mutator_cell;
mutator_cell.cell_info = cell_infos[i][j];
mutator_cell.op_type.set_ext(ObActionFlag::OP_UPDATE);
err = mutator.add_cell(mutator_cell);
EXPECT_EQ(0, err);
}
}
// write row to active memtable
MemTableTransHandle write_handle;
err = active_memtable.start_transaction(WRITE_TRANSACTION, write_handle);
ASSERT_EQ(0, err);
ups_mutator.set_mutate_timestamp(0);
err = active_memtable.set(write_handle, ups_mutator);
EXPECT_EQ(0, err);
err = active_memtable.end_transaction(write_handle);
ASSERT_EQ(0, err);
/*
ObString text;
text.assign("/tmp", strlen("/tmp"));
active_memtable.dump2text(text);
*/
for (int64_t i = 0; i < ROW_NUM; ++i)
{
ObScanner scanner;
ObGetParam get_param;
//get_param.set_timestamp(version);
ObVersionRange version_range;
//version_range.start_version_ = version;
//version_range.end_version_ = version;
version_range.start_version_ = 2;
version_range.end_version_ = 2;
version_range.border_flag_.set_inclusive_start();
version_range.border_flag_.set_inclusive_end();
get_param.set_version_range(version_range);
for (int64_t j = 0; j < COL_NUM; ++j)
{
get_param.add_cell(cell_infos[i][j]);
}
int64_t count = 0;
err = mgr.get(get_param, scanner, tbsys::CTimeUtil::getTime(), 2000000000 * 1000L * 1000L);
EXPECT_EQ(0, err);
// check result
count = 0;
while (OB_SUCCESS == scanner.next_cell())
{
ObCellInfo* p_cell = NULL;
scanner.get_cell(&p_cell);
ASSERT_TRUE(p_cell != NULL);
ObCellInfo expected = cell_infos[count / COL_NUM + i][count % COL_NUM];
check_cell(expected, *p_cell);
++count;
}
EXPECT_EQ(COL_NUM, count);
}
}
int64_t MutatorBuilder::get_cur_seed_(const seed_map_t &seed_map, const ObSchema &schema, const ObString &row_key, const bool using_id)
{
int64_t cur_seed = 0;
TEKey te_key;
te_key.table_id = schema.get_table_id();
te_key.row_key = row_key;
int hash_ret = 0;
if (HASH_EXIST != (hash_ret = seed_map.get(te_key, cur_seed)))
{
ObGetParam get_param;
ObScanner scanner;
ObCellInfo cell_info;
cell_info.row_key_ = row_key;
if (using_id)
{
cell_info.table_id_ = schema.get_table_id();
cell_info.column_id_ = SEED_COLUMN_ID;
}
else
{
cell_info.table_name_.assign_ptr(const_cast<char*>(schema.get_table_name()), static_cast<int32_t>(strlen(schema.get_table_name())));
cell_info.column_name_.assign_ptr((char*)SEED_COLUMN_NAME, static_cast<int32_t>(strlen(SEED_COLUMN_NAME)));
}
get_param.add_cell(cell_info);
ObVersionRange version_range;
version_range.start_version_ = table_start_version_;
version_range.border_flag_.set_max_value();
version_range.border_flag_.set_inclusive_start();
get_param.set_version_range(version_range);
if (OB_SUCCESS == client_.get(get_param, scanner))
{
CellinfoBuilder::result_set_t result_set;
MemTank mem_tank;
while (OB_SUCCESS == scanner.next_cell())
{
ObCellInfo *ci = NULL;
if (OB_SUCCESS != scanner.get_cell(&ci))
{
break;
}
if (!using_id)
{
::trans_name2id(*ci, schema);
}
ObCellInfo *new_ci = copy_cell(mem_tank, ci);
CellinfoBuilder::merge_obj(new_ci, result_set);
}
if (0 != result_set.size())
{
ObCellInfo *ret_ci = NULL;
result_set.get(SEED_COLUMN_ID, ret_ci);
if (NULL != ret_ci)
{
ret_ci->value_.get_int(cur_seed);
}
TBSYS_LOG(DEBUG, "seed get from oceanbase %s", print_cellinfo(ret_ci));
}
}
else
{
abort();
}
}
if (0 == cur_seed)
{
cur_seed = SEED_START;
TBSYS_LOG(DEBUG, "first seed from cur_seed=%ld row_key=[%.*s]", cur_seed, row_key.length(), row_key.ptr());
}
else
{
cur_seed += 1;
}
TBSYS_LOG(DEBUG, "get cur_seed=%ld hash_ret=%d row_key=[%.*s]", cur_seed, hash_ret, row_key.length(), row_key.ptr());
return cur_seed;
}
int64_t MutatorBuilder::query_prefix_meta_(const ObSchema &schema, const bool using_id, const int64_t prefix_start, const char *column_name)
{
int64_t ret = 0;
ObGetParam get_param;
ObScanner scanner;
ObCellInfo cell_info;
if (using_id)
{
cell_info.table_id_ = schema.get_table_id();
cell_info.column_id_ = schema.find_column_info(column_name)->get_id();
}
else
{
cell_info.table_name_.assign_ptr(const_cast<char*>(schema.get_table_name()), static_cast<int32_t>(strlen(schema.get_table_name())));
cell_info.column_name_.assign_ptr(const_cast<char*>(column_name), static_cast<int32_t>(strlen(column_name)));
}
char rowkey_info_buffer[1024];
sprintf(rowkey_info_buffer, "%s%020ld", ROWKEY_INFO_ROWKEY, prefix_start);
cell_info.row_key_.assign_ptr(rowkey_info_buffer, static_cast<int32_t>(strlen(rowkey_info_buffer)));
get_param.add_cell(cell_info);
ObVersionRange version_range;
version_range.start_version_ = table_start_version_;
version_range.border_flag_.set_max_value();
version_range.border_flag_.set_inclusive_start();
get_param.set_version_range(version_range);
if (OB_SUCCESS == (ret = client_.get(get_param, scanner)))
{
CellinfoBuilder::result_set_t result_set;
::MemTank mem_tank;
while (OB_SUCCESS == scanner.next_cell())
{
ObCellInfo *ci = NULL;
if (OB_SUCCESS != scanner.get_cell(&ci))
{
break;
}
if (!using_id)
{
::trans_name2id(*ci, schema);
}
ObCellInfo *new_ci = copy_cell(mem_tank, ci);
CellinfoBuilder::merge_obj(new_ci, result_set);
}
if (0 != result_set.size())
{
ObCellInfo *ret_ci = NULL;
result_set.get(schema.find_column_info(column_name)->get_id(), ret_ci);
if (NULL != ret_ci)
{
ret_ci->value_.get_int(ret);
}
}
}
else
{
abort();
}
return ret;
}
void scan_check_all(MutatorBuilder &mb, MockClient &client, const int64_t table_start_version, const bool using_id, const bool check)
{
for (int64_t i = 0; i < mb.get_schema_num(); ++i)
{
ObScanParam scan_param;
prepare_scan_param(scan_param, mb.get_schema(i), table_start_version, using_id);
int ret = OB_SUCCESS;
bool is_fullfilled = false;
int64_t fullfilled_item_num = 0;
RowChecker rc;
int64_t row_counter = 0;
ObScanner scanner;
while (!is_fullfilled
&& OB_SUCCESS == ret)
{
int64_t timeu = tbsys::CTimeUtil::getTime();
ret = client.ups_scan(scan_param, scanner, TIMEOUT_MS);
TBSYS_LOG(INFO, "scan ret=%d timeu=%ld", ret, tbsys::CTimeUtil::getTime() - timeu);
if (check
&& OB_SUCCESS == ret)
{
while (OB_SUCCESS == scanner.next_cell())
{
ObCellInfo *ci = NULL;
bool is_row_changed = false;
if (OB_SUCCESS == scanner.get_cell(&ci, &is_row_changed))
{
if (!using_id)
{
trans_name2id(*ci, mb.get_schema(i));
}
if (is_row_changed && 0 != rc.cell_num())
{
std::string row_key_str(rc.get_cur_rowkey().ptr(), 0, rc.get_cur_rowkey().length());
//fprintf(stderr, "[%.*s] ", rc.get_cur_rowkey().length(), rc.get_cur_rowkey().ptr());
bool get_row_bret = get_check_row(mb.get_schema(i), rc.get_cur_rowkey(), mb.get_cellinfo_builder(i), client, table_start_version, using_id);
//fprintf(stderr, "[get_row check_ret=%d] ", bret);
bool cell_info_bret = rc.check_row(mb.get_cellinfo_builder(i), mb.get_schema(i));
//fprintf(stderr, "[cell_info check_ret=%d]\n", bret);
TBSYS_LOG(INFO, "[%s] [get_row check_ret=%d] [cell_info check_ret=%d]", row_key_str.c_str(), get_row_bret, cell_info_bret);
}
if (is_row_changed
&& 0 != rc.rowkey_num()
&& rc.is_prefix_changed(ci->row_key_))
{
std::string row_key_str(rc.get_last_rowkey().ptr(), 0, rc.get_last_rowkey().length());
//fprintf(stderr, "[%.*s] ", rc.get_last_rowkey().length(), rc.get_last_rowkey().ptr());
bool bret = rc.check_rowkey(mb.get_rowkey_builder(i));
//fprintf(stderr, "row_key check_ret=%d\n", bret);
TBSYS_LOG(INFO, "[%s] [row_key check_ret=%d]", row_key_str.c_str(), bret);
}
rc.add_cell(ci);
if (is_row_changed)
{
rc.add_rowkey(ci->row_key_);
row_counter++;
}
}
}
if (0 != rc.cell_num())
{
std::string row_key_str(rc.get_cur_rowkey().ptr(), 0, rc.get_cur_rowkey().length());
//fprintf(stderr, "[%.*s] ", rc.get_cur_rowkey().length(), rc.get_cur_rowkey().ptr());
bool get_row_bret = get_check_row(mb.get_schema(i), rc.get_cur_rowkey(), mb.get_cellinfo_builder(i), client, table_start_version, using_id);
//fprintf(stderr, "[get_row check_ret=%d] ", bret);
bool cell_info_bret = rc.check_row(mb.get_cellinfo_builder(i), mb.get_schema(i));
//fprintf(stderr, "[cell_info check_ret=%d]\n", bret);
TBSYS_LOG(INFO, "[%s] [get_row check_ret=%d] [cell_info check_ret=%d]", row_key_str.c_str(), get_row_bret, cell_info_bret);
}
}
scanner.get_is_req_fullfilled(is_fullfilled, fullfilled_item_num);
ObRange *range = const_cast<ObRange*>(scan_param.get_range());
scanner.get_last_row_key(range->start_key_);
range->border_flag_.unset_min_value();
range->border_flag_.unset_inclusive_start();
}
if (check
&& 0 != rc.rowkey_num())
{
std::string row_key_str(rc.get_last_rowkey().ptr(), 0, rc.get_last_rowkey().length());
//fprintf(stderr, "[%.*s] ", rc.get_last_rowkey().length(), rc.get_last_rowkey().ptr());
bool bret = rc.check_rowkey(mb.get_rowkey_builder(i));
//fprintf(stderr, "row_key check_ret=%d\n", bret);
TBSYS_LOG(INFO, "[%s] [row_key check_ret=%d]", row_key_str.c_str(), bret);
}
TBSYS_LOG(INFO, "table_id=%lu row_counter=%ld", mb.get_schema(i).get_table_id(), row_counter);
}
}
bool check_result(const ObScanParam &scan_param, ObScanner &ob_scanner,
ObFinalResult & local_result)
{
int err = OB_SUCCESS;
bool res = true;
ObScanner local_scanner;
ObCellInfo *ob_cell = NULL;
ObCellInfo *local_cell = NULL;
err = local_result.scan(scan_param,local_scanner);
if (OB_SUCCESS != err)
{
TBSYS_LOG(WARN,"fail to scan local result");
}
int64_t row_number = 0;
bool ob_end = false;
ObString rowkey;
while (OB_SUCCESS == err)
{
for (int64_t scan_idx = 0; scan_idx < scan_param.get_column_name_size(); scan_idx ++)
{
if (OB_SUCCESS == err)
{
err = ob_scanner.next_cell();
}
if (OB_ITER_END == err && scan_idx == 0)
{
ob_end = true;
err = OB_SUCCESS;
}
else if (OB_SUCCESS == err)
{
err = ob_scanner.get_cell(&ob_cell);
}
if (OB_SUCCESS != err)
{
TBSYS_LOG(WARN,"fail to get cell from ob result [row_idx:%lld,idx:%lld]",
row_number, scan_idx);
}
if (OB_SUCCESS == err)
{
err = local_scanner.next_cell();
if (ob_end && OB_ITER_END != err)
{
TBSYS_LOG(WARN,"local result return more cells than ob result");
err = OB_INVALID_ARGUMENT;
}
if ( !ob_end && OB_ITER_END == err)
{
TBSYS_LOG(WARN,"ob result return more cells than local result");
err = OB_INVALID_ARGUMENT;
}
if (ob_end && OB_ITER_END == err)
{
err = OB_ITER_END;
break;
}
if (OB_SUCCESS == err)
{
err = local_scanner.get_cell(&local_cell);
}
if (OB_SUCCESS != err)
{
TBSYS_LOG(WARN,"fail to get cell from local result [row_idx:%lld,idx:%lld]",
row_number, scan_idx);
}
}
if (OB_SUCCESS == err)
{
if (0 == scan_idx)
{
rowkey = ob_cell->row_key_;
}
/// check ob result
if (ob_cell->table_name_ != scan_param.get_table_name())
{
TBSYS_LOG(WARN,"ob result table name error [row_idx:%lld,idx:%lld,ob.table_name_:%.*s,"
"param.table_name_:%.*s]", row_number, scan_idx,ob_cell->table_name_.length(),
ob_cell->table_name_.ptr(), scan_param.get_table_name().length(),
scan_param.get_table_name().ptr());
err = OB_INVALID_ARGUMENT;
}
if (ob_cell->column_name_ != scan_param.get_column_name()[scan_idx])
{
TBSYS_LOG(WARN,"ob result rowkey error [row_idx:%lld,idx:%lld,ob.column_name_:%.*s,"
"param.column_name_:%.*s]", row_number, scan_idx,ob_cell->column_name_.length(),
ob_cell->column_name_.ptr(), scan_param.get_column_name()[scan_idx].length(),
scan_param.get_column_name()[scan_idx].ptr());
err = OB_INVALID_ARGUMENT;
}
/// check local result
if (local_cell->table_name_ != scan_param.get_table_name())
{
TBSYS_LOG(WARN,"ob result table name error [row_idx:%lld,idx:%lld,ob.table_name_:%.*s,"
"param.table_name_:%.*s]", row_number, scan_idx,local_cell->table_name_.length(),
local_cell->table_name_.ptr(), scan_param.get_table_name().length(),
scan_param.get_table_name().ptr());
err = OB_INVALID_ARGUMENT;
}
if (local_cell->column_name_ != scan_param.get_column_name()[scan_idx])
{
TBSYS_LOG(WARN,"ob result rowkey error [row_idx:%lld,idx:%lld,ob.column_name_:%.*s,"
"param.column_name_:%.*s]", row_number,scan_idx,local_cell->column_name_.length(),
local_cell->column_name_.ptr(), scan_param.get_column_name()[scan_idx].length(),
scan_param.get_column_name()[scan_idx].ptr());
err = OB_INVALID_ARGUMENT;
}
if (local_cell->row_key_ != ob_cell->row_key_)
{
TBSYS_LOG(WARN,"rowkey error [row_idx:%lld,idx:%lld,ob.row_key_:%.*s,"
"local.row_key_:%.*s]", row_number, scan_idx,ob_cell->row_key_.length(),
ob_cell->row_key_.ptr(), local_cell->row_key_.length(),
local_cell->row_key_.ptr());
err = OB_INVALID_ARGUMENT;
}
if (local_cell->row_key_ != rowkey)
{
TBSYS_LOG(WARN,"rowkey error [row_idx:%lld,idx:%lld,ob.row_key_:%.*s,"
"row_first_cell.row_key_:%.*s]", row_number,scan_idx,local_cell->row_key_.length(),
local_cell->row_key_.ptr(), rowkey.length(), rowkey.ptr());
err = OB_INVALID_ARGUMENT;
}
if (OB_SUCCESS == err)
{
if (ob_cell->value_.get_ext() != local_cell->value_.get_ext())
{
TBSYS_LOG(WARN,"ext info not coincident [row_idx:%lld,idx:%lld,"
"ob.ext:%lld,local.ext:%lld]",
row_number, scan_idx, ob_cell->value_.get_ext(), local_cell->value_.get_ext());
err = OB_INVALID_ARGUMENT;
}
if (ob_cell->value_.get_type() == ObNullType
&& ob_cell->value_.get_type() == local_cell->value_.get_type())
{
/// check pass
}
else
{
int64_t ob_value = 0;
int64_t local_value = 0;
if (OB_SUCCESS == err)
{
err = ob_cell->value_.get_int(ob_value);
}
if (OB_SUCCESS == err)
{
err = local_cell->value_.get_int(local_value);
}
if (OB_SUCCESS != err)
{
TBSYS_LOG(WARN,"fail to get int value [row_idx:%lld,idx:%lld]",row_number, scan_idx);
err = OB_INVALID_ARGUMENT;
}
else
{
if (ob_value != local_value)
{
TBSYS_LOG(WARN,"value not coincident [row_idx:%lld,idx:%lld,ob.value:%lld,"
"local.value:%lld]",row_number, scan_idx, ob_value, local_value);
err = OB_INVALID_ARGUMENT;
}
}
}
}
}
}
if (OB_ITER_END == err)
{
err = OB_SUCCESS;
break;
}
row_number ++;
}
if (OB_SUCCESS != err)
{
res = false;
TBSYS_LOG(DEBUG, "check fail");
}
else
{
res = true;
TBSYS_LOG(DEBUG, "check pass");
}
return res;
}
bool check_result(const ObGetParam &get_param, ObScanner &ob_scanner,
ObFinalResult & local_result)
{
int err = OB_SUCCESS;
bool res = true;
ObScanner local_scanner;
ObCellInfo *ob_cell = NULL;
ObCellInfo *local_cell = NULL;
err = local_result.get(get_param,local_scanner);
if (OB_SUCCESS != err)
{
TBSYS_LOG(WARN,"fail to get local result");
}
for (int64_t get_idx = 0;
get_idx < get_param.get_cell_size() && OB_SUCCESS == err;
get_idx ++)
{
int ob_err = ob_scanner.next_cell();
int local_err = local_scanner.next_cell();
if (OB_ITER_END == ob_err && OB_ITER_END == local_err)
{
err = OB_SUCCESS;
break;
}
if (OB_SUCCESS != ob_err)
{
err = ob_err;
TBSYS_LOG(WARN,"ob next cell err");
break;
}
if (OB_SUCCESS != local_err)
{
err = local_err;
TBSYS_LOG(WARN,"local next cell err");
break;
}
if (OB_SUCCESS == err)
{
err = ob_scanner.get_cell(&ob_cell);
}
if (OB_SUCCESS != err)
{
TBSYS_LOG(WARN,"fail to get cell from ob result [idx:%lld]", get_idx);
}
if (OB_SUCCESS == err)
{
if (OB_SUCCESS == err)
{
err = local_scanner.get_cell(&local_cell);
}
if (OB_SUCCESS != err)
{
TBSYS_LOG(WARN,"fail to get cell from local result [idx:%lld]", get_idx);
}
}
if (OB_SUCCESS == err)
{
/*
/// check ob result
if (ob_cell->table_name_ != get_param[get_idx]->table_name_)
{
TBSYS_LOG(WARN,"ob result table name error [idx:%lld,ob.table_name_:%.*s,"
"param.table_name_:%.*s]", get_idx,ob_cell->table_name_.length(),
ob_cell->table_name_.ptr(), get_param[get_idx]->table_name_.length(),
get_param[get_idx]->table_name_.ptr());
err = OB_INVALID_ARGUMENT;
}
if (ob_cell->row_key_ != get_param[get_idx]->row_key_)
{
TBSYS_LOG(WARN,"ob result rowkey error [idx:%lld,ob.row_key_:%.*s,"
"param.row_key_:%.*s]", get_idx,ob_cell->row_key_.length(),
ob_cell->row_key_.ptr(), get_param[get_idx]->row_key_.length(),
get_param[get_idx]->row_key_.ptr());
err = OB_INVALID_ARGUMENT;
}
if (ob_cell->column_name_ != get_param[get_idx]->column_name_)
{
TBSYS_LOG(WARN,"ob result column name error [idx:%lld,ob.column_name_:%.*s,"
"param.column_name_:%.*s]", get_idx,ob_cell->column_name_.length(),
ob_cell->column_name_.ptr(), get_param[get_idx]->column_name_.length(),
get_param[get_idx]->column_name_.ptr());
err = OB_INVALID_ARGUMENT;
}
/// check local result
if (local_cell->table_name_ != get_param[get_idx]->table_name_)
{
TBSYS_LOG(WARN,"local result table name error [idx:%lld,ob.table_name_:%.*s,"
"param.table_name_:%.*s]", get_idx,local_cell->table_name_.length(),
local_cell->table_name_.ptr(), get_param[get_idx]->table_name_.length(),
get_param[get_idx]->table_name_.ptr());
err = OB_INVALID_ARGUMENT;
}
if (local_cell->row_key_ != get_param[get_idx]->row_key_)
{
TBSYS_LOG(WARN,"local result rowkey error [idx:%lld,local.row_key_:%.*s,"
"param.row_key_:%.*s]", get_idx,local_cell->row_key_.length(),
local_cell->row_key_.ptr(), get_param[get_idx]->row_key_.length(),
get_param[get_idx]->row_key_.ptr());
err = OB_INVALID_ARGUMENT;
}
if (local_cell->column_name_ != get_param[get_idx]->column_name_)
{
TBSYS_LOG(WARN,"local result column_name error [idx:%lld,local.column_name_:%.*s,"
"param.column_name_:%.*s]", get_idx,local_cell->column_name_.length(),
local_cell->column_name_.ptr(), get_param[get_idx]->column_name_.length(),
get_param[get_idx]->column_name_.ptr());
err = OB_INVALID_ARGUMENT;
}
*/
TBSYS_LOG(DEBUG, "ob.table_name:%.*s,ob.rowkey:%.*s,ob.column_name:%.*s",
ob_cell->table_name_.length(),ob_cell->table_name_.ptr(),
ob_cell->row_key_.length(),ob_cell->row_key_.ptr(),
ob_cell->column_name_.length(),ob_cell->column_name_.ptr()
);
TBSYS_LOG(DEBUG, "local.table_name:%.*s,local.rowkey:%.*s,local.column_name:%.*s",
local_cell->table_name_.length(),local_cell->table_name_.ptr(),
local_cell->row_key_.length(),local_cell->row_key_.ptr(),
local_cell->column_name_.length(),local_cell->column_name_.ptr()
);
if (local_cell->table_name_ != ob_cell->table_name_)
{
TBSYS_LOG(WARN,"table name not coincident [idx:%lld,ob.table_name_:%.*s,"
"local.table_name_:%.*s]", get_idx,ob_cell->table_name_.length(),
ob_cell->table_name_.ptr(), local_cell->table_name_.length(),
local_cell->table_name_.ptr());
err = OB_INVALID_ARGUMENT;
}
if (local_cell->row_key_ != ob_cell->row_key_)
{
TBSYS_LOG(WARN,"rowkey not coincident [idx:%lld,ob.row_key_:%.*s,"
"local.row_key_:%.*s]", get_idx,ob_cell->row_key_.length(),
ob_cell->row_key_.ptr(), local_cell->row_key_.length(),
local_cell->row_key_.ptr());
err = OB_INVALID_ARGUMENT;
}
if (local_cell->column_name_ != ob_cell->column_name_)
{
TBSYS_LOG(WARN,"column name not coincident [idx:%lld,ob.column_name_:%.*s,"
"local.column_name_:%.*s]", get_idx,ob_cell->column_name_.length(),
ob_cell->column_name_.ptr(), local_cell->column_name_.length(),
local_cell->column_name_.ptr());
err = OB_INVALID_ARGUMENT;
}
if (OB_SUCCESS == err)
{
if (ob_cell->value_.get_ext() != local_cell->value_.get_ext())
{
TBSYS_LOG(WARN,"ext info not coincident [idx:%lld,ob.ext:%lld,local.ext:%lld]",
get_idx, ob_cell->value_.get_ext(), local_cell->value_.get_ext());
err = OB_INVALID_ARGUMENT;
}
if (OB_SUCCESS == err && ObExtendType != ob_cell->value_.get_type())
{
int64_t ob_value;
int64_t local_value;
if (ob_cell->value_.get_ext() != local_cell->value_.get_ext())
{
TBSYS_LOG(WARN,"ext not coincident [idx:%lld,ob.ext:%lld,"
"local.ext:%lld]",get_idx, ob_cell->value_.get_ext(),
local_cell->value_.get_ext());
err = OB_INVALID_ARGUMENT;
}
if (ob_cell->value_.get_ext() == 0 && OB_SUCCESS == err)
{
if (ob_cell->value_.get_type() == ObNullType
&& ob_cell->value_.get_type() == local_cell->value_.get_type())
{
/// check pass
}
else
{
if (OB_SUCCESS == err)
{
err = local_cell->value_.get_int(local_value);
if (OB_SUCCESS != err)
{
TBSYS_LOG(WARN,"fail to get int from local, ext:%lld,type:%d",
local_cell->value_.get_ext(),local_cell->value_.get_type());
}
else
{
TBSYS_LOG(DEBUG, "local value:%lld", local_value);
}
}
if (OB_SUCCESS == err)
{
err = ob_cell->value_.get_int(ob_value);
if (OB_SUCCESS != err)
{
TBSYS_LOG(WARN,"fail to get int from ob, ext:%lld,type:%d",
ob_cell->value_.get_ext(),ob_cell->value_.get_type());
}
else
{
TBSYS_LOG(DEBUG, "ob value:%lld", ob_value);
}
}
if (OB_SUCCESS != err)
{
TBSYS_LOG(WARN,"fail to get int value [idx:%lld]", get_idx);
err = OB_INVALID_ARGUMENT;
}
else
{
if (ob_value != local_value)
{
TBSYS_LOG(WARN,"value not coincident [idx:%lld,ob.value:%lld,"
"local.value:%lld]",get_idx, ob_value, local_value);
err = OB_INVALID_ARGUMENT;
}
}
}
}
}
}
}
}
if (OB_SUCCESS == err && ob_scanner.next_cell() != OB_ITER_END)
{
TBSYS_LOG(WARN,"ob return more result than expected");
}
if (OB_SUCCESS == err && local_scanner.next_cell() != OB_ITER_END)
{
TBSYS_LOG(WARN,"local return more result than expected");
}
if (OB_SUCCESS != err)
{
res = false;
TBSYS_LOG(DEBUG, "check fail");
}
else
{
res = true;
TBSYS_LOG(DEBUG, "check pass");
}
return res;
}
bool GetSingleRowAllColumn::check_result(const uint32_t min_key_include, const uint32_t max_key_include, ObScanner &result,
void *arg)
{
bool res = true;
int err = OB_SUCCESS;
UNUSED(min_key_include);
UNUSED(max_key_include);
ObGetParam *get_param = reinterpret_cast<ObGetParam*>(arg);
uint32_t big_endian_rowkey_val = *(uint32_t*)(((*get_param)[0])->row_key_.ptr());
uint32_t rowkey_val = ntohl(big_endian_rowkey_val);
ObCellInfo target_cell;
target_cell.row_key_.assign((char*)&big_endian_rowkey_val, sizeof(big_endian_rowkey_val));
target_cell.table_name_ = msolap::target_table_name;
if (result.get_cell_num() != msolap::max_column_id - msolap::min_column_id + 1)
{
TBSYS_LOG(WARN,"result cell number error [got:%ld,expcted:%ld]", result.get_cell_num(),
msolap::max_column_id - msolap::min_column_id + 1);
err = OB_ERR_UNEXPECTED;
}
int64_t got_cell_num = 0;
ObCellInfo *cur_cell = NULL;
int64_t intval = 0;
for (got_cell_num = 0; (got_cell_num < result.get_cell_num()) && (OB_SUCCESS == err); got_cell_num++)
{
if (OB_SUCCESS != (err = result.next_cell()))
{
TBSYS_LOG(WARN,"fail to get next cell from result [err:%d]", err);
}
if ((OB_SUCCESS == err) && (OB_SUCCESS != (err = result.get_cell(&cur_cell))))
{
TBSYS_LOG(WARN,"fail to get next cell from result [err:%d]", err);
}
if ((OB_SUCCESS == err)
&& ((cur_cell->table_name_ != msolap::target_table_name)
|| (cur_cell->row_key_ != target_cell.row_key_)
|| (cur_cell->column_name_.length() != 1)
|| (OB_SUCCESS != cur_cell->value_.get_int(intval))))
{
TBSYS_LOG(WARN,"cell content error");
err = OB_ERR_UNEXPECTED;
}
if ((OB_SUCCESS == err) && ((cur_cell->column_name_.ptr()[0] < 'a') || (cur_cell->column_name_.ptr()[0] > 'z')))
{
TBSYS_LOG(WARN,"cell content error");
err = OB_ERR_UNEXPECTED;
}
if (OB_SUCCESS == err)
{
int64_t expect_intval = 0;
char c_name = cur_cell->column_name_.ptr()[0];
switch (c_name)
{
case 'a':
case 'b':
case 'c':
case 'd':
expect_intval = ((unsigned char*)&big_endian_rowkey_val)[c_name - 'a'];
break;
default:
expect_intval = rowkey_val;
}
if (expect_intval != intval)
{
TBSYS_LOG(WARN,"intvalue error [column_name:%c,expect_val:%ld,got_val:%ld,rowkey:%u]", c_name,
expect_intval, intval, rowkey_val);
err = OB_ERR_UNEXPECTED;
}
}
}
if ((OB_SUCCESS == err) && (got_cell_num != msolap::max_column_id - msolap::min_column_id + 1))
{
TBSYS_LOG(WARN,"fail to get enough cells from result");
err = OB_ERR_UNEXPECTED;
}
if ((OB_SUCCESS == err) && (OB_ITER_END != result.next_cell()))
{
TBSYS_LOG(WARN,"fail to get enough cells from result");
err = OB_ERR_UNEXPECTED;
}
if (OB_SUCCESS != err)
{
res = false;
}
return res;
}
