131 lines
3.7 KiB
C++
131 lines
3.7 KiB
C++
/**
|
|
* 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.
|
|
*/
|
|
|
|
#ifndef OCEANBASE_STORAGE_OB_MULTIPLE_SCAN_MERGE_IMPL_H_
|
|
#define OCEANBASE_STORAGE_OB_MULTIPLE_SCAN_MERGE_IMPL_H_
|
|
|
|
#include "lib/container/ob_loser_tree.h"
|
|
#include "storage/ob_i_store.h"
|
|
#include "storage/ob_row_fuse.h"
|
|
#include "storage/ob_multiple_merge.h"
|
|
#include "storage/ob_range_purger.h"
|
|
#include "storage/ob_range_skip.h"
|
|
#include "storage/ob_scan_merge_loser_tree.h"
|
|
|
|
namespace oceanbase {
|
|
namespace storage {
|
|
class ObQueryIteratorConsumer {
|
|
public:
|
|
ObQueryIteratorConsumer()
|
|
{
|
|
reset();
|
|
}
|
|
~ObQueryIteratorConsumer()
|
|
{}
|
|
void add_consumer(const int64_t iter_idx)
|
|
{
|
|
consumer_iters_[consumer_num_++] = iter_idx;
|
|
}
|
|
void set_consumer(const int64_t consumer_idx, const int64_t iter_idx)
|
|
{
|
|
consumer_iters_[consumer_idx] = iter_idx;
|
|
}
|
|
void set_base_iter_idx(const int64_t iter_idx)
|
|
{
|
|
base_sstable_iter_idx_ = iter_idx;
|
|
}
|
|
void reset()
|
|
{
|
|
consumer_num_ = 0;
|
|
base_sstable_iter_idx_ = OB_INVALID_INDEX;
|
|
memset(consumer_iters_, 0, MAX_TABLE_CNT_IN_STORAGE * sizeof(int64_t));
|
|
}
|
|
|
|
inline int64_t get_consumer_num()
|
|
{
|
|
return consumer_num_;
|
|
}
|
|
inline int64_t* get_consumer_iters()
|
|
{
|
|
return consumer_iters_;
|
|
}
|
|
inline void set_consumer_num(const int64_t consumer_num)
|
|
{
|
|
consumer_num_ = consumer_num;
|
|
}
|
|
OB_INLINE bool is_base_iter_only() const
|
|
{
|
|
return 1 == consumer_num_ && base_sstable_iter_idx_ == consumer_iters_[0];
|
|
}
|
|
|
|
// remove larger or equal to idx
|
|
void remove_le(const int64_t idx)
|
|
{
|
|
int64_t valid_consume_num = 0;
|
|
for (int64_t i = 0; i < consumer_num_; i++) {
|
|
if (consumer_iters_[i] < idx) {
|
|
consumer_iters_[valid_consume_num++] = consumer_iters_[i];
|
|
}
|
|
}
|
|
consumer_num_ = valid_consume_num;
|
|
}
|
|
TO_STRING_KV(
|
|
"consumers", ObArrayWrap<int64_t>(consumer_iters_, consumer_num_), K_(consumer_num), K_(base_sstable_iter_idx));
|
|
|
|
private:
|
|
int64_t consumer_iters_[common::MAX_TABLE_CNT_IN_STORAGE];
|
|
int64_t consumer_num_;
|
|
int64_t base_sstable_iter_idx_;
|
|
};
|
|
|
|
class ObMultipleScanMergeImpl : public ObMultipleMerge {
|
|
public:
|
|
ObMultipleScanMergeImpl();
|
|
virtual ~ObMultipleScanMergeImpl();
|
|
|
|
virtual int init(
|
|
const ObTableAccessParam& param, ObTableAccessContext& context, const ObGetTableParam& get_table_param) override;
|
|
virtual int inner_get_next_row(ObStoreRow& row) override;
|
|
virtual void reset() override;
|
|
virtual void reuse() override;
|
|
inline bool is_scan_end() const
|
|
{
|
|
return loser_tree_.empty();
|
|
}
|
|
|
|
protected:
|
|
int reset_range(int idx, int64_t range_idx, const ObStoreRowkey* rowkey, const bool include_gap_key);
|
|
int supply_consume();
|
|
int prepare_range_skip();
|
|
int inner_get_next_row(ObStoreRow& row, bool& need_retry);
|
|
int prepare_loser_tree();
|
|
|
|
private:
|
|
int try_skip_range(const ObStoreRow* row, int idx, uint8_t flag, bool first_pop, bool& skipped);
|
|
|
|
protected:
|
|
ObScanMergeLoserTreeCmp tree_cmp_;
|
|
ObScanMergeLoserTree loser_tree_;
|
|
bool iter_del_row_;
|
|
ObQueryIteratorConsumer consumer_;
|
|
bool try_push_top_item_;
|
|
ObRangePurger range_purger_;
|
|
ObRangeSkip range_skip_;
|
|
|
|
private:
|
|
DISALLOW_COPY_AND_ASSIGN(ObMultipleScanMergeImpl);
|
|
};
|
|
|
|
} // end namespace storage
|
|
} // end namespace oceanbase
|
|
#endif // OCEANBASE_STORAGE_OB_MULTIPLE_SCAN_MERGE_IMPL_H_
|