hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
71aa08728f3c34482f7091a7df37dc80c06fe930
oceanbase/src/storage/access/ob_multiple_skip_scan_merge.cpp
JiahuaChen 71aa08728f Fix memstore not release after table refresh
2023-11-01 08:13:07 +00:00

562 lines
21 KiB
C++
Raw Blame History

// Copyright (c) 2021 OceanBase
// OceanBase 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_multiple_skip_scan_merge.h"
#include "lib/oblog/ob_log_module.h"
namespace oceanbase
{
namespace storage
{
ObMultipleSkipScanMerge::ObMultipleSkipScanMerge()
: ObMultipleScanMerge(),
state_(SCAN_ROWKEY),
scan_rowkey_cnt_(0),
schema_rowkey_cnt_(0),
ss_rowkey_prefix_cnt_(0),
scan_rowkey_range_(),
scan_rows_range_(),
datums_cnt_(0),
datums_(nullptr),
origin_range_(nullptr),
skip_scan_range_(nullptr),
range_allocator_("SS_RANGE"),
rowkey_allocator_("SS_ROWKEY")
{
}
ObMultipleSkipScanMerge::~ObMultipleSkipScanMerge()
{
reset();
}
int ObMultipleSkipScanMerge::init(
ObTableAccessParam &param,
ObTableAccessContext &context,
ObGetTableParam &get_table_param)
{
int ret = OB_SUCCESS;
context.range_allocator_ = &range_allocator_;
if (OB_FAIL(ObMultipleScanMerge::init(param, context, get_table_param))) {
STORAGE_LOG(WARN, "Fail to init ObMultipleScanMerge", K(ret), K(param), K(context), K(get_table_param));
} else {
// prepare ranges for finding distinct rowkey prefix and outputing rows
void *buf = nullptr;
schema_rowkey_cnt_ = param.iter_param_.get_schema_rowkey_count();
ss_rowkey_prefix_cnt_ = param.iter_param_.get_ss_rowkey_prefix_cnt();
datums_cnt_ = SKIP_SCAN_ROWKEY_DATUMS_ARRAY_CNT * schema_rowkey_cnt_;
if (schema_rowkey_cnt_ <= 0 || ss_rowkey_prefix_cnt_ <= 0 || ss_rowkey_prefix_cnt_ > schema_rowkey_cnt_) {
ret = OB_INVALID_ARGUMENT;
STORAGE_LOG(WARN, "Invalid argument", K(ret), K(schema_rowkey_cnt_), K(ss_rowkey_prefix_cnt_));
} else if (OB_ISNULL(buf = context.stmt_allocator_->alloc(sizeof(ObStorageDatum) * datums_cnt_))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
STORAGE_LOG(WARN, "Fail to alloc datums", K(ret), K(datums_cnt_));
} else if (FALSE_IT(datums_ = new (buf) ObStorageDatum[datums_cnt_])) {
} else if (OB_FAIL(prepare_range(start_key_of_scan_rowkey_range(), scan_rowkey_range_))) {
STORAGE_LOG(WARN, "Fail to prepare distinct scan range", K(ret));
} else {
STORAGE_LOG(DEBUG, "success to init ObMultipleSkipScanMerge", K(param), K(context), K(get_table_param),
K(schema_rowkey_cnt_), K(ss_rowkey_prefix_cnt_));
}
}
return ret;
}
void ObMultipleSkipScanMerge::reset()
{
state_ = SCAN_ROWKEY;
scan_rowkey_cnt_ = 0;
schema_rowkey_cnt_ = 0;
ss_rowkey_prefix_cnt_ = 0;
scan_rowkey_range_.reset();
scan_rows_range_.reset();
datums_cnt_ = 0;
if (OB_NOT_NULL(datums_) && OB_NOT_NULL(access_ctx_->stmt_allocator_)) {
access_ctx_->stmt_allocator_->free(datums_);
}
datums_ = nullptr;
origin_range_ = nullptr;
skip_scan_range_ = nullptr;
range_allocator_.reset();
rowkey_allocator_.reset();
ObMultipleScanMerge::reset();
}
void ObMultipleSkipScanMerge::reuse()
{
if (RETIRED_TO_SCAN != state_) {
state_ = SCAN_ROWKEY;
}
reuse_datums();
range_allocator_.reuse();
rowkey_allocator_.reuse();
ObMultipleScanMerge::reuse();
}
// range: the original key range to scan rows
// skip_scan_range: the key range only contains suffix columns in rowkey
int ObMultipleSkipScanMerge::open(const blocksstable::ObDatumRange &range, const blocksstable::ObDatumRange &skip_scan_range)
{
int ret = OB_SUCCESS;
origin_range_ = &range;
skip_scan_range_ = &skip_scan_range;
if (RETIRED_TO_SCAN == state_) {
if (OB_FAIL(ObMultipleScanMerge::open(range))) {
STORAGE_LOG(WARN, "Fail to open ObMultipleScanMerge", K(ret), K(range));
}
} else if (OB_FAIL(open_skip_scan(range, skip_scan_range))) {
STORAGE_LOG(WARN, "Fail to open skip scan", K(ret), K(range), K(skip_scan_range));
}
return ret;
}
int ObMultipleSkipScanMerge::open_skip_scan(const blocksstable::ObDatumRange &range, const blocksstable::ObDatumRange &skip_scan_range)
{
int ret = OB_SUCCESS;
bool exceeded = false;
const int64_t skip_range_datum_cnt = schema_rowkey_cnt_ - ss_rowkey_prefix_cnt_;
access_ctx_->range_allocator_ = &range_allocator_;
if (skip_scan_range.is_whole_range()) {
ret = OB_NOT_SUPPORTED;
STORAGE_LOG(WARN, "not supported index skip scan plan", K(ret));
} else if (skip_scan_range.start_key_.get_datum_cnt() > skip_range_datum_cnt ||
(!skip_scan_range.start_key_.is_min_rowkey() && skip_scan_range.start_key_.get_datum_cnt() != skip_range_datum_cnt) ||
(!skip_scan_range.end_key_.is_max_rowkey() && skip_scan_range.end_key_.get_datum_cnt() != skip_range_datum_cnt)) {
ret = OB_INVALID_ARGUMENT;
STORAGE_LOG(WARN, "invalid skip scan range", K(ret), K(skip_scan_range), K(schema_rowkey_cnt_), K(ss_rowkey_prefix_cnt_));
} else if (OB_FAIL(ObMultipleScanMerge::open(range))) {
STORAGE_LOG(WARN, "Fail to open ObMultipleScanMerge", K(ret), K(range));
} else {
prepare_rowkey(start_key_of_scan_rowkey_range(), range.start_key_, schema_rowkey_cnt_, true);
prepare_rowkey(end_key_of_scan_rowkey_range(), range.end_key_, schema_rowkey_cnt_, false);
scan_rowkey_range_.set_border_flag(range.get_border_flag());
scan_rowkey_range_.set_group_idx(range.get_group_idx());
scan_rowkey_range_.set_group_idx(range.get_group_idx());
const ObColDescIArray *col_descs = nullptr;
if (OB_ISNULL(col_descs = access_param_->iter_param_.get_out_col_descs())) {
ret = OB_ERR_UNEXPECTED;
TRANS_LOG(WARN, "Unexpected null out cols", K(ret));
} else if (OB_FAIL(scan_rowkey_range_.prepare_memtable_readable(*col_descs, rowkey_allocator_))) {
STORAGE_LOG(WARN, "Fail to transfer store rowkey", K(ret), K(scan_rowkey_range_));
}
STORAGE_LOG(TRACE, "open skip scan", K(ret), K(schema_rowkey_cnt_), K(ss_rowkey_prefix_cnt_),
K(scan_rows_range_), K(range), K(skip_scan_range));
}
return ret;
}
int ObMultipleSkipScanMerge::inner_get_next_row(blocksstable::ObDatumRow &row)
{
int ret = OB_SUCCESS;
bool got_row = false;
while (OB_SUCC(ret) && !got_row) {
switch(state_) {
case SCAN_ROWKEY: {
// get next rowkey
// after get next rowkey, update and open scan rows range
if (OB_FAIL(ObMultipleScanMerge::inner_get_next_row(row))) {
if (OB_UNLIKELY(OB_ITER_END != ret && OB_PUSHDOWN_STATUS_CHANGED != ret)) {
STORAGE_LOG(WARN, "Fail to get next row", K(ret));
} else if (OB_PUSHDOWN_STATUS_CHANGED == ret) {
} else {
state_ = SCAN_FINISHED;
}
} else {
state_ = UPDATE_SCAN_ROWS_RANGE;
scan_rowkey_cnt_++;
}
break;
}
case UPDATE_SCAN_ROWS_RANGE: {
if (OB_FAIL(update_scan_rows_range(row))) {
if (OB_LIKELY(OB_ITER_END == ret)) {
ret = OB_SUCCESS;
state_ = UPDATE_SCAN_ROWKEY_RANGE;
} else {
STORAGE_LOG(WARN, "Fail to update scan rows range", K(ret), K(row));
}
} else if (should_retire_to_scan()) {
state_ = RETIRED_TO_SCAN;
} else {
STORAGE_LOG(DEBUG, "skip scan update scan rows range", K(row), K(scan_rows_range_));
state_ = SCAN_ROWS;
}
break;
}
case SCAN_ROWS: {
// get next row
// after get next row, update and open scan rowkey range
if (OB_FAIL(ObMultipleScanMerge::inner_get_next_row(row))) {
if (OB_UNLIKELY(OB_ITER_END != ret && OB_PUSHDOWN_STATUS_CHANGED != ret)) {
STORAGE_LOG(WARN, "Fail to get next row", K(ret));
} else if (OB_PUSHDOWN_STATUS_CHANGED == ret) {
} else {
ret = OB_SUCCESS;
state_ = UPDATE_SCAN_ROWKEY_RANGE;
}
} else {
STORAGE_LOG(DEBUG, "skip scan get next row", K(row));
got_row = true;
}
break;
}
case UPDATE_SCAN_ROWKEY_RANGE: {
if (OB_FAIL(update_scan_rowkey_range())) {
if (OB_UNLIKELY(OB_ITER_END != ret)) {
STORAGE_LOG(WARN, "Fail to update scan rowkey range", K(ret), K(row));
} else {
state_ = SCAN_FINISHED;
}
} else {
STORAGE_LOG(DEBUG, "skip scan update scan rowkey range", K(row), K(scan_rowkey_range_));
state_ = SCAN_ROWKEY;
}
break;
}
case SCAN_FINISHED: {
ret = OB_ITER_END;
break;
}
case RETIRED_TO_SCAN: {
ret = ObMultipleScanMerge::inner_get_next_row(row);
got_row = true;
break;
}
default : {
ret = OB_ERR_UNEXPECTED;
STORAGE_LOG(WARN, "Unexpected state", K(state_));
}
}
}
return ret;
}
int ObMultipleSkipScanMerge::inner_get_next_rows()
{
int ret = OB_SUCCESS;
bool end_loop = false;
if (SCAN_ROWS != state_) {
ret = OB_ERR_UNEXPECTED;
STORAGE_LOG(WARN, "Unexpected state", K(ret), K(state_));
} else {
while (OB_SUCC(ret) && !end_loop) {
switch(state_) {
case SCAN_ROWKEY: {
if (OB_FAIL(ObMultipleScanMerge::inner_get_next_row(unprojected_row_))) {
if (OB_UNLIKELY(OB_ITER_END != ret && OB_PUSHDOWN_STATUS_CHANGED != ret)) {
STORAGE_LOG(WARN, "Fail to get next row", K(ret));
} else if (OB_PUSHDOWN_STATUS_CHANGED == ret) {
} else {
state_ = SCAN_FINISHED;
}
} else {
state_ = UPDATE_SCAN_ROWS_RANGE;
scan_rowkey_cnt_++;
}
break;
}
case UPDATE_SCAN_ROWS_RANGE: {
if (OB_FAIL(update_scan_rows_range(unprojected_row_))) {
if (OB_LIKELY(OB_ITER_END == ret)) {
ret = OB_SUCCESS;
state_ = UPDATE_SCAN_ROWKEY_RANGE;
} else {
STORAGE_LOG(WARN, "Fail to update scan rows range", K(ret), K(unprojected_row_));
}
} else if (should_retire_to_scan()) {
state_ = RETIRED_TO_SCAN;
} else {
STORAGE_LOG(DEBUG, "skip scan update scan rows range", K(unprojected_row_), K(scan_rows_range_));
state_ = SCAN_ROWS;
}
break;
}
case SCAN_ROWS: {
bool can_batch = false;
if (OB_FAIL(can_batch_scan(can_batch))) {
STORAGE_LOG(WARN, "Fail to check can batch scan", K(ret));
} else if (!can_batch) {
end_loop = true;
ret = OB_PUSHDOWN_STATUS_CHANGED;
} else if (OB_FAIL(ObMultipleScanMerge::inner_get_next_rows())) {
if (OB_UNLIKELY(OB_ITER_END != ret && OB_PUSHDOWN_STATUS_CHANGED != ret)) {
STORAGE_LOG(WARN, "Fail to get next rows", K(ret));
} else if (OB_PUSHDOWN_STATUS_CHANGED == ret) {
} else {
ret = OB_SUCCESS;
state_ = UPDATE_SCAN_ROWKEY_RANGE;
}
} else {
end_loop = true;
}
break;
}
case UPDATE_SCAN_ROWKEY_RANGE: {
if (OB_FAIL(update_scan_rowkey_range())) {
if (OB_UNLIKELY(OB_ITER_END != ret)) {
STORAGE_LOG(WARN, "Fail to update scan rowkey range", K(ret), K(unprojected_row_));
} else {
state_ = SCAN_FINISHED;
}
} else {
STORAGE_LOG(DEBUG, "skip scan update scan rowkey range", K(unprojected_row_), K(scan_rowkey_range_));
state_ = SCAN_ROWKEY;
}
break;
}
case SCAN_FINISHED: {
ret = OB_ITER_END;
break;
}
case RETIRED_TO_SCAN: {
ret = ObMultipleScanMerge::inner_get_next_rows();
end_loop = true;
break;
}
default : {
ret = OB_ERR_UNEXPECTED;
STORAGE_LOG(WARN, "Unexpected state", K(state_));
}
}
}
}
return ret;
}
int ObMultipleSkipScanMerge::can_batch_scan(bool &can_batch)
{
int ret = OB_SUCCESS;
can_batch = (state_ == SCAN_ROWS);
if (can_batch && OB_FAIL(ObMultipleScanMerge::can_batch_scan(can_batch))) {
STORAGE_LOG(WARN, "Fail to check can batch scan", K(ret));
}
return ret;
}
int ObMultipleSkipScanMerge::prepare_range(ObStorageDatum *datums, ObDatumRange &range)
{
int ret = OB_SUCCESS;
if (OB_FAIL(range.start_key_.assign(datums, schema_rowkey_cnt_))) {
STORAGE_LOG(WARN, "Fail to assign start key", K(ret), K(schema_rowkey_cnt_));
} else if (OB_FAIL(range.end_key_.assign(datums + schema_rowkey_cnt_, schema_rowkey_cnt_))) {
STORAGE_LOG(WARN, "Fail to assign end key", K(ret), K(schema_rowkey_cnt_));
}
return ret;
}
void ObMultipleSkipScanMerge::prepare_rowkey(
blocksstable::ObStorageDatum *datums,
const blocksstable::ObDatumRowkey &rowkey,
const int64_t datum_cnt,
const bool is_min)
{
for (int64_t i = 0; i < datum_cnt; ++i) {
if (i < rowkey.get_datum_cnt()) {
datums[i] = rowkey.get_datum(i);
} else if (is_min) {
datums[i].set_min();
} else {
datums[i].set_max();
}
}
}
int ObMultipleSkipScanMerge::update_scan_rows_range(blocksstable::ObDatumRow &row)
{
int ret = OB_SUCCESS;
range_allocator_.reuse();
if (should_check_interrupt() && OB_FAIL(THIS_WORKER.check_status())) {
STORAGE_LOG(WARN, "query interrupt", K(ret));
} else if (OB_FAIL(prepare_scan_row_range())) {
STORAGE_LOG(WARN, "Fail to prepare scan row range", K(ret));
} else if (should_retire_to_scan()) {
// too many distinct prefix, retire to normal scan
for (int64_t i = 0; OB_SUCC(ret) && i < ss_rowkey_prefix_cnt_; ++i) {
ObStorageDatum &prefix_of_rows_key = access_ctx_->query_flag_.is_reverse_scan() ?
end_key_of_scan_rows_range()[i] :
start_key_of_scan_rows_range()[i];
prefix_of_rows_key.reuse();
if (OB_FAIL(prefix_of_rows_key.deep_copy(row.storage_datums_[i], range_allocator_))) {
STORAGE_LOG(WARN, "Fail to deep copy start key's datum", K(ret), K(i), K(row), K(scan_rows_range_));
}
}
if (OB_FAIL(ret)) {
} else if (access_ctx_->query_flag_.is_reverse_scan()) {
scan_rows_range_.set_start_key(origin_range_->get_start_key());
set_border_falg(true, *origin_range_, scan_rows_range_);
} else {
scan_rows_range_.set_end_key(origin_range_->get_end_key());
set_border_falg(false, *origin_range_, scan_rows_range_);
}
STORAGE_LOG(TRACE, "should retire to normal scan", K(ret), K(scan_rows_range_));
} else {
for (int64_t i = 0; OB_SUCC(ret) && i < ss_rowkey_prefix_cnt_; ++i) {
ObStorageDatum &prefix_of_start_key = start_key_of_scan_rows_range()[i];
ObStorageDatum &prefix_of_end_key = end_key_of_scan_rows_range()[i];
prefix_of_start_key.reuse();
prefix_of_end_key.reuse();
if (OB_FAIL(prefix_of_start_key.deep_copy(row.storage_datums_[i], range_allocator_))) {
STORAGE_LOG(WARN, "Fail to deep copy start key's datum", K(ret), K(i), K(row), K(scan_rows_range_));
} else if (OB_FAIL(prefix_of_end_key.deep_copy(row.storage_datums_[i], range_allocator_))) {
STORAGE_LOG(WARN, "Fail to deep copy end key's datum", K(ret), K(i), K(row), K(scan_rows_range_));
}
}
}
if (OB_SUCC(ret)) {
// adjust scan rows range according original query range
// one case is in parallel execution, splitted range
bool exceeded = false;
if (OB_FAIL(shrink_scan_rows_range(exceeded))) {
STORAGE_LOG(WARN, "Fail to check range exceed", K(ret));
} else if (exceeded) {
ret = OB_ITER_END;
}
}
if (OB_SUCC(ret)) {
ObMultipleScanMerge::reuse();
const ObColDescIArray *col_descs = nullptr;
if (OB_ISNULL(col_descs = access_param_->iter_param_.get_out_col_descs())) {
ret = OB_ERR_UNEXPECTED;
TRANS_LOG(WARN, "Unexpected null out cols", K(ret));
} else if (OB_FAIL(scan_rows_range_.prepare_memtable_readable(*col_descs, range_allocator_))) {
STORAGE_LOG(WARN, "Fail to transfer store rowkey", K(ret), K(scan_rows_range_));
} else if (OB_FAIL(ObMultipleScanMerge::open(scan_rows_range_))) {
STORAGE_LOG(WARN, "Fail to open scan rows range", K(ret), K(scan_rows_range_));
}
}
STORAGE_LOG(TRACE, "Update and open scan rows range", K(ret), K(row), K(scan_rows_range_));
return ret;
}
int ObMultipleSkipScanMerge::update_scan_rowkey_range()
{
int ret = OB_SUCCESS;
rowkey_allocator_.reuse();
if (OB_UNLIKELY(!scan_rows_range_.is_valid())) {
ret = OB_ERR_UNEXPECTED;
STORAGE_LOG(WARN, "Unexpected scan rows range", K(ret), K(scan_rows_range_));
} else {
ObStorageDatum *rowkey_datums = access_ctx_->query_flag_.is_reverse_scan() ?
end_key_of_scan_rowkey_range() :
start_key_of_scan_rowkey_range();
for (int64_t i = 0; OB_SUCC(ret) && i < ss_rowkey_prefix_cnt_; ++i) {
if (OB_FAIL(rowkey_datums[i].deep_copy(scan_rows_range_.start_key_.get_datum(i), rowkey_allocator_))) {
STORAGE_LOG(WARN, "Fail to deep copy start key's datum", K(ret), K(i), K(scan_rowkey_range_));
}
}
if (OB_SUCC(ret)) {
for (int64_t i = ss_rowkey_prefix_cnt_; i < schema_rowkey_cnt_; ++i) {
access_ctx_->query_flag_.is_reverse_scan() ? rowkey_datums[i].set_min() : rowkey_datums[i].set_max();
}
access_ctx_->query_flag_.is_reverse_scan() ? scan_rowkey_range_.set_right_open() : scan_rowkey_range_.set_left_open();
int cmp_ret = 0;
const ObStorageDatumUtils &datum_utils = access_param_->iter_param_.get_read_info()->get_datum_utils();
if (OB_FAIL(scan_rowkey_range_.start_key_.compare(scan_rowkey_range_.end_key_, datum_utils, cmp_ret))) {
STORAGE_LOG(WARN, "Fail to compare", K(ret), K(scan_rowkey_range_));
} else if (cmp_ret >= 0) {
ret = OB_ITER_END;
} else {
ObMultipleScanMerge::reuse();
const ObColDescIArray *col_descs = nullptr;
if (OB_ISNULL(col_descs = access_param_->iter_param_.get_out_col_descs())) {
ret = OB_ERR_UNEXPECTED;
TRANS_LOG(WARN, "Unexpected null out cols", K(ret));
} else if (OB_FAIL(scan_rowkey_range_.prepare_memtable_readable(*col_descs, rowkey_allocator_))) {
STORAGE_LOG(WARN, "Fail to transfer store rowkey", K(ret), K(scan_rowkey_range_));
} else if (OB_FAIL(ObMultipleScanMerge::open(scan_rowkey_range_))) {
STORAGE_LOG(WARN, "Fail to open scan rowkey range", K(ret), K(scan_rowkey_range_));
}
}
}
}
STORAGE_LOG(TRACE, "Update and open scan rowkey range", K(ret), K(scan_rows_range_), K(scan_rowkey_range_));
return ret;
}
int ObMultipleSkipScanMerge::shrink_scan_rows_range(bool &exceeded)
{
int ret = OB_SUCCESS;
int cmp_ret = 0;
const ObStorageDatumUtils &datum_utils = access_param_->iter_param_.get_read_info()->get_datum_utils();
if (OB_FAIL(scan_rows_range_.start_key_.compare(origin_range_->start_key_, datum_utils, cmp_ret))) {
STORAGE_LOG(WARN, "Fail to compare", K(ret));
} else if (cmp_ret > 0) {
} else {
set_border_falg(true, *origin_range_, scan_rows_range_);
if (cmp_ret < 0) {
scan_rows_range_.start_key_ = origin_range_->start_key_;
}
}
if (OB_FAIL(ret)) {
} else if (OB_FAIL(scan_rows_range_.end_key_.compare(origin_range_->end_key_, datum_utils, cmp_ret))) {
STORAGE_LOG(WARN, "Fail to compare", K(ret));
} else if (cmp_ret < 0) {
} else {
set_border_falg(false, *origin_range_, scan_rows_range_);
if (cmp_ret > 0) {
scan_rows_range_.end_key_ = origin_range_->end_key_;
}
}
if (OB_FAIL(ret)) {
} else if (OB_FAIL(scan_rows_range_.start_key_.compare(scan_rows_range_.end_key_, datum_utils, cmp_ret))) {
STORAGE_LOG(WARN, "Fail to compare", K(ret), K(scan_rows_range_));
} else if (cmp_ret > 0 || (0 == cmp_ret && (scan_rows_range_.is_left_open() || scan_rows_range_.is_right_open()))) {
exceeded = true;
}
return ret;
}
int ObMultipleSkipScanMerge::prepare_scan_row_range()
{
int ret = OB_SUCCESS;
if (OB_FAIL(prepare_range(start_key_of_scan_rows_range(), scan_rows_range_))) {
STORAGE_LOG(WARN, "Fail to prepare skip scan range", K(ret));
} else {
for (int64_t i = 0; i < ss_rowkey_prefix_cnt_; ++i) {
start_key_of_scan_rows_range()[i].set_min();
end_key_of_scan_rows_range()[i].set_max();
}
prepare_rowkey(start_key_of_scan_rows_range() + ss_rowkey_prefix_cnt_,
skip_scan_range_->start_key_,
schema_rowkey_cnt_ - ss_rowkey_prefix_cnt_,
true);
prepare_rowkey(end_key_of_scan_rows_range() + ss_rowkey_prefix_cnt_,
skip_scan_range_->end_key_,
schema_rowkey_cnt_ - ss_rowkey_prefix_cnt_,
false);
scan_rows_range_.set_border_flag(skip_scan_range_->get_border_flag());
scan_rows_range_.set_group_idx(origin_range_->get_group_idx());
}
return ret;
}
void ObMultipleSkipScanMerge::set_border_falg(const bool is_left, const blocksstable::ObDatumRange &src, blocksstable::ObDatumRange &dst)
{
if (is_left) {
if (src.is_left_open()) {
dst.set_left_open();
} else {
dst.set_left_closed();
}
} else {
if (src.is_right_open()) {
dst.set_right_open();
} else {
dst.set_right_closed();
}
}
}
}
}
Reference in New Issue View Git Blame Copy Permalink