hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
e44cddde95b13f52ff4a24763e2df74e54d77400
oceanbase/src/storage/ob_table_scan_iterator.cpp

887 lines
29 KiB
C++
Raw Blame History

/**
* Copyright (c) 2021 OceanBase
* OceanBase CE is licensed under Mulan PubL v2.
* You can use this software according to the terms and conditions of the Mulan PubL v2.
* You may obtain a copy of Mulan PubL v2 at:
* http://license.coscl.org.cn/MulanPubL-2.0
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PubL v2 for more details.
*/
#include "ob_table_scan_iterator.h"
#include "lib/utility/ob_tracepoint.h"
#include "lib/stat/ob_diagnose_info.h"
#include "common/sql_mode/ob_sql_mode_utils.h"
#include "common/object/ob_obj_compare.h"
#include "storage/blocksstable/ob_storage_cache_suite.h"
#include "storage/ob_multiple_scan_merge.h"
#include "storage/ob_index_merge.h"
#include "storage/ob_partition_store.h"
#include "storage/ob_store_row_filter.h"
#include "ob_warm_up.h"
#include <sys/time.h>
#include <sys/resource.h>
namespace oceanbase {
namespace storage {
using namespace oceanbase::common;
using namespace oceanbase::share::schema;
using namespace oceanbase::blocksstable;
ObTableScanStoreRowIterator::ObTableScanStoreRowIterator()
: is_inited_(false),
single_merge_(NULL),
get_merge_(NULL),
scan_merge_(NULL),
multi_scan_merge_(NULL),
index_merge_(NULL),
row_sample_iterator_(NULL),
block_sample_iterator_(NULL),
main_table_param_(),
main_table_ctx_(),
index_table_param_(),
index_table_ctx_(),
get_table_param_(),
trans_service_(NULL),
ctx_(),
scan_param_(NULL),
partition_store_(NULL),
range_iter_(),
main_iter_(NULL),
row_filter_(NULL),
block_cache_ws_(),
is_iter_opened_(false),
use_fuse_row_cache_(true)
{}
ObTableScanStoreRowIterator::~ObTableScanStoreRowIterator()
{
reset();
}
void ObTableScanStoreRowIterator::reset()
{
// revert store ctx
if (NULL != trans_service_ && NULL != scan_param_ && NULL != scan_param_->trans_desc_) {
int tmp_ret = OB_SUCCESS;
if (OB_SUCCESS !=
(tmp_ret = trans_service_->revert_store_ctx(*scan_param_->trans_desc_, scan_param_->pg_key_, ctx_))) {
STORAGE_LOG(ERROR, "fail to revert store ctx", K(tmp_ret), K(scan_param_->pg_key_));
}
}
if (NULL != single_merge_) {
single_merge_->~ObSingleMerge();
single_merge_ = NULL;
}
if (NULL != get_merge_) {
get_merge_->~ObMultipleGetMerge();
get_merge_ = NULL;
}
if (NULL != scan_merge_) {
scan_merge_->~ObMultipleScanMerge();
scan_merge_ = NULL;
}
if (NULL != multi_scan_merge_) {
multi_scan_merge_->~ObMultipleMultiScanMerge();
multi_scan_merge_ = NULL;
}
if (NULL != index_merge_) {
index_merge_->~ObIndexMerge();
index_merge_ = NULL;
}
if (NULL != row_sample_iterator_) {
row_sample_iterator_->~ObRowSampleIterator();
row_sample_iterator_ = NULL;
}
if (NULL != block_sample_iterator_) {
block_sample_iterator_->~ObBlockSampleIterator();
block_sample_iterator_ = NULL;
}
if (NULL != row_filter_) {
row_filter_->~ObIStoreRowFilter();
row_filter_ = NULL;
}
main_table_param_.reset();
main_table_ctx_.reset();
index_table_param_.reset();
index_table_ctx_.reset();
get_table_param_.reset();
trans_service_ = NULL;
ctx_.reset();
scan_param_ = NULL;
partition_store_ = NULL;
range_iter_.reset();
main_iter_ = NULL;
block_cache_ws_.reset();
is_iter_opened_ = false;
use_fuse_row_cache_ = true;
is_inited_ = false;
}
void ObTableScanStoreRowIterator::reuse_row_iters()
{
if (NULL != single_merge_) {
single_merge_->reuse();
}
if (NULL != get_merge_) {
get_merge_->reuse();
}
if (NULL != scan_merge_) {
scan_merge_->reuse();
}
if (NULL != multi_scan_merge_) {
multi_scan_merge_->reuse();
}
if (NULL != index_merge_) {
index_merge_->reuse();
}
if (NULL != row_sample_iterator_) {
row_sample_iterator_->reuse();
}
if (NULL != block_sample_iterator_) {
block_sample_iterator_->reuse();
}
}
int ObTableScanStoreRowIterator::prepare_table_param()
{
int ret = OB_SUCCESS;
if (nullptr == scan_param_ || nullptr == scan_param_->table_param_) {
ret = OB_INVALID_ARGUMENT;
STORAGE_LOG(WARN, "Invalid argument", K(ret), KP(scan_param_));
} else if (OB_FAIL(main_table_param_.init(*scan_param_))) {
STORAGE_LOG(WARN, "failed to init main table param", K(ret));
} else if (scan_param_->scan_flag_.is_index_back() && OB_FAIL(index_table_param_.init_index_back(*scan_param_))) {
STORAGE_LOG(WARN, "failed to init index table param", K(ret));
}
return ret;
}
int ObTableScanStoreRowIterator::prepare_table_context(const ObIStoreRowFilter* row_filter)
{
int ret = OB_SUCCESS;
if (nullptr == scan_param_ || nullptr == scan_param_->table_param_) {
ret = OB_INVALID_ARGUMENT;
STORAGE_LOG(WARN, "Invalid argument", K(ret), KP(scan_param_));
} else {
ObVersionRange trans_version_range;
trans_version_range.multi_version_start_ = 0;
trans_version_range.base_version_ = 0;
trans_version_range.snapshot_version_ = ctx_.mem_ctx_->get_read_snapshot();
if (OB_UNLIKELY(!trans_version_range.is_valid())) {
ret = OB_ERR_UNEXPECTED;
STORAGE_LOG(WARN, "trans version range is not valid", K(ret), K(trans_version_range));
} else if (OB_FAIL(main_table_ctx_.init(
*scan_param_, ctx_, block_cache_ws_, trans_version_range, row_filter, false /* is_index_back */))) {
STORAGE_LOG(WARN, "failed to init main table ctx", K(ret));
} else if (scan_param_->scan_flag_.is_index_back()) {
if (OB_FAIL(index_table_ctx_.init(
*scan_param_, ctx_, block_cache_ws_, trans_version_range, row_filter, true /* is_index_back */))) {
STORAGE_LOG(WARN, "failed to init index table ctx", K(ret));
} else {
index_table_ctx_.use_fuse_row_cache_ = false;
}
}
if (OB_SUCC(ret)) {
main_table_ctx_.fuse_row_cache_hit_rate_ = scan_param_->fuse_row_cache_hit_rate_;
main_table_ctx_.block_cache_hit_rate_ = scan_param_->block_cache_hit_rate_;
}
}
return ret;
}
int ObTableScanStoreRowIterator::init_scan_iter(const bool index_back, ObMultipleMerge& iter)
{
int ret = OB_SUCCESS;
if (index_back) {
ret = iter.init(index_table_param_, index_table_ctx_, get_table_param_);
} else {
ret = iter.init(main_table_param_, main_table_ctx_, get_table_param_);
}
if (!scan_param_->sample_info_.is_no_sample() && SampleInfo::SAMPLE_INCR_DATA == scan_param_->sample_info_.scope_) {
iter.disable_fill_default();
iter.disable_output_row_with_nop();
}
return ret;
}
int ObTableScanStoreRowIterator::rescan(const ObRangeArray& key_ranges, const ObPosArray& range_array_pos)
{
int ret = OB_SUCCESS;
if (OB_UNLIKELY(!is_inited_)) {
ret = OB_NOT_INIT;
STORAGE_LOG(WARN, "The ObTableScanStoreRowIterator has not been inited, ", K(ret));
} else if (&scan_param_->key_ranges_ != &key_ranges || &scan_param_->range_array_pos_ != &range_array_pos) {
ret = OB_ERR_UNEXPECTED;
STORAGE_LOG(WARN, "scan_param is not the same", K(ret), K(scan_param_), K(key_ranges), K(range_array_pos));
} else {
STORAGE_LOG(DEBUG, "table scan iterate rescan", K_(is_inited), K(scan_param_));
// there's no need to reset main_table_param_ and index_table_param_
// scan_param only reset query range fields in ObTableScan::rt_rescan()
range_iter_.reuse();
main_iter_ = NULL;
reuse_row_iters();
main_table_ctx_.reuse();
index_table_ctx_.reuse();
is_iter_opened_ = false;
if (OB_FAIL(range_iter_.set_scan_param(*scan_param_))) {
STORAGE_LOG(WARN, "set scan param to range iterator failed", K(ret));
} else if (OB_FAIL(prepare_table_context(row_filter_))) {
STORAGE_LOG(WARN, "fail to prepare table context", K(ret));
} else {
if (OB_FAIL(open_iter())) {
STORAGE_LOG(WARN, "fail to open iter", K(ret));
} else {
is_iter_opened_ = true;
}
}
}
return ret;
}
int ObTableScanStoreRowIterator::init(transaction::ObTransService& trans_service, const ObStoreCtx& ctx,
ObTableScanParam& scan_param, ObPartitionStore& partition_store)
{
int ret = OB_SUCCESS;
if (OB_UNLIKELY(is_inited_)) {
ret = OB_INIT_TWICE;
STORAGE_LOG(WARN, "The ObTableScanStoreRowIterator has been inited, ", K(ret));
} else if (OB_UNLIKELY(!ctx.is_valid()) || OB_UNLIKELY(!scan_param.is_valid())) {
ret = OB_INVALID_ARGUMENT;
STORAGE_LOG(WARN, "Invalid argument, ", K(ret), K(ctx.is_valid()), K(scan_param.is_valid()));
} else if (OB_FAIL(range_iter_.set_scan_param(scan_param))) {
STORAGE_LOG(WARN, "Fail to set scan param, ", K(ret));
} else {
if (NULL != scan_param.part_filter_ && NULL != scan_param.part_mgr_) {
void* buf = NULL;
if (NULL == (buf = scan_param.allocator_->alloc(sizeof(ObStoreRowFilter)))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
STORAGE_LOG(ERROR, "alloc store row filter failed", K(ret));
} else if (NULL == (row_filter_ = new (buf) ObStoreRowFilter())) {
ret = OB_ERR_UNEXPECTED;
STORAGE_LOG(ERROR, "new store row filter failed", K(ret), KP(buf));
} else if (OB_FAIL(row_filter_->init(scan_param.part_filter_,
scan_param.expr_ctx_.exec_ctx_,
scan_param.part_mgr_,
scan_param.pkey_))) {
STORAGE_LOG(WARN, "row filter init failed", K(ret));
} else {
// do nothing
}
}
if (OB_SUCC(ret)) {
const uint64_t tenant_id = scan_param.pkey_.get_tenant_id();
use_fuse_row_cache_ = true;
ctx_ = ctx;
scan_param_ = &scan_param;
partition_store_ = &partition_store;
if (OB_FAIL(block_cache_ws_.init(tenant_id))) {
STORAGE_LOG(WARN, "block_cache_ws init failed", K(ret), K(tenant_id));
} else if (OB_FAIL(prepare_table_param())) {
STORAGE_LOG(WARN, "Fail to prepare table param, ", K(ret));
} else if (OB_FAIL(prepare_table_context(row_filter_))) {
STORAGE_LOG(WARN, "Fail to prepare table ctx, ", K(ret));
} else {
if (!is_iter_opened_) {
if (OB_FAIL(open_iter())) {
STORAGE_LOG(WARN, "fail to open iter", K(ret));
} else {
is_iter_opened_ = true;
}
}
if (OB_SUCC(ret)) {
trans_service_ = &trans_service;
is_inited_ = true;
}
}
}
}
if (OB_UNLIKELY(!is_inited_)) {
reset();
}
return ret;
}
int ObTableScanStoreRowIterator::open_iter()
{
int ret = OB_SUCCESS;
ObBatch batch;
void* buf = NULL;
if (OB_FAIL(range_iter_.get_next(batch))) {
if (OB_ITER_END != ret) {
STORAGE_LOG(WARN, "fail to get batch range", K(ret));
} else {
ret = OB_SUCCESS;
}
} else {
get_table_param_.partition_store_ = partition_store_;
get_table_param_.frozen_version_ = scan_param_->frozen_version_;
get_table_param_.sample_info_ = scan_param_->sample_info_;
switch (batch.type_) {
case ObBatch::T_GET: {
if (NULL == single_merge_) {
if (NULL == (buf = scan_param_->allocator_->alloc(sizeof(ObSingleMerge)))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
STORAGE_LOG(WARN, "Fail to allocate memory, ", K(ret));
} else {
single_merge_ = new (buf) ObSingleMerge();
if (OB_FAIL(init_scan_iter(scan_param_->scan_flag_.is_index_back(), *single_merge_))) {
STORAGE_LOG(WARN, "Fail to init single merge, ", K(ret));
} else {
use_fuse_row_cache_ = !single_merge_->is_read_memtable_only();
}
}
}
if (OB_SUCC(ret)) {
main_table_ctx_.use_fuse_row_cache_ = use_fuse_row_cache_;
if (OB_FAIL(single_merge_->open(*batch.rowkey_))) {
STORAGE_LOG(WARN, "Fail to open multiple get merge iterator, ", K(ret));
} else {
main_iter_ = single_merge_;
}
}
break;
}
case ObBatch::T_MULTI_GET: {
if (NULL == get_merge_) {
if (NULL == (buf = scan_param_->allocator_->alloc(sizeof(ObMultipleGetMerge)))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
STORAGE_LOG(WARN, "Fail to allocate memory, ", K(ret));
} else {
get_merge_ = new (buf) ObMultipleGetMerge();
if (OB_FAIL(init_scan_iter(scan_param_->scan_flag_.is_index_back(), *get_merge_))) {
STORAGE_LOG(WARN, "Fail to init get merge, ", K(ret));
} else {
use_fuse_row_cache_ = !get_merge_->is_read_memtable_only();
}
}
}
if (OB_SUCC(ret)) {
main_table_ctx_.use_fuse_row_cache_ = use_fuse_row_cache_;
if (OB_FAIL(get_merge_->open(*batch.rowkeys_))) {
STORAGE_LOG(WARN, "Fail to open multiple get merge iterator, ", K(ret));
} else {
main_iter_ = get_merge_;
}
}
break;
}
case ObBatch::T_SCAN: {
if (NULL == scan_merge_) {
if (OB_ISNULL(buf = scan_param_->allocator_->alloc(sizeof(ObMultipleScanMerge)))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
STORAGE_LOG(WARN, "Fail to allocate memory, ", K(ret));
} else {
scan_merge_ = new (buf) ObMultipleScanMerge();
if (OB_FAIL(init_scan_iter(scan_param_->scan_flag_.is_index_back(), *scan_merge_))) {
STORAGE_LOG(WARN, "Fail to init scan merge, ", K(ret));
}
}
}
if (OB_SUCC(ret)) {
if (scan_param_->sample_info_.is_block_sample()) {
if (NULL == block_sample_iterator_) {
if (OB_ISNULL(buf = scan_param_->allocator_->alloc(sizeof(ObBlockSampleIterator)))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
STORAGE_LOG(WARN, "failed to allocate block_sample_iterator_", K(ret));
} else {
block_sample_iterator_ = new (buf) ObBlockSampleIterator(scan_param_->sample_info_);
}
}
if (OB_SUCC(ret)) {
if (OB_FAIL(block_sample_iterator_->open(*scan_merge_,
scan_param_->scan_flag_.is_index_back() ? index_table_ctx_ : main_table_ctx_,
*batch.range_,
get_table_param_,
scan_param_->scan_flag_.is_reverse_scan()))) {
STORAGE_LOG(WARN, "failed to open block_sample_iterator_", K(ret));
} else {
main_iter_ = block_sample_iterator_;
}
}
} else {
if (OB_FAIL(scan_merge_->open(*batch.range_))) {
STORAGE_LOG(WARN, "Fail to open multiple scan merge iterator, ", K(ret), K(*scan_param_));
} else {
main_iter_ = scan_merge_;
}
}
}
break;
}
case ObBatch::T_MULTI_SCAN: {
if (NULL == multi_scan_merge_) {
if (NULL == (buf = scan_param_->allocator_->alloc(sizeof(ObMultipleMultiScanMerge)))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
STORAGE_LOG(WARN, "Fail to allocate memory, ", K(ret));
} else {
multi_scan_merge_ = new (buf) ObMultipleMultiScanMerge();
if (OB_FAIL(init_scan_iter(scan_param_->scan_flag_.is_index_back(), *multi_scan_merge_))) {
STORAGE_LOG(WARN, "fail to init multi scan merge", K(ret));
}
}
}
if (OB_SUCC(ret)) {
if (OB_FAIL(multi_scan_merge_->open(*batch.ranges_))) {
STORAGE_LOG(WARN, "Fail to open multiple multi_scan merge iterator, ", K(ret));
} else {
main_iter_ = multi_scan_merge_;
}
}
break;
}
default: {
ret = OB_INVALID_ARGUMENT;
STORAGE_LOG(WARN, "invalid batch type", K(ret), K(batch.type_));
}
}
if (OB_SUCC(ret)) {
if (scan_param_->sample_info_.is_row_sample()) {
if (NULL == row_sample_iterator_) {
if (OB_ISNULL(buf = scan_param_->allocator_->alloc(sizeof(ObRowSampleIterator)))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
STORAGE_LOG(WARN, "failed to allocate memory", K(ret));
} else {
row_sample_iterator_ = new (buf) ObRowSampleIterator(scan_param_->sample_info_);
}
}
if (OB_SUCC(ret)) {
if (OB_FAIL(row_sample_iterator_->open(*main_iter_))) {
STORAGE_LOG(WARN, "failed to open row_sample_iterator", K(ret));
} else {
main_iter_ = row_sample_iterator_;
}
}
}
}
if (OB_SUCC(ret)) {
if (scan_param_->scan_flag_.is_index_back()) {
if (NULL == index_merge_) {
if (NULL == (buf = scan_param_->allocator_->alloc(sizeof(ObIndexMerge)))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
STORAGE_LOG(WARN, "Fail to allocate memory, ", K(ret));
} else {
index_merge_ = new (buf) ObIndexMerge();
if (OB_FAIL(index_merge_->init(main_table_param_, index_table_param_, main_table_ctx_, get_table_param_))) {
STORAGE_LOG(WARN, "Fail to init index merge, ", K(ret));
}
}
}
if (OB_SUCC(ret)) {
main_table_ctx_.use_fuse_row_cache_ = use_fuse_row_cache_;
if (OB_FAIL(index_merge_->open(*main_iter_))) {
STORAGE_LOG(WARN, "Fail to open index merge iterator, ", K(ret));
} else {
main_iter_ = index_merge_;
}
}
}
}
}
return ret;
}
int ObTableScanStoreRowIterator::get_next_row(ObStoreRow*& cur_row)
{
int ret = OB_SUCCESS;
if (OB_UNLIKELY(!is_inited_)) {
ret = OB_NOT_INIT;
STORAGE_LOG(WARN, "The ObTableScanStoreRowIterator has not been inited, ", K(ret));
} else if (OB_ISNULL(main_iter_)) {
ret = OB_ITER_END;
} else {
if (OB_FAIL(main_iter_->get_next_row(cur_row))) {
if (OB_ARRAY_BINDING_SWITCH_ITERATOR == ret) {
ret = OB_ITER_END;
} else if (OB_ITER_END != ret) {
STORAGE_LOG(WARN, "fail to get next row", K(ret));
}
}
}
if (OB_SUCC(ret)) {
} else if (OB_ITER_END != ret) {
STORAGE_LOG(WARN,
"Fail to get next row, ",
K(ret),
K(*scan_param_),
K_(main_table_param),
K_(index_table_param),
KP(single_merge_),
KP(get_merge_),
KP(scan_merge_),
KP(multi_scan_merge_),
KP(index_merge_));
}
return ret;
}
int ObTableScanStoreRowIterator::switch_iterator(const int64_t range_array_idx)
{
int ret = OB_SUCCESS;
if (nullptr != index_merge_) {
if (OB_FAIL(index_merge_->switch_iterator(range_array_idx))) {
STORAGE_LOG(WARN, "fail to switch iterator", K(ret));
}
} else {
if (nullptr != get_merge_) {
if (OB_FAIL(get_merge_->switch_iterator(range_array_idx))) {
STORAGE_LOG(WARN, "fail to switch iterator", K(ret));
}
} else if (nullptr != multi_scan_merge_) {
if (OB_FAIL(multi_scan_merge_->switch_iterator(range_array_idx))) {
STORAGE_LOG(WARN, "fail to switch iterator", K(ret));
}
} else if (nullptr != single_merge_) {
if (OB_FAIL(single_merge_->switch_iterator(range_array_idx))) {
STORAGE_LOG(WARN, "fail to switch iterator", K(ret));
}
} else if (nullptr != scan_merge_) {
if (OB_FAIL(scan_merge_->switch_iterator(range_array_idx))) {
STORAGE_LOG(WARN, "fail to switch iterator", K(ret));
}
}
STORAGE_LOG(DEBUG, "switch iterator", K(range_array_idx));
}
return ret;
}
int ObTableScanStoreRowIterator::release_table_ref()
{
int ret = OB_SUCCESS;
if (NULL != main_iter_) {
if (OB_FAIL(main_iter_->release_table_ref())) {
STORAGE_LOG(WARN, "failed to release table ref", K(ret));
}
}
return ret;
}
ObTableScanRangeArrayRowIterator::ObTableScanRangeArrayRowIterator()
: is_inited_(false), row_iter_(NULL), cur_row_(NULL), curr_range_array_idx_(0), is_reverse_scan_(false)
{}
ObTableScanRangeArrayRowIterator::~ObTableScanRangeArrayRowIterator()
{}
int ObTableScanRangeArrayRowIterator::init(const bool is_reverse_scan, ObTableScanStoreRowIterator& iter)
{
int ret = OB_SUCCESS;
if (OB_UNLIKELY(is_inited_)) {
ret = OB_INIT_TWICE;
STORAGE_LOG(WARN, "ObTableScanRangeArrayRowIterator has been inited twice", K(ret));
} else {
is_reverse_scan_ = is_reverse_scan;
row_iter_ = &iter;
is_inited_ = true;
}
return ret;
}
int ObTableScanRangeArrayRowIterator::get_next_row(common::ObNewRow*& row)
{
int ret = OB_SUCCESS;
ObStoreRow* cur_row = NULL;
if (OB_UNLIKELY(!is_inited_)) {
ret = OB_NOT_INIT;
STORAGE_LOG(WARN, "ObTableScanRangeArrayRowIterator has not been inited", K(ret));
} else if (NULL != cur_row_) {
cur_row = cur_row_;
} else {
if (OB_FAIL(row_iter_->get_next_row(cur_row))) {
if (OB_ITER_END != ret) {
STORAGE_LOG(WARN, "fail to get next row", K(ret));
}
} else if (OB_ISNULL(cur_row)) {
ret = OB_ERR_UNEXPECTED;
STORAGE_LOG(WARN, "curr row must not be NULL", K(ret));
} else {
cur_row_ = cur_row;
}
}
if (OB_SUCC(ret)) {
const int64_t range_array_idx = cur_row->range_array_idx_;
int comp_ret = static_cast<int32_t>(curr_range_array_idx_ - range_array_idx);
comp_ret = is_reverse_scan_ ? -comp_ret : comp_ret;
if (comp_ret > 0) {
ret = OB_NOT_SUPPORTED;
STORAGE_LOG(WARN,
"switch range array when iterator does not reach end is not supported",
K(ret),
K(curr_range_array_idx_),
"curr_row_range_array_idx",
range_array_idx,
K_(is_reverse_scan));
} else if (0 == comp_ret) {
row = &(cur_row->row_val_);
cur_row_ = NULL;
STORAGE_LOG(DEBUG, "get next row", K(*row), K(*cur_row));
} else if (comp_ret < 0) {
// curr range is empty
ret = OB_ITER_END;
STORAGE_LOG(DEBUG, "get next row iter end", K(curr_range_array_idx_), K(range_array_idx));
}
}
return ret;
}
void ObTableScanRangeArrayRowIterator::reset()
{
is_inited_ = false;
row_iter_ = NULL;
cur_row_ = NULL;
curr_range_array_idx_ = 0;
is_reverse_scan_ = false;
}
int ObTableScanRangeArrayRowIterator::set_range_array_idx(const int64_t range_array_idx)
{
int ret = OB_SUCCESS;
if (OB_FAIL(row_iter_->switch_iterator(range_array_idx))) {
STORAGE_LOG(WARN, "fail to switch iterator", K(ret), K(range_array_idx));
} else {
curr_range_array_idx_ = range_array_idx;
}
return ret;
}
int ObTableScanRangeArrayRowIterator::release_table_ref()
{
int ret = OB_SUCCESS;
if (OB_FAIL(row_iter_->release_table_ref())) {
STORAGE_LOG(WARN, "failed to refresh table on demand", K(ret));
}
return ret;
}
constexpr const char ObTableScanIterIterator::LABEL[];
constexpr const char ObTableScanIterator::LABEL[];
ObTableScanIterIterator::ObTableScanIterIterator()
: ObNewIterIterator(ObNewIterIterator::ObTableScanIterIterator),
store_row_iter_(),
range_row_iter_(),
range_array_cursor_(0),
range_array_cnt_(0),
is_reverse_scan_(false)
{}
ObTableScanIterIterator::~ObTableScanIterIterator()
{}
int ObTableScanIterIterator::get_next_range()
{
int ret = OB_SUCCESS;
if (range_array_cursor_ > range_array_cnt_ || range_array_cursor_ < -1) {
ret = OB_ITER_END;
} else {
range_array_cursor_ = is_reverse_scan_ ? range_array_cursor_ - 1 : range_array_cursor_ + 1;
ret = range_array_cursor_ >= range_array_cnt_ || range_array_cursor_ < 0 ? OB_ITER_END : OB_SUCCESS;
}
return ret;
}
int ObTableScanIterIterator::get_next_iter(common::ObNewRowIterator*& iter)
{
int ret = OB_SUCCESS;
if (OB_FAIL(get_next_range())) {
if (OB_ITER_END != ret) {
STORAGE_LOG(WARN, "fail to get next range", K(ret));
}
} else {
range_row_iter_.set_range_array_idx(range_array_cursor_);
iter = &range_row_iter_;
}
return ret;
}
int ObTableScanIterIterator::init(transaction::ObTransService& trans_service, const ObStoreCtx& ctx,
ObTableScanParam& scan_param, ObPartitionStore& partition_store)
{
int ret = OB_SUCCESS;
if (OB_FAIL(store_row_iter_.init(trans_service, ctx, scan_param, partition_store))) {
STORAGE_LOG(WARN, "fail to init table scan store row iterator", K(ret));
} else if (OB_FAIL(range_row_iter_.init(scan_param.scan_flag_.is_reverse_scan(), store_row_iter_))) {
STORAGE_LOG(WARN, "fail to init range row iterator", K(ret));
} else {
const int64_t range_array_cnt = scan_param.range_array_pos_.count();
is_reverse_scan_ = scan_param.scan_flag_.is_reverse_scan();
range_array_cnt_ = 0 == range_array_cnt ? 1 : range_array_cnt; // zero range means whole range
range_array_cursor_ = is_reverse_scan_ ? range_array_cnt_ : -1;
}
return ret;
}
int ObTableScanIterIterator::rescan(ObTableScanParam& scan_param)
{
int ret = OB_SUCCESS;
range_row_iter_.reset();
if (OB_FAIL(store_row_iter_.rescan(scan_param.key_ranges_, scan_param.range_array_pos_))) {
STORAGE_LOG(WARN, "fail to rescan", K(ret));
} else if (OB_FAIL(range_row_iter_.init(scan_param.scan_flag_.is_reverse_scan(), store_row_iter_))) {
STORAGE_LOG(WARN, "fail to init range row iterator", K(ret));
} else {
const int64_t range_array_cnt = scan_param.range_array_pos_.count();
is_reverse_scan_ = scan_param.scan_flag_.is_reverse_scan();
range_array_cnt_ = 0 == range_array_cnt ? 1 : range_array_cnt; // zero range means whole range
range_array_cursor_ = is_reverse_scan_ ? range_array_cnt_ : -1;
}
return ret;
}
void ObTableScanIterIterator::reset()
{
store_row_iter_.reset();
range_row_iter_.reset();
range_array_cursor_ = 0;
range_array_cnt_ = 0;
is_reverse_scan_ = false;
}
int ObTableScanIterIterator::release_table_ref()
{
int ret = OB_SUCCESS;
if (OB_FAIL(store_row_iter_.release_table_ref())) {
STORAGE_LOG(WARN, "failed to refresh table on demand", K(ret));
}
return ret;
}
ObTableScanIterator::ObTableScanIterator()
: ObNewRowIterator(ObNewRowIterator::ObTableScanIterator), iter_(), row_iter_(NULL)
{}
ObTableScanIterator::~ObTableScanIterator()
{}
int ObTableScanIterator::get_next_row(common::ObNewRow*& row)
{
int ret = OB_SUCCESS;
if (NULL == row_iter_) {
if (OB_FAIL(iter_.get_next_iter(row_iter_))) {
if (OB_ITER_END != ret) {
STORAGE_LOG(WARN, "fail to get next iterator", K(ret));
} else {
STORAGE_LOG(DEBUG, "table scan iterator reaches end");
}
}
}
if (OB_SUCC(ret)) {
if (OB_FAIL(row_iter_->get_next_row(row))) {
if (OB_ITER_END != ret) {
STORAGE_LOG(WARN, "fail to get next row", K(ret));
} else {
ret = OB_SUCCESS;
while (OB_SUCC(ret)) {
if (OB_FAIL(iter_.get_next_iter(row_iter_))) {
if (OB_ITER_END != ret) {
STORAGE_LOG(WARN, "fail to get next iter", K(ret));
} else {
STORAGE_LOG(DEBUG, "table scan iterator reaches end");
}
} else if (OB_FAIL(row_iter_->get_next_row(row))) {
if (OB_ITER_END != ret) {
STORAGE_LOG(WARN, "fail to get next row", K(ret));
} else {
STORAGE_LOG(DEBUG, "table scan row iterator reaches end");
ret = OB_SUCCESS;
}
} else {
break;
}
}
}
}
}
return ret;
}
int ObTableScanIterator::init(transaction::ObTransService& trans_service, const ObStoreCtx& ctx,
ObTableScanParam& scan_param, ObPartitionStore& partition_store)
{
return iter_.init(trans_service, ctx, scan_param, partition_store);
}
int ObTableScanIterator::rescan(ObTableScanParam& scan_param)
{
row_iter_ = NULL;
return iter_.rescan(scan_param);
}
void ObTableScanIterator::reset()
{
iter_.reset();
row_iter_ = NULL;
}
int ObTableScanIterator::release_table_ref()
{
int ret = OB_SUCCESS;
if (OB_FAIL(iter_.release_table_ref())) {
STORAGE_LOG(WARN, "failed to refresh table on demand", K(ret));
}
return ret;
}
ObTableScanNewRowIterator::ObTableScanNewRowIterator(ObNewIterIterator& iter) : iter_(iter), row_iter_(NULL)
{}
ObTableScanNewRowIterator::~ObTableScanNewRowIterator()
{}
int ObTableScanNewRowIterator::get_next_row(common::ObNewRow*& row)
{
int ret = OB_SUCCESS;
if (NULL == row_iter_) {
if (OB_FAIL(iter_.get_next_iter(row_iter_))) {
if (OB_ITER_END != ret) {
STORAGE_LOG(WARN, "fail to get next iterator", K(ret));
} else {
STORAGE_LOG(DEBUG, "table scan iterator reaches end");
}
}
}
if (OB_SUCC(ret)) {
if (OB_FAIL(row_iter_->get_next_row(row))) {
if (OB_ITER_END != ret) {
STORAGE_LOG(WARN, "fail to get next row", K(ret));
} else {
ret = OB_SUCCESS;
while (OB_SUCC(ret)) {
if (OB_FAIL(iter_.get_next_iter(row_iter_))) {
if (OB_ITER_END != ret) {
STORAGE_LOG(WARN, "fail to get next iter", K(ret));
} else {
STORAGE_LOG(DEBUG, "table scan iterator reaches end");
}
} else if (OB_FAIL(row_iter_->get_next_row(row))) {
if (OB_ITER_END != ret) {
STORAGE_LOG(WARN, "fail to get next row", K(ret));
} else {
STORAGE_LOG(DEBUG, "table scan row iterator reaches end");
ret = OB_SUCCESS;
}
} else {
break;
}
}
}
}
}
return ret;
}
} // namespace storage
} // namespace oceanbase
Reference in New Issue View Git Blame Copy Permalink