int ObGetScanProxy::build_get_column_filter(const ObGetParam& get_param,
const int32_t offset,const int32_t size,
ColumnFilter& cf)
{
int ret = OB_SUCCESS;
cf.clear();
for(int32_t i=0; (OB_SUCCESS == ret) && (i < size); ++i)
{
ret = cf.add_column(get_param[offset + i]->column_id_);
}
return ret;
}
void get_table(const ObList<ITableEntity*> &tlist)
{
int ret = OB_SUCCESS;
uint64_t table_id = 1001;
ObString row_key(17, 17, "rk0001_00000000000");
ObList<ITableEntity*>::const_iterator iter;
int64_t index = 0;
for (iter = tlist.begin(); iter != tlist.end(); iter++, index++)
{
ITableEntity *table_entity = *iter;
ITableUtils *table_utils = table_entity->get_tsi_tableutils(index);
assert(NULL != table_utils);
table_utils->reset();
TableTransHandle *trans_handle = &(table_utils->get_trans_handle());
assert(NULL != trans_handle);
ITableIterator *titer = &(table_utils->get_table_iter());
assert(NULL != titer);
ColumnFilter *cf = ITableEntity::get_tsi_columnfilter();
assert(NULL != cf);
cf->add_column(0);
ret = table_entity->start_transaction(*trans_handle);
assert(OB_SUCCESS == ret);
//ret = table_entity->get(*trans_handle, table_id, row_key, cf, titer);
//assert(OB_SUCCESS == ret);
ObRange range;
range.table_id_ = table_id;
range.border_flag_.set_inclusive_start();
range.border_flag_.set_inclusive_end();
range.start_key_.assign_ptr("rk0001_0000000000", 17);
range.end_key_.assign_ptr("rk0002_0000000000", 17);
//range.border_flag_.set_min_value();
//range.border_flag_.set_max_value();
ObScanParam scan_param;
//scan_param.set_is_result_cached(true);
scan_param.set(table_id, ObString(), range);
scan_param.add_column(5);
scan_param.add_column(6);
scan_param.add_column(7);
ret = table_entity->scan(*trans_handle, scan_param, titer);
while (OB_SUCCESS == titer->next_cell())
{
ObCellInfo *cell_info = NULL;
bool is_row_changed = false;
if (OB_SUCCESS == titer->get_cell(&cell_info, &is_row_changed))
{
fprintf(stderr, "[result] %s %d\n", print_cellinfo(cell_info), is_row_changed);
}
}
fprintf(stderr, "[result] ==========\n");
table_utils->reset();
ret = table_entity->end_transaction(*trans_handle);
assert(OB_SUCCESS == ret);
}
thread_read_complete();
}
int ObGetScanProxy::cs_scan(const ObScanParam& scan_param, ObScanner& scanner,
ObIterator* it_out[],int64_t& it_size)
{
int ret = OB_SUCCESS;
int64_t it_num = 0;
if ((NULL == it_out) || it_size <= 0)
{
ret = OB_INVALID_ARGUMENT;
}
if ((OB_SUCCESS == ret) && ((ret = tablet_manager_.scan(scan_param, scanner)) != OB_SUCCESS))
{
TBSYS_LOG(WARN, "failed to scan data from local chunk server, ret=%d", ret);
}
if (OB_SUCCESS == ret)
{
ObSSTableScanner *sstable_scanner =
GET_TSI_MULT(ObSSTableScanner, TSI_CS_SSTABLE_SCANNER_1);
if (NULL == sstable_scanner)
{
TBSYS_LOG(ERROR, "failed to get thread local sstable scanner, "
"sstable_scanner=%p",
sstable_scanner);
ret = OB_ALLOCATE_MEMORY_FAILED;
}
else
{
tablet_range_.reset();
ret = scanner.get_range(tablet_range_);
if (OB_SUCCESS == ret)
{
it_out[it_num++] = sstable_scanner;
}
else
{
TBSYS_LOG(WARN, "failed to get tablet range from scanner, ret=%d", ret);
}
}
}
if (OB_SUCCESS == ret)
{
int64_t query_version = 0;
const ObVersionRange version_range = scan_param.get_version_range();
if (!version_range.border_flag_.is_max_value() && version_range.end_version_ != 0)
{
query_version = version_range.end_version_;
}
ObTablet*& scan_tablet = tablet_manager_.get_cur_thread_scan_tablet();
int32_t compactsstable_num = scan_tablet->get_compactsstable_num();
if (compactsstable_num > 0)
{
ObCompactSSTableMemNode* mem_node = scan_tablet->get_compactsstable_list();
ObCompactMemIteratorArray *its = GET_TSI_MULT(ObCompactMemIteratorArray,TSI_CS_COMPACTSSTABLE_ITERATOR_1);
ColumnFilter* cf = GET_TSI_MULT(ColumnFilter,TSI_CS_COLUMNFILTER_1);
ObCompactSSTableMem* mem = NULL;
int64_t major_version = 0;
int32_t i = 0;
if ((NULL == mem_node) || (NULL == cf) || (NULL == its))
{
TBSYS_LOG(WARN,"unexpect error,mem_node=%p,cf=%p,its=%p",mem_node,cf,its);
ret = OB_ALLOCATE_MEMORY_FAILED;
}
else
{
cf->clear();
}
if ((OB_SUCCESS == ret) && (NULL == (cf = ColumnFilter::build_columnfilter(scan_param, cf))))
{
TBSYS_LOG(WARN,"build columnfilter failed");
ret = OB_ERROR;
}
for(i=0; (mem_node != NULL) && (i < compactsstable_num) && (OB_SUCCESS == ret) && (it_num < it_size);++i)
{
mem = &mem_node->mem_;
if (NULL == mem)
{
TBSYS_LOG(WARN,"unexpect error,compact mem is null");
ret = OB_ERROR;
}
else
{
//query version just have major version
major_version = mem->get_version_range().major_version_;
if ((0 == query_version) || (query_version > 0 && major_version <= query_version))
{
if ((ret = its->iters_[i].init(mem)) != OB_SUCCESS)
{
TBSYS_LOG(WARN,"init iterator of compact mem failed,ret=%d",ret);
}
else if ((ret = its->iters_[i].set_scan_param(*scan_param.get_range(),cf,
scan_param.get_scan_direction() == ScanFlag::BACKWARD))
!= OB_SUCCESS)
{
TBSYS_LOG(WARN,"set scan param failed,ret=%d",ret);
}
else
{
it_out[it_num++] = &its->iters_[i];
//set data version to the last compact sstable version
scanner.set_data_version(mem->get_data_version());
FILL_TRACE_LOG("add compact iterator to merger,it_num:%ld,version:%ld",it_num,mem->get_data_version());
}
}
else
{
break; //got enough data
}
}
mem_node = mem_node->next_;
} //end for
} //end compactsstable_num > 0
}
if (OB_SUCCESS == ret)
{
it_size = it_num;
}
return ret;
}
