This is an automated email from the ASF dual-hosted git repository.
zclll pushed a commit to branch tpc_preview6
in repository https://gitbox.apache.org/repos/asf/doris.git
The following commit(s) were added to refs/heads/tpc_preview6 by this push:
new a262b8df803 [tpc preview](expr) Add short-circuit logic to the runtime
filter's expr filter. (#60264)
a262b8df803 is described below
commit a262b8df8036c9496d48bb24ff771b5e21f8c650
Author: Mryange <[email protected]>
AuthorDate: Tue Jan 27 16:46:22 2026 +0800
[tpc preview](expr) Add short-circuit logic to the runtime filter's expr
filter. (#60264)
---
be/src/exprs/bitmapfilter_predicate.h | 25 +++--
be/src/exprs/bloom_filter_func.h | 8 +-
be/src/exprs/bloom_filter_func_adaptor.h | 51 +++++++---
be/src/exprs/hybrid_set.h | 139 ++++++++++++++++++++--------
be/src/vec/exprs/vbitmap_predicate.cpp | 21 ++++-
be/src/vec/exprs/vbitmap_predicate.h | 6 +-
be/src/vec/exprs/vbloom_predicate.cpp | 18 +++-
be/src/vec/exprs/vbloom_predicate.h | 8 ++
be/src/vec/exprs/vdirect_in_predicate.h | 16 ++--
be/src/vec/exprs/vectorized_fn_call.cpp | 3 +-
be/src/vec/exprs/vectorized_fn_call.h | 3 +-
be/src/vec/exprs/vexpr.h | 3 +-
be/src/vec/exprs/vruntimefilter_wrapper.cpp | 4 +-
13 files changed, 222 insertions(+), 83 deletions(-)
diff --git a/be/src/exprs/bitmapfilter_predicate.h
b/be/src/exprs/bitmapfilter_predicate.h
index e8f149ce87f..0f9a5009a6b 100644
--- a/be/src/exprs/bitmapfilter_predicate.h
+++ b/be/src/exprs/bitmapfilter_predicate.h
@@ -34,7 +34,7 @@ public:
virtual uint16_t find_fixed_len_olap_engine(const char* data, const
uint8_t* nullmap,
uint16_t* offsets, int number)
= 0;
virtual void find_batch(const char* data, const uint8_t* nullmap, size_t
number,
- uint8_t* results) const = 0;
+ uint8_t* results, const uint8_t* __restrict filter
= nullptr) const = 0;
virtual size_t size() const = 0;
bool is_not_in() const { return _not_in; }
void set_not_in(bool not_in) { _not_in = not_in; }
@@ -59,8 +59,8 @@ public:
uint16_t find_fixed_len_olap_engine(const char* data, const uint8_t*
nullmap, uint16_t* offsets,
int number) override;
- void find_batch(const char* data, const uint8_t* nullmap, size_t number,
- uint8_t* results) const override;
+ void find_batch(const char* data, const uint8_t* nullmap, size_t number,
uint8_t* results,
+ const uint8_t* __restrict filter = nullptr) const override;
size_t size() const override { return _bitmap_value->cardinality(); }
@@ -106,16 +106,27 @@ uint16_t
BitmapFilterFunc<type>::find_fixed_len_olap_engine(const char* data,
template <PrimitiveType type>
void BitmapFilterFunc<type>::find_batch(const char* data, const uint8_t*
nullmap, size_t number,
- uint8_t* results) const {
- for (size_t i = 0; i < number; i++) {
+ uint8_t* results, const uint8_t*
__restrict filter) const {
+ auto update = [&](size_t i) {
results[i] = false;
if (nullmap != nullptr && nullmap[i]) {
- continue;
+ return;
}
if (!find(*((CppType*)data + i))) {
- continue;
+ return;
}
results[i] = true;
+ };
+ if (filter != nullptr) {
+ for (size_t i = 0; i < number; i++) {
+ if (filter[i]) {
+ update(i);
+ }
+ }
+ } else {
+ for (size_t i = 0; i < number; i++) {
+ update(i);
+ }
}
}
diff --git a/be/src/exprs/bloom_filter_func.h b/be/src/exprs/bloom_filter_func.h
index ad6d7cc2d43..048a9498ab1 100644
--- a/be/src/exprs/bloom_filter_func.h
+++ b/be/src/exprs/bloom_filter_func.h
@@ -134,7 +134,8 @@ public:
virtual void insert_fixed_len(const vectorized::ColumnPtr& column, size_t
start) = 0;
- virtual void find_fixed_len(const vectorized::ColumnPtr& column, uint8_t*
results) = 0;
+ virtual void find_fixed_len(const vectorized::ColumnPtr& column, uint8_t*
results,
+ const uint8_t* __restrict filter = nullptr) =
0;
virtual uint16_t find_fixed_len_olap_engine(const char* data, const
uint8_t* nullmap,
uint16_t* offsets, int number,
@@ -176,8 +177,9 @@ public:
OpV2::insert_batch(*_bloom_filter, column, start);
}
- void find_fixed_len(const vectorized::ColumnPtr& column, uint8_t* results)
override {
- OpV2::find_batch(*_bloom_filter, column, results);
+ void find_fixed_len(const vectorized::ColumnPtr& column, uint8_t* results,
+ const uint8_t* __restrict filter = nullptr) override {
+ OpV2::find_batch(*_bloom_filter, column, results, filter);
}
template <bool is_nullable>
diff --git a/be/src/exprs/bloom_filter_func_adaptor.h
b/be/src/exprs/bloom_filter_func_adaptor.h
index 70801bc2138..1420a53dc78 100644
--- a/be/src/exprs/bloom_filter_func_adaptor.h
+++ b/be/src/exprs/bloom_filter_func_adaptor.h
@@ -87,6 +87,21 @@ struct CommonFindOp {
number,
is_parse_column);
}
+ template <typename Func>
+ static void for_each_with_filter(size_t n, const uint8_t* __restrict
filter, Func&& f) {
+ if (filter != nullptr) {
+ for (size_t i = 0; i < n; ++i) {
+ if (filter[i]) {
+ std::forward<Func>(f)(i);
+ }
+ }
+ } else {
+ for (size_t i = 0; i < n; ++i) {
+ std::forward<Func>(f)(i);
+ }
+ }
+ }
+
static void insert_batch(BloomFilterAdaptor& bloom_filter, const
vectorized::ColumnPtr& column,
size_t start) {
const auto size = column->size();
@@ -122,7 +137,8 @@ struct CommonFindOp {
}
static void find_batch(const BloomFilterAdaptor& bloom_filter,
- const vectorized::ColumnPtr& column, uint8_t*
results) {
+ const vectorized::ColumnPtr& column, uint8_t*
results,
+ const uint8_t* __restrict filter) {
const T* __restrict data = nullptr;
const uint8_t* __restrict nullmap = nullptr;
if (column->is_nullable()) {
@@ -140,23 +156,27 @@ struct CommonFindOp {
const auto size = column->size();
if (nullmap) {
- for (size_t i = 0; i < size; i++) {
+ auto update = [&](size_t i) {
if (!nullmap[i]) {
results[i] =
bloom_filter.test_element<fixed_len_to_uint32_method>(data[i]);
} else {
results[i] = bloom_filter.contain_null();
}
- }
+ };
+ for_each_with_filter(size, filter, update);
} else {
- for (size_t i = 0; i < size; i++) {
+ auto update = [&](size_t i) {
results[i] =
bloom_filter.test_element<fixed_len_to_uint32_method>(data[i]);
- }
+ };
+ for_each_with_filter(size, filter, update);
}
}
};
template <typename fixed_len_to_uint32_method>
struct StringFindOp : CommonFindOp<fixed_len_to_uint32_method, StringRef> {
+ using CommonFindOp<fixed_len_to_uint32_method,
StringRef>::for_each_with_filter;
+
static void insert_batch(BloomFilterAdaptor& bloom_filter, const
vectorized::ColumnPtr& column,
size_t start) {
auto _insert_batch_col_str = [&](const auto& col, const uint8_t*
__restrict nullmap,
@@ -196,7 +216,8 @@ struct StringFindOp :
CommonFindOp<fixed_len_to_uint32_method, StringRef> {
}
static void find_batch(const BloomFilterAdaptor& bloom_filter,
- const vectorized::ColumnPtr& column, uint8_t*
results) {
+ const vectorized::ColumnPtr& column, uint8_t*
results,
+ const uint8_t* __restrict filter) {
if (column->is_nullable()) {
const auto* nullable = assert_cast<const
vectorized::ColumnNullable*>(column.get());
const auto& col =
@@ -204,28 +225,32 @@ struct StringFindOp :
CommonFindOp<fixed_len_to_uint32_method, StringRef> {
const auto& nullmap =
assert_cast<const
vectorized::ColumnUInt8&>(nullable->get_null_map_column())
.get_data();
-
if (nullable->has_null()) {
- for (size_t i = 0; i < col.size(); i++) {
+ auto update = [&](size_t i) {
if (!nullmap[i]) {
results[i] =
bloom_filter.test_element<fixed_len_to_uint32_method>(
col.get_data_at(i));
} else {
results[i] = bloom_filter.contain_null();
}
- }
+ };
+ for_each_with_filter(column->size(), filter, update);
} else {
- for (size_t i = 0; i < col.size(); i++) {
+ auto update = [&](size_t i) {
results[i] =
bloom_filter.test_element<fixed_len_to_uint32_method>(
col.get_data_at(i));
- }
+ };
+ for_each_with_filter(column->size(), filter, update);
}
} else {
const auto& col = assert_cast<const
vectorized::ColumnString*>(column.get());
- for (size_t i = 0; i < col->size(); i++) {
+
+ auto update = [&](size_t i) {
results[i] =
bloom_filter.test_element<fixed_len_to_uint32_method>(col->get_data_at(i));
- }
+ };
+
+ for_each_with_filter(column->size(), filter, update);
}
}
};
diff --git a/be/src/exprs/hybrid_set.h b/be/src/exprs/hybrid_set.h
index f7cb79915b0..d2f0c5ec1f3 100644
--- a/be/src/exprs/hybrid_set.h
+++ b/be/src/exprs/hybrid_set.h
@@ -245,17 +245,19 @@ public:
virtual bool find(const void* data, size_t) const = 0;
virtual void find_batch(const doris::vectorized::IColumn& column, size_t
rows,
- doris::vectorized::ColumnUInt8::Container&
results) = 0;
+ doris::vectorized::ColumnUInt8::Container& results,
+ const uint8_t* __restrict filter = nullptr) = 0;
virtual void find_batch_negative(const doris::vectorized::IColumn& column,
size_t rows,
-
doris::vectorized::ColumnUInt8::Container& results) = 0;
+
doris::vectorized::ColumnUInt8::Container& results,
+ const uint8_t* __restrict filter =
nullptr) = 0;
virtual void find_batch_nullable(const doris::vectorized::IColumn& column,
size_t rows,
const doris::vectorized::NullMap&
null_map,
-
doris::vectorized::ColumnUInt8::Container& results) = 0;
-
- virtual void find_batch_nullable_negative(
- const doris::vectorized::IColumn& column, size_t rows,
- const doris::vectorized::NullMap& null_map,
- doris::vectorized::ColumnUInt8::Container& results) = 0;
+
doris::vectorized::ColumnUInt8::Container& results,
+ const uint8_t* __restrict filter =
nullptr) = 0;
+ virtual void find_batch_nullable_negative(const
doris::vectorized::IColumn& column, size_t rows,
+ const
doris::vectorized::NullMap& null_map,
+
doris::vectorized::ColumnUInt8::Container& results,
+ const uint8_t* __restrict filter
= nullptr) = 0;
virtual void to_pb(PInFilter* filter) = 0;
virtual uint64_t get_digest(uint64_t seed) = 0;
@@ -338,31 +340,36 @@ public:
bool find(const void* data, size_t /*unused*/) const override { return
find(data); }
void find_batch(const doris::vectorized::IColumn& column, size_t rows,
- doris::vectorized::ColumnUInt8::Container& results)
override {
- _find_batch<false, false>(column, rows, nullptr, results);
+ doris::vectorized::ColumnUInt8::Container& results,
+ const uint8_t* __restrict filter = nullptr) override {
+ _find_batch<false, false>(column, rows, nullptr, results, filter);
}
void find_batch_negative(const doris::vectorized::IColumn& column, size_t
rows,
- doris::vectorized::ColumnUInt8::Container&
results) override {
- _find_batch<false, true>(column, rows, nullptr, results);
+ doris::vectorized::ColumnUInt8::Container&
results,
+ const uint8_t* __restrict filter = nullptr)
override {
+ _find_batch<false, true>(column, rows, nullptr, results, filter);
}
void find_batch_nullable(const doris::vectorized::IColumn& column, size_t
rows,
const doris::vectorized::NullMap& null_map,
- doris::vectorized::ColumnUInt8::Container&
results) override {
- _find_batch<true, false>(column, rows, &null_map, results);
+ doris::vectorized::ColumnUInt8::Container&
results,
+ const uint8_t* __restrict filter = nullptr)
override {
+ _find_batch<true, false>(column, rows, &null_map, results, filter);
}
void find_batch_nullable_negative(const doris::vectorized::IColumn&
column, size_t rows,
const doris::vectorized::NullMap&
null_map,
-
doris::vectorized::ColumnUInt8::Container& results) override {
- _find_batch<true, true>(column, rows, &null_map, results);
+
doris::vectorized::ColumnUInt8::Container& results,
+ const uint8_t* __restrict filter =
nullptr) override {
+ _find_batch<true, true>(column, rows, &null_map, results, filter);
}
template <bool is_nullable, bool is_negative>
void _find_batch(const doris::vectorized::IColumn& column, size_t rows,
const doris::vectorized::NullMap* null_map,
- doris::vectorized::ColumnUInt8::Container& results) {
+ doris::vectorized::ColumnUInt8::Container& results,
+ const uint8_t* __restrict filter) {
auto& col = assert_cast<const ColumnType&>(column);
const auto* __restrict data = (ElementType*)col.get_data().data();
const uint8_t* __restrict null_map_data;
@@ -375,7 +382,8 @@ public:
}
auto* __restrict result_data = results.data();
- for (size_t i = 0; i < rows; ++i) {
+
+ auto update_value = [&](size_t i) {
if constexpr (!is_nullable && !is_negative) {
result_data[i] = _set.find(data[i]);
} else if constexpr (!is_nullable && is_negative) {
@@ -385,6 +393,17 @@ public:
} else { // (is_nullable && is_negative)
result_data[i] = !(_set.find(data[i]) & (!null_map_data[i]));
}
+ };
+ if (filter != nullptr) {
+ for (size_t i = 0; i < rows; i++) {
+ if (filter[i]) {
+ update_value(i);
+ }
+ }
+ } else {
+ for (size_t i = 0; i < rows; i++) {
+ update_value(i);
+ }
}
}
@@ -525,31 +544,36 @@ public:
}
void find_batch(const doris::vectorized::IColumn& column, size_t rows,
- doris::vectorized::ColumnUInt8::Container& results)
override {
- _find_batch<false, false>(column, rows, nullptr, results);
+ doris::vectorized::ColumnUInt8::Container& results,
+ const uint8_t* __restrict filter = nullptr) override {
+ _find_batch<false, false>(column, rows, nullptr, results, filter);
}
void find_batch_negative(const doris::vectorized::IColumn& column, size_t
rows,
- doris::vectorized::ColumnUInt8::Container&
results) override {
- _find_batch<false, true>(column, rows, nullptr, results);
+ doris::vectorized::ColumnUInt8::Container&
results,
+ const uint8_t* __restrict filter = nullptr)
override {
+ _find_batch<false, true>(column, rows, nullptr, results, filter);
}
void find_batch_nullable(const doris::vectorized::IColumn& column, size_t
rows,
const doris::vectorized::NullMap& null_map,
- doris::vectorized::ColumnUInt8::Container&
results) override {
- _find_batch<true, false>(column, rows, &null_map, results);
+ doris::vectorized::ColumnUInt8::Container&
results,
+ const uint8_t* __restrict filter = nullptr)
override {
+ _find_batch<true, false>(column, rows, &null_map, results, filter);
}
void find_batch_nullable_negative(const doris::vectorized::IColumn&
column, size_t rows,
const doris::vectorized::NullMap&
null_map,
-
doris::vectorized::ColumnUInt8::Container& results) override {
- _find_batch<true, true>(column, rows, &null_map, results);
+
doris::vectorized::ColumnUInt8::Container& results,
+ const uint8_t* __restrict filter =
nullptr) override {
+ _find_batch<true, true>(column, rows, &null_map, results, filter);
}
template <bool is_nullable, bool is_negative>
void _find_batch(const doris::vectorized::IColumn& column, size_t rows,
const doris::vectorized::NullMap* null_map,
- doris::vectorized::ColumnUInt8::Container& results) {
+ doris::vectorized::ColumnUInt8::Container& results,
+ const uint8_t* __restrict filter) {
const auto& col = assert_cast<const
doris::vectorized::ColumnString&>(column);
const uint8_t* __restrict null_map_data;
if constexpr (is_nullable) {
@@ -561,7 +585,8 @@ public:
}
auto* __restrict result_data = results.data();
- for (size_t i = 0; i < rows; ++i) {
+
+ auto update_value = [&](size_t i) {
const auto& string_data = col.get_data_at(i).to_string();
if constexpr (!is_nullable && !is_negative) {
result_data[i] = _set.find(string_data);
@@ -572,6 +597,19 @@ public:
} else { // (is_nullable && is_negative)
result_data[i] = !(_set.find(string_data) &
(!null_map_data[i]));
}
+ };
+
+ if (filter != nullptr) {
+ for (size_t i = 0; i < rows; ++i) {
+ if (filter[i]) {
+ update_value(i);
+ }
+ }
+ return;
+ } else {
+ for (size_t i = 0; i < rows; ++i) {
+ update_value(i);
+ }
}
}
@@ -714,31 +752,36 @@ public:
}
void find_batch(const doris::vectorized::IColumn& column, size_t rows,
- doris::vectorized::ColumnUInt8::Container& results)
override {
- _find_batch<false, false>(column, rows, nullptr, results);
+ doris::vectorized::ColumnUInt8::Container& results,
+ const uint8_t* __restrict filter) override {
+ _find_batch<false, false>(column, rows, nullptr, results, filter);
}
void find_batch_negative(const doris::vectorized::IColumn& column, size_t
rows,
- doris::vectorized::ColumnUInt8::Container&
results) override {
- _find_batch<false, true>(column, rows, nullptr, results);
+ doris::vectorized::ColumnUInt8::Container&
results,
+ const uint8_t* __restrict filter) override {
+ _find_batch<false, true>(column, rows, nullptr, results, filter);
}
void find_batch_nullable(const doris::vectorized::IColumn& column, size_t
rows,
const doris::vectorized::NullMap& null_map,
- doris::vectorized::ColumnUInt8::Container&
results) override {
- _find_batch<true, false>(column, rows, &null_map, results);
+ doris::vectorized::ColumnUInt8::Container&
results,
+ const uint8_t* __restrict filter) override {
+ _find_batch<true, false>(column, rows, &null_map, results, filter);
}
void find_batch_nullable_negative(const doris::vectorized::IColumn&
column, size_t rows,
const doris::vectorized::NullMap&
null_map,
-
doris::vectorized::ColumnUInt8::Container& results) override {
- _find_batch<true, true>(column, rows, &null_map, results);
+
doris::vectorized::ColumnUInt8::Container& results,
+ const uint8_t* __restrict filter)
override {
+ _find_batch<true, true>(column, rows, &null_map, results, filter);
}
template <bool is_nullable, bool is_negative>
void _find_batch(const doris::vectorized::IColumn& column, size_t rows,
const doris::vectorized::NullMap* null_map,
- doris::vectorized::ColumnUInt8::Container& results) {
+ doris::vectorized::ColumnUInt8::Container& results,
+ const uint8_t* __restrict filter) {
const auto& col = assert_cast<const
doris::vectorized::ColumnString&>(column);
const auto& offset = col.get_offsets();
const uint8_t* __restrict data = col.get_chars().data();
@@ -752,8 +795,8 @@ public:
}
auto* __restrict result_data = results.data();
- for (size_t i = 0; i < rows; ++i) {
- uint32_t len = offset[i] - offset[i - 1];
+
+ auto update_value = [&](size_t i, uint32_t len) {
if constexpr (!is_nullable && !is_negative) {
result_data[i] = _set.find(StringRef(data, len));
} else if constexpr (!is_nullable && is_negative) {
@@ -763,7 +806,23 @@ public:
} else { // (is_nullable && is_negative)
result_data[i] = !((!null_map_data[i]) &
_set.find(StringRef(data, len)));
}
- data += len;
+ };
+
+ if (filter != nullptr) {
+ for (size_t i = 0; i < rows; ++i) {
+ uint32_t len = offset[i] - offset[i - 1];
+ if (filter[i]) {
+ update_value(i, len);
+ }
+ data += len;
+ }
+ return;
+ } else {
+ for (size_t i = 0; i < rows; ++i) {
+ uint32_t len = offset[i] - offset[i - 1];
+ update_value(i, len);
+ data += len;
+ }
}
}
diff --git a/be/src/vec/exprs/vbitmap_predicate.cpp
b/be/src/vec/exprs/vbitmap_predicate.cpp
index dc3956c3d0b..c69fede0111 100644
--- a/be/src/vec/exprs/vbitmap_predicate.cpp
+++ b/be/src/vec/exprs/vbitmap_predicate.cpp
@@ -75,8 +75,9 @@ doris::Status
vectorized::VBitmapPredicate::open(doris::RuntimeState* state,
return Status::OK();
}
-Status VBitmapPredicate::execute_column(VExprContext* context, const Block*
block, size_t count,
- ColumnPtr& result_column) const {
+Status VBitmapPredicate::_do_execute(VExprContext* context, const Block* block,
+ const uint8_t* __restrict filter, size_t
count,
+ ColumnPtr& result_column) const {
DCHECK(_open_finished || block == nullptr);
DCHECK_EQ(_children.size(), 1);
@@ -95,9 +96,9 @@ Status VBitmapPredicate::execute_column(VExprContext*
context, const Block* bloc
auto column_nullmap = assert_cast<const
ColumnNullable*>(argument_column.get())
->get_null_map_column_ptr();
_filter->find_batch(column_nested->get_raw_data().data,
- (uint8_t*)column_nullmap->get_raw_data().data, sz,
ptr);
+ (uint8_t*)column_nullmap->get_raw_data().data, sz,
ptr, filter);
} else {
- _filter->find_batch(argument_column->get_raw_data().data, nullptr, sz,
ptr);
+ _filter->find_batch(argument_column->get_raw_data().data, nullptr, sz,
ptr, filter);
}
result_column = std::move(res_data_column);
@@ -105,6 +106,18 @@ Status VBitmapPredicate::execute_column(VExprContext*
context, const Block* bloc
return Status::OK();
}
+Status VBitmapPredicate::execute_column(VExprContext* context, const Block*
block, size_t count,
+ ColumnPtr& result_column) const {
+ return _do_execute(context, block, nullptr, count, result_column);
+}
+
+Status VBitmapPredicate::execute_runtime_filter(VExprContext* context, const
Block* block,
+ const uint8_t* __restrict
filter, size_t count,
+ ColumnPtr& result_column,
+ ColumnPtr* arg_column) const {
+ return _do_execute(context, block, filter, count, result_column);
+}
+
void vectorized::VBitmapPredicate::close(vectorized::VExprContext* context,
FunctionContext::FunctionStateScope
scope) {
VExpr::close(context, scope);
diff --git a/be/src/vec/exprs/vbitmap_predicate.h
b/be/src/vec/exprs/vbitmap_predicate.h
index 646bfaf497c..24a0a6a75cf 100644
--- a/be/src/vec/exprs/vbitmap_predicate.h
+++ b/be/src/vec/exprs/vbitmap_predicate.h
@@ -51,7 +51,9 @@ public:
Status execute_column(VExprContext* context, const Block* block, size_t
count,
ColumnPtr& result_column) const override;
-
+ Status execute_runtime_filter(VExprContext* context, const Block* block,
+ const uint8_t* __restrict filter, size_t
count,
+ ColumnPtr& result_column, ColumnPtr*
arg_column) const override;
Status prepare(RuntimeState* state, const RowDescriptor& desc,
VExprContext* context) override;
Status open(RuntimeState* state, VExprContext* context,
@@ -75,6 +77,8 @@ public:
uint64_t get_digest(uint64_t seed) const override { return 0; }
private:
+ Status _do_execute(VExprContext* context, const Block* block, const
uint8_t* __restrict filter,
+ size_t count, ColumnPtr& result_column) const;
std::shared_ptr<BitmapFilterFuncBase> _filter;
inline static const std::string EXPR_NAME = "bitmap_predicate";
};
diff --git a/be/src/vec/exprs/vbloom_predicate.cpp
b/be/src/vec/exprs/vbloom_predicate.cpp
index 3a2e6c5ca81..841a2e16c95 100644
--- a/be/src/vec/exprs/vbloom_predicate.cpp
+++ b/be/src/vec/exprs/vbloom_predicate.cpp
@@ -70,8 +70,9 @@ void VBloomPredicate::close(VExprContext* context,
FunctionContext::FunctionStat
VExpr::close(context, scope);
}
-Status VBloomPredicate::execute_column(VExprContext* context, const Block*
block, size_t count,
- ColumnPtr& result_column) const {
+Status VBloomPredicate::_do_execute(VExprContext* context, const Block* block,
+ const uint8_t* __restrict filter, size_t
count,
+ ColumnPtr& result_column) const {
DCHECK(_open_finished || block == nullptr);
DCHECK_EQ(_children.size(), 1);
@@ -85,13 +86,24 @@ Status VBloomPredicate::execute_column(VExprContext*
context, const Block* block
res_data_column->resize(sz);
auto* ptr = ((ColumnUInt8*)res_data_column.get())->get_data().data();
- _filter->find_fixed_len(argument_column, ptr);
+ _filter->find_fixed_len(argument_column, ptr, filter);
result_column = std::move(res_data_column);
DCHECK_EQ(result_column->size(), count);
return Status::OK();
}
+Status VBloomPredicate::execute_column(VExprContext* context, const Block*
block, size_t count,
+ ColumnPtr& result_column) const {
+ return _do_execute(context, block, nullptr, count, result_column);
+}
+
+Status VBloomPredicate::execute_runtime_filter(VExprContext* context, const
Block* block,
+ const uint8_t* __restrict
filter, size_t count,
+ ColumnPtr& result_column,
+ ColumnPtr* arg_column) const {
+ return _do_execute(context, block, filter, count, result_column);
+}
const std::string& VBloomPredicate::expr_name() const {
return EXPR_NAME;
}
diff --git a/be/src/vec/exprs/vbloom_predicate.h
b/be/src/vec/exprs/vbloom_predicate.h
index 2d21a60d2ac..bfd5e2ef8b2 100644
--- a/be/src/vec/exprs/vbloom_predicate.h
+++ b/be/src/vec/exprs/vbloom_predicate.h
@@ -45,6 +45,11 @@ public:
~VBloomPredicate() override = default;
Status execute_column(VExprContext* context, const Block* block, size_t
count,
ColumnPtr& result_column) const override;
+
+ Status execute_runtime_filter(VExprContext* context, const Block* block,
+ const uint8_t* __restrict filter, size_t
count,
+ ColumnPtr& result_column, ColumnPtr*
arg_column) const override;
+
Status prepare(RuntimeState* state, const RowDescriptor& desc,
VExprContext* context) override;
Status open(RuntimeState* state, VExprContext* context,
FunctionContext::FunctionStateScope scope) override;
@@ -57,6 +62,9 @@ public:
uint64_t get_digest(uint64_t seed) const override;
private:
+ Status _do_execute(VExprContext* context, const Block* block, const
uint8_t* __restrict filter,
+ size_t count, ColumnPtr& result_column) const;
+
std::shared_ptr<BloomFilterFuncBase> _filter;
inline static const std::string EXPR_NAME = "bloom_predicate";
};
diff --git a/be/src/vec/exprs/vdirect_in_predicate.h
b/be/src/vec/exprs/vdirect_in_predicate.h
index 79a0d1e4de0..83ce0c00064 100644
--- a/be/src/vec/exprs/vdirect_in_predicate.h
+++ b/be/src/vec/exprs/vdirect_in_predicate.h
@@ -56,12 +56,13 @@ public:
Status execute_column(VExprContext* context, const Block* block, size_t
count,
ColumnPtr& result_column) const override {
- return _do_execute(context, block, count, result_column, nullptr);
+ return _do_execute(context, block, nullptr, count, result_column,
nullptr);
}
- Status execute_runtime_filter(VExprContext* context, const Block* block,
size_t count,
+ Status execute_runtime_filter(VExprContext* context, const Block* block,
+ const uint8_t* __restrict filter, size_t
count,
ColumnPtr& result_column, ColumnPtr*
arg_column) const override {
- return _do_execute(context, block, count, result_column, arg_column);
+ return _do_execute(context, block, filter, count, result_column,
arg_column);
}
const std::string& expr_name() const override { return _expr_name; }
@@ -115,8 +116,8 @@ public:
}
private:
- Status _do_execute(VExprContext* context, const Block* block, size_t count,
- ColumnPtr& result_column, ColumnPtr* arg_column) const {
+ Status _do_execute(VExprContext* context, const Block* block, const
uint8_t* __restrict filter,
+ size_t count, ColumnPtr& result_column, ColumnPtr*
arg_column) const {
DCHECK(_open_finished || block == nullptr);
ColumnPtr argument_column;
@@ -136,9 +137,10 @@ private:
->get_nested_column_ptr();
const auto& null_map =
static_cast<const
ColumnNullable*>(argument_column.get())->get_null_map_data();
- _filter->find_batch_nullable(*column_nested, sz, null_map,
res_data_column->get_data());
+ _filter->find_batch_nullable(*column_nested, sz, null_map,
res_data_column->get_data(),
+ filter);
} else {
- _filter->find_batch(*argument_column, sz,
res_data_column->get_data());
+ _filter->find_batch(*argument_column, sz,
res_data_column->get_data(), filter);
}
DCHECK(!_data_type->is_nullable());
diff --git a/be/src/vec/exprs/vectorized_fn_call.cpp
b/be/src/vec/exprs/vectorized_fn_call.cpp
index 33e875044c1..0d4bc252394 100644
--- a/be/src/vec/exprs/vectorized_fn_call.cpp
+++ b/be/src/vec/exprs/vectorized_fn_call.cpp
@@ -267,7 +267,8 @@ size_t VectorizedFnCall::estimate_memory(const size_t rows)
{
}
Status VectorizedFnCall::execute_runtime_filter(VExprContext* context, const
Block* block,
- size_t count, ColumnPtr&
result_column,
+ const uint8_t* __restrict
filter, size_t count,
+ ColumnPtr& result_column,
ColumnPtr* arg_column) const {
return _do_execute(context, block, count, result_column, arg_column);
}
diff --git a/be/src/vec/exprs/vectorized_fn_call.h
b/be/src/vec/exprs/vectorized_fn_call.h
index b48b2612a73..2963e35931f 100644
--- a/be/src/vec/exprs/vectorized_fn_call.h
+++ b/be/src/vec/exprs/vectorized_fn_call.h
@@ -54,7 +54,8 @@ public:
VectorizedFnCall(const TExprNode& node);
Status execute_column(VExprContext* context, const Block* block, size_t
count,
ColumnPtr& result_column) const override;
- Status execute_runtime_filter(VExprContext* context, const Block* block,
size_t count,
+ Status execute_runtime_filter(VExprContext* context, const Block* block,
+ const uint8_t* __restrict filter, size_t
count,
ColumnPtr& result_column, ColumnPtr*
arg_column) const override;
Status evaluate_inverted_index(VExprContext* context, uint32_t
segment_num_rows) override;
Status prepare(RuntimeState* state, const RowDescriptor& desc,
VExprContext* context) override;
diff --git a/be/src/vec/exprs/vexpr.h b/be/src/vec/exprs/vexpr.h
index 7a0423642b0..31812816e9b 100644
--- a/be/src/vec/exprs/vexpr.h
+++ b/be/src/vec/exprs/vexpr.h
@@ -175,7 +175,8 @@ public:
// Only the 4th parameter is used in the runtime filter. In and MinMax
need overwrite the
// interface
- virtual Status execute_runtime_filter(VExprContext* context, const Block*
block, size_t count,
+ virtual Status execute_runtime_filter(VExprContext* context, const Block*
block,
+ const uint8_t* __restrict filter,
size_t count,
ColumnPtr& result_column, ColumnPtr*
arg_column) const {
return execute_column(context, block, count, result_column);
};
diff --git a/be/src/vec/exprs/vruntimefilter_wrapper.cpp
b/be/src/vec/exprs/vruntimefilter_wrapper.cpp
index 6096ce52d73..e2145704228 100644
--- a/be/src/vec/exprs/vruntimefilter_wrapper.cpp
+++ b/be/src/vec/exprs/vruntimefilter_wrapper.cpp
@@ -114,8 +114,8 @@ Status VRuntimeFilterWrapper::execute_filter(VExprContext*
context, const Block*
ColumnPtr filter_column;
ColumnPtr arg_column = nullptr;
- RETURN_IF_ERROR(
- _impl->execute_runtime_filter(context, block, rows, filter_column,
&arg_column));
+ RETURN_IF_ERROR(_impl->execute_runtime_filter(context, block,
result_filter_data, rows,
+ filter_column, &arg_column));
// bloom filter will handle null aware inside itself
if (_null_aware && TExprNodeType::BLOOM_PRED != node_type()) {
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
