This is an automated email from the ASF dual-hosted git repository.
yiguolei pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/doris.git
The following commit(s) were added to refs/heads/master by this push:
new 4c8fe107a7d [refactor](exception safe) Refactor delete handler and
block column predicates to make sure exception safe (#31618)
4c8fe107a7d is described below
commit 4c8fe107a7d76f788b65948e3704ab6045642ab4
Author: yiguolei <[email protected]>
AuthorDate: Fri Mar 1 12:27:26 2024 +0800
[refactor](exception safe) Refactor delete handler and block column
predicates to make sure exception safe (#31618)
---
be/src/olap/block_column_predicate.cpp | 24 ++++----
be/src/olap/block_column_predicate.h | 25 ++++----
be/src/olap/delete_handler.cpp | 15 ++---
be/src/olap/delete_handler.h | 7 +--
be/src/olap/iterators.h | 2 +-
be/src/olap/rowset/beta_rowset_reader.cpp | 12 ++--
be/src/olap/rowset/segment_v2/segment.cpp | 9 ++-
be/src/olap/rowset/segment_v2/segment_iterator.cpp | 4 +-
be/src/olap/tablet_reader.cpp | 2 -
be/test/olap/block_column_predicate_test.cpp | 68 +++++++++++++---------
be/test/olap/delete_handler_test.cpp | 10 ----
11 files changed, 88 insertions(+), 90 deletions(-)
diff --git a/be/src/olap/block_column_predicate.cpp
b/be/src/olap/block_column_predicate.cpp
index 13e7da1a6f9..58d9c02d8be 100644
--- a/be/src/olap/block_column_predicate.cpp
+++ b/be/src/olap/block_column_predicate.cpp
@@ -15,7 +15,7 @@
// specific language governing permissions and limitations
// under the License.
-#include "block_column_predicate.h"
+#include "olap/block_column_predicate.h"
#include <string.h>
@@ -90,8 +90,7 @@ uint16_t
OrBlockColumnPredicate::evaluate(vectorized::MutableColumns& block, uin
bool ret_flags[selected_size];
memset(ret_flags, false, selected_size);
for (int i = 0; i < num_of_column_predicate(); ++i) {
- auto column_predicate = _block_column_predicate_vec[i];
- column_predicate->evaluate_or(block, sel, selected_size,
ret_flags);
+ _block_column_predicate_vec[i]->evaluate_or(block, sel,
selected_size, ret_flags);
}
uint16_t new_size = 0;
@@ -106,7 +105,7 @@ uint16_t
OrBlockColumnPredicate::evaluate(vectorized::MutableColumns& block, uin
void OrBlockColumnPredicate::evaluate_or(vectorized::MutableColumns& block,
uint16_t* sel,
uint16_t selected_size, bool* flags)
const {
- for (auto block_column_predicate : _block_column_predicate_vec) {
+ for (auto& block_column_predicate : _block_column_predicate_vec) {
block_column_predicate->evaluate_or(block, sel, selected_size, flags);
}
}
@@ -119,8 +118,7 @@ void
OrBlockColumnPredicate::evaluate_and(vectorized::MutableColumns& block, uin
bool ret_flags[selected_size];
memset(ret_flags, false, selected_size);
for (int i = 0; i < num_of_column_predicate(); ++i) {
- auto column_predicate = _block_column_predicate_vec[i];
- column_predicate->evaluate_or(block, sel, selected_size,
ret_flags);
+ _block_column_predicate_vec[i]->evaluate_or(block, sel,
selected_size, ret_flags);
}
for (int i = 0; i < selected_size; ++i) {
@@ -131,7 +129,7 @@ void
OrBlockColumnPredicate::evaluate_and(vectorized::MutableColumns& block, uin
uint16_t AndBlockColumnPredicate::evaluate(vectorized::MutableColumns& block,
uint16_t* sel,
uint16_t selected_size) const {
- for (auto block_column_predicate : _block_column_predicate_vec) {
+ for (auto& block_column_predicate : _block_column_predicate_vec) {
selected_size = block_column_predicate->evaluate(block, sel,
selected_size);
}
return selected_size;
@@ -139,14 +137,14 @@ uint16_t
AndBlockColumnPredicate::evaluate(vectorized::MutableColumns& block, ui
void AndBlockColumnPredicate::evaluate_and(vectorized::MutableColumns& block,
uint16_t* sel,
uint16_t selected_size, bool*
flags) const {
- for (auto block_column_predicate : _block_column_predicate_vec) {
+ for (auto& block_column_predicate : _block_column_predicate_vec) {
block_column_predicate->evaluate_and(block, sel, selected_size, flags);
}
}
bool AndBlockColumnPredicate::evaluate_and(
const std::pair<WrapperField*, WrapperField*>& statistic) const {
- for (auto block_column_predicate : _block_column_predicate_vec) {
+ for (auto& block_column_predicate : _block_column_predicate_vec) {
if (!block_column_predicate->evaluate_and(statistic)) {
return false;
}
@@ -155,7 +153,7 @@ bool AndBlockColumnPredicate::evaluate_and(
}
bool AndBlockColumnPredicate::evaluate_and(const segment_v2::BloomFilter* bf)
const {
- for (auto block_column_predicate : _block_column_predicate_vec) {
+ for (auto& block_column_predicate : _block_column_predicate_vec) {
if (!block_column_predicate->evaluate_and(bf)) {
return false;
}
@@ -165,7 +163,7 @@ bool AndBlockColumnPredicate::evaluate_and(const
segment_v2::BloomFilter* bf) co
bool AndBlockColumnPredicate::evaluate_and(const StringRef* dict_words,
const size_t dict_num) const {
- for (auto* predicate : _block_column_predicate_vec) {
+ for (auto& predicate : _block_column_predicate_vec) {
if (!predicate->evaluate_and(dict_words, dict_num)) {
return false;
}
@@ -181,7 +179,7 @@ void
AndBlockColumnPredicate::evaluate_or(vectorized::MutableColumns& block, uin
bool new_flags[selected_size];
memset(new_flags, true, selected_size);
- for (auto block_column_predicate : _block_column_predicate_vec) {
+ for (auto& block_column_predicate : _block_column_predicate_vec) {
block_column_predicate->evaluate_and(block, sel, selected_size,
new_flags);
}
@@ -199,7 +197,7 @@ void
AndBlockColumnPredicate::evaluate_vec(vectorized::MutableColumns& block, ui
} else {
bool new_flags[size];
bool initialized = false;
- for (auto block_column_predicate : _block_column_predicate_vec) {
+ for (auto& block_column_predicate : _block_column_predicate_vec) {
if (initialized) {
block_column_predicate->evaluate_vec(block, size, new_flags);
for (uint16_t j = 0; j < size; j++) {
diff --git a/be/src/olap/block_column_predicate.h
b/be/src/olap/block_column_predicate.h
index 0ddebec3c18..eed5e18329a 100644
--- a/be/src/olap/block_column_predicate.h
+++ b/be/src/olap/block_column_predicate.h
@@ -28,6 +28,7 @@
#include <utility>
#include <vector>
+#include "common/factory_creator.h"
#include "common/status.h"
#include "olap/column_predicate.h"
#include "olap/olap_common.h"
@@ -105,6 +106,8 @@ public:
};
class SingleColumnBlockPredicate : public BlockColumnPredicate {
+ ENABLE_FACTORY_CREATOR(SingleColumnBlockPredicate);
+
public:
explicit SingleColumnBlockPredicate(const ColumnPredicate* pre) :
_predicate(pre) {}
@@ -145,14 +148,10 @@ class MutilColumnBlockPredicate : public
BlockColumnPredicate {
public:
MutilColumnBlockPredicate() = default;
- ~MutilColumnBlockPredicate() override {
- for (auto ptr : _block_column_predicate_vec) {
- delete ptr;
- }
- }
+ ~MutilColumnBlockPredicate() override = default;
bool support_zonemap() const override {
- for (const auto* child_block_predicate : _block_column_predicate_vec) {
+ for (const auto& child_block_predicate : _block_column_predicate_vec) {
if (!child_block_predicate->support_zonemap()) {
return false;
}
@@ -161,29 +160,31 @@ public:
return true;
}
- void add_column_predicate(const BlockColumnPredicate* column_predicate) {
- _block_column_predicate_vec.push_back(column_predicate);
+ void add_column_predicate(std::unique_ptr<BlockColumnPredicate>
column_predicate) {
+ _block_column_predicate_vec.push_back(std::move(column_predicate));
}
size_t num_of_column_predicate() const { return
_block_column_predicate_vec.size(); }
void get_all_column_ids(std::set<ColumnId>& column_id_set) const override {
- for (auto child_block_predicate : _block_column_predicate_vec) {
+ for (auto& child_block_predicate : _block_column_predicate_vec) {
child_block_predicate->get_all_column_ids(column_id_set);
}
}
void get_all_column_predicate(std::set<const ColumnPredicate*>&
predicate_set) const override {
- for (auto child_block_predicate : _block_column_predicate_vec) {
+ for (auto& child_block_predicate : _block_column_predicate_vec) {
child_block_predicate->get_all_column_predicate(predicate_set);
}
}
protected:
- std::vector<const BlockColumnPredicate*> _block_column_predicate_vec;
+ std::vector<std::unique_ptr<BlockColumnPredicate>>
_block_column_predicate_vec;
};
class OrBlockColumnPredicate : public MutilColumnBlockPredicate {
+ ENABLE_FACTORY_CREATOR(OrBlockColumnPredicate);
+
public:
uint16_t evaluate(vectorized::MutableColumns& block, uint16_t* sel,
uint16_t selected_size) const override;
@@ -196,6 +197,8 @@ public:
};
class AndBlockColumnPredicate : public MutilColumnBlockPredicate {
+ ENABLE_FACTORY_CREATOR(AndBlockColumnPredicate);
+
public:
uint16_t evaluate(vectorized::MutableColumns& block, uint16_t* sel,
uint16_t selected_size) const override;
diff --git a/be/src/olap/delete_handler.cpp b/be/src/olap/delete_handler.cpp
index 6c65b8e9709..d2126bbdf3e 100644
--- a/be/src/olap/delete_handler.cpp
+++ b/be/src/olap/delete_handler.cpp
@@ -416,7 +416,7 @@ Status DeleteHandler::init(TabletSchemaSPtr tablet_schema,
return Status::OK();
}
-void DeleteHandler::finalize() {
+DeleteHandler::~DeleteHandler() {
if (!_is_inited) {
return;
}
@@ -440,10 +440,10 @@ void DeleteHandler::get_delete_conditions_after_version(
// now, only query support delete column predicate operator
if (!del_cond.column_predicate_vec.empty()) {
if (del_cond.column_predicate_vec.size() == 1) {
- auto* single_column_block_predicate =
- new
SingleColumnBlockPredicate(del_cond.column_predicate_vec[0]);
+ auto single_column_block_predicate =
SingleColumnBlockPredicate::create_unique(
+ del_cond.column_predicate_vec[0]);
and_block_column_predicate_ptr->add_column_predicate(
- single_column_block_predicate);
+ std::move(single_column_block_predicate));
if (del_predicates_for_zone_map->count(
del_cond.column_predicate_vec[0]->column_id())
< 1) {
del_predicates_for_zone_map->insert(
@@ -453,7 +453,7 @@ void DeleteHandler::get_delete_conditions_after_version(
(*del_predicates_for_zone_map)[del_cond.column_predicate_vec[0]->column_id()]
.push_back(del_cond.column_predicate_vec[0]);
} else {
- auto* or_column_predicate = new OrBlockColumnPredicate();
+ auto or_column_predicate =
OrBlockColumnPredicate::create_unique();
// build or_column_predicate
// when delete from where a = 1 and b = 2, we can not use
del_predicates_for_zone_map to filter zone page,
@@ -464,9 +464,10 @@ void DeleteHandler::get_delete_conditions_after_version(
del_cond.column_predicate_vec.cend(),
[&or_column_predicate](const
ColumnPredicate* predicate) {
or_column_predicate->add_column_predicate(
- new
SingleColumnBlockPredicate(predicate));
+
SingleColumnBlockPredicate::create_unique(predicate));
});
-
and_block_column_predicate_ptr->add_column_predicate(or_column_predicate);
+ and_block_column_predicate_ptr->add_column_predicate(
+ std::move(or_column_predicate));
}
}
}
diff --git a/be/src/olap/delete_handler.h b/be/src/olap/delete_handler.h
index c3365a80cf2..45be5d73ffe 100644
--- a/be/src/olap/delete_handler.h
+++ b/be/src/olap/delete_handler.h
@@ -25,6 +25,7 @@
#include <unordered_map>
#include <vector>
+#include "common/factory_creator.h"
#include "common/status.h"
#include "olap/rowset/rowset_meta.h"
#include "olap/tablet_schema.h"
@@ -55,6 +56,7 @@ struct DeleteConditions {
// NOTE：
// * In the first step, before calling delete_handler.init(), you should
lock the tablet's header file.
class DeleteHandler {
+ ENABLE_FACTORY_CREATOR(DeleteHandler);
// These static method is used to generate delete predicate pb during
write or push handler
public:
// generated DeletePredicatePB by TCondition
@@ -89,7 +91,7 @@ private:
public:
DeleteHandler() = default;
- ~DeleteHandler() { finalize(); }
+ ~DeleteHandler();
// Initialize DeleteHandler, use the delete conditions of this tablet
whose version less than or equal to
// 'version' to fill '_del_conds'.
@@ -107,9 +109,6 @@ public:
[[nodiscard]] bool empty() const { return _del_conds.empty(); }
- // Release an instance of this class.
- void finalize();
-
void get_delete_conditions_after_version(
int64_t version, AndBlockColumnPredicate*
and_block_column_predicate_ptr,
std::unordered_map<int32_t, std::vector<const ColumnPredicate*>>*
diff --git a/be/src/olap/iterators.h b/be/src/olap/iterators.h
index 8b61a35c2e5..5f7c32bf0d4 100644
--- a/be/src/olap/iterators.h
+++ b/be/src/olap/iterators.h
@@ -82,7 +82,7 @@ public:
std::unordered_map<uint32_t, std::shared_ptr<roaring::Roaring>>
delete_bitmap;
std::shared_ptr<AndBlockColumnPredicate> delete_condition_predicates =
- std::make_shared<AndBlockColumnPredicate>();
+ AndBlockColumnPredicate::create_shared();
// reader's column predicate, nullptr if not existed
// used to fiter rows in row block
std::vector<ColumnPredicate*> column_predicates;
diff --git a/be/src/olap/rowset/beta_rowset_reader.cpp
b/be/src/olap/rowset/beta_rowset_reader.cpp
index d57873619b1..71002b69099 100644
--- a/be/src/olap/rowset/beta_rowset_reader.cpp
+++ b/be/src/olap/rowset/beta_rowset_reader.cpp
@@ -56,7 +56,7 @@ BetaRowsetReader::BetaRowsetReader(BetaRowsetSharedPtr rowset)
}
void BetaRowsetReader::reset_read_options() {
- _read_options.delete_condition_predicates =
std::make_shared<AndBlockColumnPredicate>();
+ _read_options.delete_condition_predicates =
AndBlockColumnPredicate::create_shared();
_read_options.column_predicates.clear();
_read_options.col_id_to_predicates.clear();
_read_options.del_predicates_for_zone_map.clear();
@@ -154,11 +154,10 @@ Status
BetaRowsetReader::get_segment_iterators(RowsetReaderContext* read_context
for (auto pred : *(_read_context->predicates)) {
if (_read_options.col_id_to_predicates.count(pred->column_id()) <
1) {
_read_options.col_id_to_predicates.insert(
- {pred->column_id(),
std::make_shared<AndBlockColumnPredicate>()});
+ {pred->column_id(),
AndBlockColumnPredicate::create_shared()});
}
- auto single_column_block_predicate = new
SingleColumnBlockPredicate(pred);
_read_options.col_id_to_predicates[pred->column_id()]->add_column_predicate(
- single_column_block_predicate);
+ SingleColumnBlockPredicate::create_unique(pred));
}
}
@@ -207,11 +206,10 @@ Status
BetaRowsetReader::get_segment_iterators(RowsetReaderContext* read_context
for (auto pred : *(_read_context->value_predicates)) {
if
(_read_options.col_id_to_predicates.count(pred->column_id()) < 1) {
_read_options.col_id_to_predicates.insert(
- {pred->column_id(),
std::make_shared<AndBlockColumnPredicate>()});
+ {pred->column_id(),
AndBlockColumnPredicate::create_shared()});
}
- auto single_column_block_predicate = new
SingleColumnBlockPredicate(pred);
_read_options.col_id_to_predicates[pred->column_id()]->add_column_predicate(
- single_column_block_predicate);
+ SingleColumnBlockPredicate::create_unique(pred));
}
}
}
diff --git a/be/src/olap/rowset/segment_v2/segment.cpp
b/be/src/olap/rowset/segment_v2/segment.cpp
index 6e09e76f51c..674d5c31b02 100644
--- a/be/src/olap/rowset/segment_v2/segment.cpp
+++ b/be/src/olap/rowset/segment_v2/segment.cpp
@@ -156,8 +156,8 @@ Status Segment::new_iterator(SchemaSPtr schema, const
StorageReadOptions& read_o
int32_t uid =
read_options.tablet_schema->column(runtime_predicate->column_id()).unique_id();
AndBlockColumnPredicate and_predicate;
- auto* single_predicate = new
SingleColumnBlockPredicate(runtime_predicate.get());
- and_predicate.add_column_predicate(single_predicate);
+ and_predicate.add_column_predicate(
+
SingleColumnBlockPredicate::create_unique(runtime_predicate.get()));
if (_column_readers.contains(uid) &&
can_apply_predicate_safely(runtime_predicate->column_id(),
runtime_predicate.get(),
*schema,
read_options.io_ctx.reader_type) &&
@@ -200,11 +200,10 @@ Status Segment::new_iterator(SchemaSPtr schema, const
StorageReadOptions& read_o
if
(!options_with_pruned_predicates.col_id_to_predicates.contains(
pred->column_id())) {
options_with_pruned_predicates.col_id_to_predicates.insert(
- {pred->column_id(),
std::make_shared<AndBlockColumnPredicate>()});
+ {pred->column_id(),
AndBlockColumnPredicate::create_shared()});
}
- auto* single_column_block_predicate = new
SingleColumnBlockPredicate(pred);
options_with_pruned_predicates.col_id_to_predicates[pred->column_id()]
- ->add_column_predicate(single_column_block_predicate);
+
->add_column_predicate(SingleColumnBlockPredicate::create_unique(pred));
}
return iter->get()->init(options_with_pruned_predicates);
}
diff --git a/be/src/olap/rowset/segment_v2/segment_iterator.cpp
b/be/src/olap/rowset/segment_v2/segment_iterator.cpp
index 546e3b8fb8e..c9848f6f866 100644
--- a/be/src/olap/rowset/segment_v2/segment_iterator.cpp
+++ b/be/src/olap/rowset/segment_v2/segment_iterator.cpp
@@ -600,8 +600,8 @@ Status
SegmentIterator::_get_row_ranges_from_conditions(RowRanges* condition_row
runtime_predicate.get(),
*_schema,
_opts.io_ctx.reader_type)) {
AndBlockColumnPredicate and_predicate;
- auto* single_predicate = new
SingleColumnBlockPredicate(runtime_predicate.get());
- and_predicate.add_column_predicate(single_predicate);
+ and_predicate.add_column_predicate(
+
SingleColumnBlockPredicate::create_unique(runtime_predicate.get()));
RowRanges column_rp_row_ranges =
RowRanges::create_single(num_rows());
RETURN_IF_ERROR(_column_iterators[runtime_predicate->column_id()]
diff --git a/be/src/olap/tablet_reader.cpp b/be/src/olap/tablet_reader.cpp
index 8e4f7a28aaf..86823ac36c7 100644
--- a/be/src/olap/tablet_reader.cpp
+++ b/be/src/olap/tablet_reader.cpp
@@ -110,8 +110,6 @@ void TabletReader::ReadSource::fill_delete_predicates() {
TabletReader::~TabletReader() {
VLOG_NOTICE << "merged rows:" << _merged_rows;
- _delete_handler.finalize();
-
for (auto pred : _col_predicates) {
delete pred;
}
diff --git a/be/test/olap/block_column_predicate_test.cpp
b/be/test/olap/block_column_predicate_test.cpp
index c310e1d43a2..8c8231e62ae 100644
--- a/be/test/olap/block_column_predicate_test.cpp
+++ b/be/test/olap/block_column_predicate_test.cpp
@@ -98,12 +98,12 @@ TEST_F(BlockColumnPredicateTest, AND_MUTI_COLUMN_VEC) {
new ComparisonPredicateBase<TYPE_INT, PredicateType::LT>(col_idx,
less_value));
std::unique_ptr<ColumnPredicate> great_pred(
new ComparisonPredicateBase<TYPE_INT, PredicateType::GT>(col_idx,
great_value));
- auto single_less_pred = new SingleColumnBlockPredicate(less_pred.get());
- auto single_great_pred = new SingleColumnBlockPredicate(great_pred.get());
+ auto single_less_pred =
SingleColumnBlockPredicate::create_unique(less_pred.get());
+ auto single_great_pred =
SingleColumnBlockPredicate::create_unique(great_pred.get());
AndBlockColumnPredicate and_block_column_pred;
- and_block_column_pred.add_column_predicate(single_less_pred);
- and_block_column_pred.add_column_predicate(single_great_pred);
+ and_block_column_pred.add_column_predicate(std::move(single_less_pred));
+ and_block_column_pred.add_column_predicate(std::move(single_great_pred));
uint16_t sel_idx[rows];
uint16_t selected_size = rows;
@@ -133,12 +133,12 @@ TEST_F(BlockColumnPredicateTest, OR_MUTI_COLUMN_VEC) {
new ComparisonPredicateBase<TYPE_INT, PredicateType::LT>(col_idx,
less_value));
std::unique_ptr<ColumnPredicate> great_pred(
new ComparisonPredicateBase<TYPE_INT, PredicateType::GT>(col_idx,
great_value));
- auto single_less_pred = new SingleColumnBlockPredicate(less_pred.get());
- auto single_great_pred = new SingleColumnBlockPredicate(great_pred.get());
+ auto single_less_pred =
SingleColumnBlockPredicate::create_unique(less_pred.get());
+ auto single_great_pred =
SingleColumnBlockPredicate::create_unique(great_pred.get());
OrBlockColumnPredicate or_block_column_pred;
- or_block_column_pred.add_column_predicate(single_less_pred);
- or_block_column_pred.add_column_predicate(single_great_pred);
+ or_block_column_pred.add_column_predicate(std::move(single_less_pred));
+ or_block_column_pred.add_column_predicate(std::move(single_great_pred));
uint16_t sel_idx[rows];
uint16_t selected_size = rows;
@@ -173,13 +173,16 @@ TEST_F(BlockColumnPredicateTest, OR_AND_MUTI_COLUMN_VEC) {
// Test for and or single
// (column < 5 and column > 3) or column < 3
- auto and_block_column_pred = new AndBlockColumnPredicate();
- and_block_column_pred->add_column_predicate(new
SingleColumnBlockPredicate(less_pred.get()));
- and_block_column_pred->add_column_predicate(new
SingleColumnBlockPredicate(great_pred.get()));
+ auto and_block_column_pred = AndBlockColumnPredicate::create_unique();
+ and_block_column_pred->add_column_predicate(
+ SingleColumnBlockPredicate::create_unique(less_pred.get()));
+ and_block_column_pred->add_column_predicate(
+ SingleColumnBlockPredicate::create_unique(great_pred.get()));
OrBlockColumnPredicate or_block_column_pred;
- or_block_column_pred.add_column_predicate(and_block_column_pred);
- or_block_column_pred.add_column_predicate(new
SingleColumnBlockPredicate(less_pred1.get()));
+
or_block_column_pred.add_column_predicate(std::move(and_block_column_pred));
+ or_block_column_pred.add_column_predicate(
+ SingleColumnBlockPredicate::create_unique(less_pred1.get()));
uint16_t sel_idx[rows];
uint16_t selected_size = rows;
@@ -201,13 +204,16 @@ TEST_F(BlockColumnPredicateTest, OR_AND_MUTI_COLUMN_VEC) {
// Test for single or and
// column < 3 or (column < 5 and column > 3)
- auto and_block_column_pred1 = new AndBlockColumnPredicate();
- and_block_column_pred1->add_column_predicate(new
SingleColumnBlockPredicate(less_pred.get()));
- and_block_column_pred1->add_column_predicate(new
SingleColumnBlockPredicate(great_pred.get()));
+ auto and_block_column_pred1 = AndBlockColumnPredicate::create_unique();
+ and_block_column_pred1->add_column_predicate(
+ SingleColumnBlockPredicate::create_unique(less_pred.get()));
+ and_block_column_pred1->add_column_predicate(
+ SingleColumnBlockPredicate::create_unique(great_pred.get()));
OrBlockColumnPredicate or_block_column_pred1;
- or_block_column_pred1.add_column_predicate(new
SingleColumnBlockPredicate(less_pred1.get()));
- or_block_column_pred1.add_column_predicate(and_block_column_pred1);
+ or_block_column_pred1.add_column_predicate(
+ SingleColumnBlockPredicate::create_unique(less_pred1.get()));
+
or_block_column_pred1.add_column_predicate(std::move(and_block_column_pred1));
selected_size = or_block_column_pred1.evaluate(block, sel_idx,
selected_size);
EXPECT_EQ(selected_size, 4);
@@ -234,13 +240,16 @@ TEST_F(BlockColumnPredicateTest, AND_OR_MUTI_COLUMN_VEC) {
// Test for and or single
// (column < 5 or column < 3) and column > 3
- auto or_block_column_pred = new OrBlockColumnPredicate();
- or_block_column_pred->add_column_predicate(new
SingleColumnBlockPredicate(less_pred.get()));
- or_block_column_pred->add_column_predicate(new
SingleColumnBlockPredicate(less_pred1.get()));
+ auto or_block_column_pred = OrBlockColumnPredicate::create_unique();
+ or_block_column_pred->add_column_predicate(
+ SingleColumnBlockPredicate::create_unique(less_pred.get()));
+ or_block_column_pred->add_column_predicate(
+ SingleColumnBlockPredicate::create_unique(less_pred1.get()));
AndBlockColumnPredicate and_block_column_pred;
- and_block_column_pred.add_column_predicate(or_block_column_pred);
- and_block_column_pred.add_column_predicate(new
SingleColumnBlockPredicate(great_pred.get()));
+
and_block_column_pred.add_column_predicate(std::move(or_block_column_pred));
+ and_block_column_pred.add_column_predicate(
+ SingleColumnBlockPredicate::create_unique(great_pred.get()));
uint16_t sel_idx[rows];
uint16_t selected_size = rows;
@@ -260,13 +269,16 @@ TEST_F(BlockColumnPredicateTest, AND_OR_MUTI_COLUMN_VEC) {
// Test for single or and
// column > 3 and (column < 5 or column < 3)
- auto or_block_column_pred1 = new OrBlockColumnPredicate();
- or_block_column_pred1->add_column_predicate(new
SingleColumnBlockPredicate(less_pred.get()));
- or_block_column_pred1->add_column_predicate(new
SingleColumnBlockPredicate(less_pred1.get()));
+ auto or_block_column_pred1 = OrBlockColumnPredicate::create_unique();
+ or_block_column_pred1->add_column_predicate(
+ SingleColumnBlockPredicate::create_unique(less_pred.get()));
+ or_block_column_pred1->add_column_predicate(
+ SingleColumnBlockPredicate::create_unique(less_pred1.get()));
AndBlockColumnPredicate and_block_column_pred1;
- and_block_column_pred1.add_column_predicate(new
SingleColumnBlockPredicate(great_pred.get()));
- and_block_column_pred1.add_column_predicate(or_block_column_pred1);
+ and_block_column_pred1.add_column_predicate(
+ SingleColumnBlockPredicate::create_unique(great_pred.get()));
+
and_block_column_pred1.add_column_predicate(std::move(or_block_column_pred1));
EXPECT_EQ(selected_size, 1);
EXPECT_EQ(pred_col->get_data()[sel_idx[0]], 4);
diff --git a/be/test/olap/delete_handler_test.cpp
b/be/test/olap/delete_handler_test.cpp
index 3779dc20d21..3a22f317535 100644
--- a/be/test/olap/delete_handler_test.cpp
+++ b/be/test/olap/delete_handler_test.cpp
@@ -910,7 +910,6 @@ protected:
void TearDown() {
// Remove all dir.
tablet.reset();
- _delete_handler.finalize();
static_cast<void>(k_engine->tablet_manager()->drop_tablet(
_create_tablet.tablet_id, _create_tablet.replica_id, false));
EXPECT_TRUE(
@@ -970,7 +969,6 @@ TEST_F(TestDeleteHandler, ValueWithQuote) {
auto res = _delete_handler.init(tablet->tablet_schema(),
get_delete_predicates(), 5);
EXPECT_EQ(Status::OK(), res);
- _delete_handler.finalize();
}
TEST_F(TestDeleteHandler, ValueWithoutQuote) {
@@ -983,7 +981,6 @@ TEST_F(TestDeleteHandler, ValueWithoutQuote) {
auto res = _delete_handler.init(tablet->tablet_schema(),
get_delete_predicates(), 5);
EXPECT_EQ(Status::OK(), res);
- _delete_handler.finalize();
}
TEST_F(TestDeleteHandler, InitSuccess) {
@@ -1057,7 +1054,6 @@ TEST_F(TestDeleteHandler, InitSuccess) {
// Get delete conditions which version <= 5
res = _delete_handler.init(tablet->tablet_schema(),
get_delete_predicates(), 5);
EXPECT_EQ(Status::OK(), res);
- _delete_handler.finalize();
}
// 测试一个过滤条件包含的子条件之间是and关系,
@@ -1089,8 +1085,6 @@ TEST_F(TestDeleteHandler, FilterDataSubconditions) {
// 指定版本号为10以载入Header中的所有过滤条件(在这个case中，只有过滤条件1)
res = _delete_handler.init(tablet->tablet_schema(),
get_delete_predicates(), 4);
EXPECT_EQ(Status::OK(), res);
-
- _delete_handler.finalize();
}
// 测试多个过滤条件之间是or关系，
@@ -1150,8 +1144,6 @@ TEST_F(TestDeleteHandler, FilterDataConditions) {
// 指定版本号为4以载入meta中的所有过滤条件(在这个case中，只有过滤条件1)
res = _delete_handler.init(tablet->tablet_schema(),
get_delete_predicates(), 4);
EXPECT_EQ(Status::OK(), res);
-
- _delete_handler.finalize();
}
// 测试在过滤时，版本号小于数据版本的过滤条件将不起作用
@@ -1196,8 +1188,6 @@ TEST_F(TestDeleteHandler, FilterDataVersion) {
// 指定版本号为4以载入meta中的所有过滤条件(过滤条件1，过滤条件2)
res = _delete_handler.init(tablet->tablet_schema(),
get_delete_predicates(), 4);
EXPECT_EQ(Status::OK(), res);
-
- _delete_handler.finalize();
}
} // namespace doris
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
