This is an automated email from the ASF dual-hosted git repository.
morningman pushed a commit to branch dev-1.0.1
in repository https://gitbox.apache.org/repos/asf/incubator-doris.git
commit a7c6ca63c45e553973f91a5e9b69c00e6f5af5a1
Author: morningman <mo...@163.com>
AuthorDate: Wed Jun 1 22:10:58 2022 +0800
[bugfix]handle ComlumnDictionary in evaluate_and and evaluate_or (#9818)
* handle ColumnDictory in evaluate_or
We need to handle ComlumnDictory in evaluate_or, otherwise delete handler
would triger a core dump.
* handle ComlumnDictionary in evaluate_and
Because there is only one difference between evaluate_and and
evaluate_or, that is or and delete, I merge two macros into one.
Delete handlers also trigger evaluate_and, i am not sure if column
dictionary would be used in evaluate_and.
* clang format
* fix short circut for evaluate_and and evaluate_or
* clang format
---
be/src/olap/comparison_predicate.cpp | 451 +++++++++++++++++------------------
1 file changed, 217 insertions(+), 234 deletions(-)
diff --git a/be/src/olap/comparison_predicate.cpp b/be/src/olap/comparison_predicate.cpp
index 363c75e5b8..2223d1fe19 100644
--- a/be/src/olap/comparison_predicate.cpp
+++ b/be/src/olap/comparison_predicate.cpp
@@ -28,8 +28,8 @@
namespace doris {
-#define COMPARISON_PRED_CONSTRUCTOR(CLASS) \
- template <class T> \
+#define COMPARISON_PRED_CONSTRUCTOR(CLASS) \
+ template <class T> \
CLASS<T>::CLASS(uint32_t column_id, const T& value, bool opposite) \
: ColumnPredicate(column_id, opposite), _value(value) {}
@@ -55,55 +55,54 @@ COMPARISON_PRED_CONSTRUCTOR_STRING(LessEqualPredicate)
COMPARISON_PRED_CONSTRUCTOR_STRING(GreaterPredicate)
COMPARISON_PRED_CONSTRUCTOR_STRING(GreaterEqualPredicate)
-#define COMPARISON_PRED_EVALUATE(CLASS, OP) \
- template <class T> \
- void CLASS<T>::evaluate(VectorizedRowBatch* batch) const { \
- uint16_t n = batch->size(); \
- if (n == 0) { \
- return; \
- } \
- uint16_t* sel = batch->selected(); \
- const T* col_vector = \
- reinterpret_cast<const T*>(batch->column(_column_id)->col_data()); \
- uint16_t new_size = 0; \
- if (batch->column(_column_id)->no_nulls()) { \
- if (batch->selected_in_use()) { \
- for (uint16_t j = 0; j != n; ++j) { \
- uint16_t i = sel[j]; \
- sel[new_size] = i; \
- new_size += (col_vector[i] OP _value); \
- } \
- batch->set_size(new_size); \
- } else { \
- for (uint16_t i = 0; i != n; ++i) { \
- sel[new_size] = i; \
- new_size += (col_vector[i] OP _value); \
- } \
- if (new_size < n) { \
- batch->set_size(new_size); \
- batch->set_selected_in_use(true); \
- } \
- } \
- } else { \
- bool* is_null = batch->column(_column_id)->is_null(); \
- if (batch->selected_in_use()) { \
- for (uint16_t j = 0; j != n; ++j) { \
- uint16_t i = sel[j]; \
- sel[new_size] = i; \
- new_size += (!is_null[i] && (col_vector[i] OP _value)); \
- } \
- batch->set_size(new_size); \
- } else { \
- for (uint16_t i = 0; i != n; ++i) { \
- sel[new_size] = i; \
- new_size += (!is_null[i] && (col_vector[i] OP _value)); \
- } \
- if (new_size < n) { \
- batch->set_size(new_size); \
- batch->set_selected_in_use(true); \
- } \
- } \
- } \
+#define COMPARISON_PRED_EVALUATE(CLASS, OP) \
+ template <class T> \
+ void CLASS<T>::evaluate(VectorizedRowBatch* batch) const { \
+ uint16_t n = batch->size(); \
+ if (n == 0) { \
+ return; \
+ } \
+ uint16_t* sel = batch->selected(); \
+ const T* col_vector = reinterpret_cast<const T*>(batch->column(_column_id)->col_data()); \
+ uint16_t new_size = 0; \
+ if (batch->column(_column_id)->no_nulls()) { \
+ if (batch->selected_in_use()) { \
+ for (uint16_t j = 0; j != n; ++j) { \
+ uint16_t i = sel[j]; \
+ sel[new_size] = i; \
+ new_size += (col_vector[i] OP _value); \
+ } \
+ batch->set_size(new_size); \
+ } else { \
+ for (uint16_t i = 0; i != n; ++i) { \
+ sel[new_size] = i; \
+ new_size += (col_vector[i] OP _value); \
+ } \
+ if (new_size < n) { \
+ batch->set_size(new_size); \
+ batch->set_selected_in_use(true); \
+ } \
+ } \
+ } else { \
+ bool* is_null = batch->column(_column_id)->is_null(); \
+ if (batch->selected_in_use()) { \
+ for (uint16_t j = 0; j != n; ++j) { \
+ uint16_t i = sel[j]; \
+ sel[new_size] = i; \
+ new_size += (!is_null[i] && (col_vector[i] OP _value)); \
+ } \
+ batch->set_size(new_size); \
+ } else { \
+ for (uint16_t i = 0; i != n; ++i) { \
+ sel[new_size] = i; \
+ new_size += (!is_null[i] && (col_vector[i] OP _value)); \
+ } \
+ if (new_size < n) { \
+ batch->set_size(new_size); \
+ batch->set_selected_in_use(true); \
+ } \
+ } \
+ } \
}
COMPARISON_PRED_EVALUATE(EqualPredicate, ==)
@@ -113,30 +112,28 @@ COMPARISON_PRED_EVALUATE(LessEqualPredicate, <=)
COMPARISON_PRED_EVALUATE(GreaterPredicate, >)
COMPARISON_PRED_EVALUATE(GreaterEqualPredicate, >=)
-#define COMPARISON_PRED_COLUMN_BLOCK_EVALUATE(CLASS, OP) \
- template <class T> \
- void CLASS<T>::evaluate(ColumnBlock* block, uint16_t* sel, uint16_t* size) const { \
- uint16_t new_size = 0; \
- if (block->is_nullable()) { \
- for (uint16_t i = 0; i < *size; ++i) { \
- uint16_t idx = sel[i]; \
- sel[new_size] = idx; \
- const T* cell_value = \
- reinterpret_cast<const T*>(block->cell(idx).cell_ptr()); \
- auto result = (!block->cell(idx).is_null() && (*cell_value OP _value)); \
- new_size += _opposite ? !result : result; \
- } \
- } else { \
- for (uint16_t i = 0; i < *size; ++i) { \
- uint16_t idx = sel[i]; \
- sel[new_size] = idx; \
- const T* cell_value = \
- reinterpret_cast<const T*>(block->cell(idx).cell_ptr()); \
- auto result = (*cell_value OP _value); \
- new_size += _opposite ? !result : result; \
- } \
- } \
- *size = new_size; \
+#define COMPARISON_PRED_COLUMN_BLOCK_EVALUATE(CLASS, OP) \
+ template <class T> \
+ void CLASS<T>::evaluate(ColumnBlock* block, uint16_t* sel, uint16_t* size) const { \
+ uint16_t new_size = 0; \
+ if (block->is_nullable()) { \
+ for (uint16_t i = 0; i < *size; ++i) { \
+ uint16_t idx = sel[i]; \
+ sel[new_size] = idx; \
+ const T* cell_value = reinterpret_cast<const T*>(block->cell(idx).cell_ptr()); \
+ auto result = (!block->cell(idx).is_null() && (*cell_value OP _value)); \
+ new_size += _opposite ? !result : result; \
+ } \
+ } else { \
+ for (uint16_t i = 0; i < *size; ++i) { \
+ uint16_t idx = sel[i]; \
+ sel[new_size] = idx; \
+ const T* cell_value = reinterpret_cast<const T*>(block->cell(idx).cell_ptr()); \
+ auto result = (*cell_value OP _value); \
+ new_size += _opposite ? !result : result; \
+ } \
+ } \
+ *size = new_size; \
}
COMPARISON_PRED_COLUMN_BLOCK_EVALUATE(EqualPredicate, ==)
@@ -193,7 +190,8 @@ COMPARISON_PRED_COLUMN_BLOCK_EVALUATE(GreaterEqualPredicate, >=)
} else if (column.is_column_dictionary()) { \
if constexpr (std::is_same_v<T, StringValue>) { \
auto& dict_col = \
- reinterpret_cast<vectorized::ColumnDictionary<vectorized::Int32>&>(column);\
+ reinterpret_cast<vectorized::ColumnDictionary<vectorized::Int32>&>( \
+ column); \
auto& data_array = dict_col.get_data(); \
auto dict_code = IS_RANGE ? dict_col.find_code_by_bound(_value, 1 OP 0, 1 OP 1) \
: dict_col.find_code(_value); \
@@ -201,13 +199,12 @@ COMPARISON_PRED_COLUMN_BLOCK_EVALUATE(GreaterEqualPredicate, >=)
uint16_t idx = sel[i]; \
sel[new_size] = idx; \
const auto& cell_value = data_array[idx]; \
- bool ret = cell_value OP dict_code; \
+ bool ret = cell_value OP dict_code; \
new_size += _opposite ? !ret : ret; \
} \
} \
} else { \
- auto& pred_column_ref = \
- reinterpret_cast<vectorized::PredicateColumnType<T>&>(column); \
+ auto& pred_column_ref = reinterpret_cast<vectorized::PredicateColumnType<T>&>(column); \
auto& data_array = pred_column_ref.get_data(); \
for (uint16_t i = 0; i < *size; i++) { \
uint16_t idx = sel[i]; \
@@ -220,7 +217,6 @@ COMPARISON_PRED_COLUMN_BLOCK_EVALUATE(GreaterEqualPredicate, >=)
*size = new_size; \
}
-
COMPARISON_PRED_COLUMN_EVALUATE(EqualPredicate, ==, false)
COMPARISON_PRED_COLUMN_EVALUATE(NotEqualPredicate, !=, false)
COMPARISON_PRED_COLUMN_EVALUATE(LessPredicate, <, true)
@@ -228,35 +224,34 @@ COMPARISON_PRED_COLUMN_EVALUATE(LessEqualPredicate, <=, true)
COMPARISON_PRED_COLUMN_EVALUATE(GreaterPredicate, >, true)
COMPARISON_PRED_COLUMN_EVALUATE(GreaterEqualPredicate, >=, true)
-#define COMPARISON_PRED_COLUMN_EVALUATE_VEC(CLASS, OP) \
- template <class T> \
- void CLASS<T>::evaluate_vec(vectorized::IColumn& column, uint16_t size, bool* flags) \
- const { \
- if (column.is_nullable()) { \
- auto* nullable_column = \
- vectorized::check_and_get_column<vectorized::ColumnNullable>(column); \
- auto& data_array = reinterpret_cast<const vectorized::PredicateColumnType<T>&>( \
- nullable_column->get_nested_column()) \
- .get_data(); \
- auto& null_bitmap = reinterpret_cast<const vectorized::ColumnVector<uint8_t>&>( \
- *(nullable_column->get_null_map_column_ptr())) \
- .get_data(); \
- for (uint16_t i = 0; i < size; i++) { \
- flags[i] = (data_array[i] OP _value) && (!null_bitmap[i]); \
- } \
- } else { \
- auto& predicate_column = \
- reinterpret_cast<vectorized::PredicateColumnType<T>&>(column); \
- auto& data_array = predicate_column.get_data(); \
- for (uint16_t i = 0; i < size; i++) { \
- flags[i] = data_array[i] OP _value; \
- } \
- } \
- if (_opposite) { \
- for (uint16_t i = 0; i < size; i++) { \
- flags[i] = !flags[i]; \
- } \
- } \
+#define COMPARISON_PRED_COLUMN_EVALUATE_VEC(CLASS, OP) \
+ template <class T> \
+ void CLASS<T>::evaluate_vec(vectorized::IColumn& column, uint16_t size, bool* flags) const { \
+ if (column.is_nullable()) { \
+ auto* nullable_column = \
+ vectorized::check_and_get_column<vectorized::ColumnNullable>(column); \
+ auto& data_array = reinterpret_cast<const vectorized::PredicateColumnType<T>&>( \
+ nullable_column->get_nested_column()) \
+ .get_data(); \
+ auto& null_bitmap = reinterpret_cast<const vectorized::ColumnVector<uint8_t>&>( \
+ *(nullable_column->get_null_map_column_ptr())) \
+ .get_data(); \
+ for (uint16_t i = 0; i < size; i++) { \
+ flags[i] = (data_array[i] OP _value) && (!null_bitmap[i]); \
+ } \
+ } else { \
+ auto& predicate_column = \
+ reinterpret_cast<vectorized::PredicateColumnType<T>&>(column); \
+ auto& data_array = predicate_column.get_data(); \
+ for (uint16_t i = 0; i < size; i++) { \
+ flags[i] = data_array[i] OP _value; \
+ } \
+ } \
+ if (_opposite) { \
+ for (uint16_t i = 0; i < size; i++) { \
+ flags[i] = !flags[i]; \
+ } \
+ } \
}
COMPARISON_PRED_COLUMN_EVALUATE_VEC(EqualPredicate, ==)
@@ -266,133 +261,121 @@ COMPARISON_PRED_COLUMN_EVALUATE_VEC(LessEqualPredicate, <=)
COMPARISON_PRED_COLUMN_EVALUATE_VEC(GreaterPredicate, >)
COMPARISON_PRED_COLUMN_EVALUATE_VEC(GreaterEqualPredicate, >=)
-#define COMPARISON_PRED_COLUMN_BLOCK_EVALUATE_OR(CLASS, OP) \
- template <class T> \
- void CLASS<T>::evaluate_or(ColumnBlock* block, uint16_t* sel, uint16_t size, bool* flags) \
- const { \
- if (block->is_nullable()) { \
- for (uint16_t i = 0; i < size; ++i) { \
- if (flags[i]) continue; \
- uint16_t idx = sel[i]; \
- const T* cell_value = \
- reinterpret_cast<const T*>(block->cell(idx).cell_ptr()); \
- auto result = (!block->cell(idx).is_null() && (*cell_value OP _value)); \
- flags[i] |= _opposite ? !result : result; \
- } \
- } else { \
- for (uint16_t i = 0; i < size; ++i) { \
- if (flags[i]) continue; \
- uint16_t idx = sel[i]; \
- const T* cell_value = \
- reinterpret_cast<const T*>(block->cell(idx).cell_ptr()); \
- auto result = (*cell_value OP _value); \
- flags[i] |= _opposite ? !result : result; \
- } \
- } \
+#define COMPARISON_PRED_COLUMN_BLOCK_EVALUATE_BOOL(CLASS, OP, BOOL_NAME, BOOL_OP, SHORT_OP) \
+ template <class T> \
+ void CLASS<T>::evaluate_##BOOL_NAME(ColumnBlock* block, uint16_t* sel, uint16_t size, \
+ bool* flags) const { \
+ if (block->is_nullable()) { \
+ for (uint16_t i = 0; i < size; ++i) { \
+ if (SHORT_OP(flags[i])) continue; \
+ uint16_t idx = sel[i]; \
+ const T* cell_value = reinterpret_cast<const T*>(block->cell(idx).cell_ptr()); \
+ auto result = (!block->cell(idx).is_null() && (*cell_value OP _value)); \
+ flags[i] = flags[i] BOOL_OP(_opposite ? !result : result); \
+ } \
+ } else { \
+ for (uint16_t i = 0; i < size; ++i) { \
+ if (flags[i]) continue; \
+ uint16_t idx = sel[i]; \
+ const T* cell_value = reinterpret_cast<const T*>(block->cell(idx).cell_ptr()); \
+ auto result = (*cell_value OP _value); \
+ flags[i] = flags[i] BOOL_OP(_opposite ? !result : result); \
+ } \
+ } \
}
-COMPARISON_PRED_COLUMN_BLOCK_EVALUATE_OR(EqualPredicate, ==)
-COMPARISON_PRED_COLUMN_BLOCK_EVALUATE_OR(NotEqualPredicate, !=)
-COMPARISON_PRED_COLUMN_BLOCK_EVALUATE_OR(LessPredicate, <)
-COMPARISON_PRED_COLUMN_BLOCK_EVALUATE_OR(LessEqualPredicate, <=)
-COMPARISON_PRED_COLUMN_BLOCK_EVALUATE_OR(GreaterPredicate, >)
-COMPARISON_PRED_COLUMN_BLOCK_EVALUATE_OR(GreaterEqualPredicate, >=)
-
-#define COMPARISON_PRED_COLUMN_EVALUATE_OR(CLASS, OP) \
- template <class T> \
- void CLASS<T>::evaluate_or(vectorized::IColumn& column, uint16_t* sel, uint16_t size, bool* flags) const { \
- if (column.is_nullable()) { \
- auto* nullable_column = vectorized::check_and_get_column<vectorized::ColumnNullable>(column); \
- auto& data_array = reinterpret_cast<const vectorized::PredicateColumnType<T>&>(nullable_column->get_nested_column()).get_data(); \
- auto& null_bitmap = reinterpret_cast<const vectorized::ColumnVector<uint8_t>&>(*(nullable_column->get_null_map_column_ptr())).get_data();\
- for (uint16_t i = 0; i < size; i++) { \
- if (flags[i]) continue; \
- uint16_t idx = sel[i]; \
- bool ret = !null_bitmap[idx] && (data_array[idx] OP _value); \
- flags[i] |= _opposite ? !ret : ret; \
- } \
- } else { \
- auto& predicate_column = reinterpret_cast<vectorized::PredicateColumnType<T>&>(column); \
- auto& data_array = predicate_column.get_data(); \
- for (uint16_t i = 0; i < size; ++i) { \
- if (flags[i]) continue; \
- uint16_t idx = sel[i]; \
- bool ret = data_array[idx] OP _value; \
- flags[i] |= _opposite ? !ret : ret; \
- } \
- } \
- }
-
-COMPARISON_PRED_COLUMN_EVALUATE_OR(EqualPredicate, ==)
-COMPARISON_PRED_COLUMN_EVALUATE_OR(NotEqualPredicate, !=)
-COMPARISON_PRED_COLUMN_EVALUATE_OR(LessPredicate, <)
-COMPARISON_PRED_COLUMN_EVALUATE_OR(LessEqualPredicate, <=)
-COMPARISON_PRED_COLUMN_EVALUATE_OR(GreaterPredicate, >)
-COMPARISON_PRED_COLUMN_EVALUATE_OR(GreaterEqualPredicate, >=)
-
-#define COMPARISON_PRED_COLUMN_BLOCK_EVALUATE_AND(CLASS, OP) \
- template <class T> \
- void CLASS<T>::evaluate_and(ColumnBlock* block, uint16_t* sel, uint16_t size, bool* flags) \
- const { \
- if (block->is_nullable()) { \
- for (uint16_t i = 0; i < size; ++i) { \
- if (!flags[i]) continue; \
- uint16_t idx = sel[i]; \
- const T* cell_value = \
- reinterpret_cast<const T*>(block->cell(idx).cell_ptr()); \
- auto result = (!block->cell(idx).is_null() && (*cell_value OP _value)); \
- flags[i] &= _opposite ? !result : result; \
- } \
- } else { \
- for (uint16_t i = 0; i < size; ++i) { \
- if (!flags[i]) continue; \
- uint16_t idx = sel[i]; \
- const T* cell_value = \
- reinterpret_cast<const T*>(block->cell(idx).cell_ptr()); \
- auto result = (*cell_value OP _value); \
- flags[i] &= _opposite ? !result : result; \
- } \
- } \
+#define COMPARISON_PRED_COLUMN_BLOCK_EVALUATE_BOOL2(BOOL_NAME, BOOL_OP, SHORT_OP) \
+ COMPARISON_PRED_COLUMN_BLOCK_EVALUATE_BOOL(EqualPredicate, ==, BOOL_NAME, BOOL_OP, SHORT_OP) \
+ COMPARISON_PRED_COLUMN_BLOCK_EVALUATE_BOOL(NotEqualPredicate, !=, BOOL_NAME, BOOL_OP, \
+ SHORT_OP) \
+ COMPARISON_PRED_COLUMN_BLOCK_EVALUATE_BOOL(LessPredicate, <, BOOL_NAME, BOOL_OP, SHORT_OP) \
+ COMPARISON_PRED_COLUMN_BLOCK_EVALUATE_BOOL(LessEqualPredicate, <=, BOOL_NAME, BOOL_OP, \
+ SHORT_OP) \
+ COMPARISON_PRED_COLUMN_BLOCK_EVALUATE_BOOL(GreaterPredicate, >, BOOL_NAME, BOOL_OP, SHORT_OP) \
+ COMPARISON_PRED_COLUMN_BLOCK_EVALUATE_BOOL(GreaterEqualPredicate, >=, BOOL_NAME, BOOL_OP, \
+ SHORT_OP)
+
+COMPARISON_PRED_COLUMN_BLOCK_EVALUATE_BOOL2(or, |, )
+COMPARISON_PRED_COLUMN_BLOCK_EVALUATE_BOOL2(and, &, !)
+
+#define COMPARISON_PRED_COLUMN_EVALUATE_BOOL(CLASS, OP, IS_RANGE, BOOL_NAME, BOOL_OP, SHORT_OP) \
+ template <class T> \
+ void CLASS<T>::evaluate_##BOOL_NAME(vectorized::IColumn& column, uint16_t* sel, uint16_t size, \
+ bool* flags) const { \
+ if (column.is_nullable()) { \
+ auto* nullable_column = \
+ vectorized::check_and_get_column<vectorized::ColumnNullable>(column); \
+ auto& nested_col = nullable_column->get_nested_column(); \
+ auto& null_bitmap = reinterpret_cast<const vectorized::ColumnVector<uint8_t>&>( \
+ *(nullable_column->get_null_map_column_ptr())) \
+ .get_data(); \
+ if (nested_col.is_column_dictionary()) { \
+ if constexpr (std::is_same_v<T, StringValue>) { \
+ auto* nested_col_ptr = vectorized::check_and_get_column< \
+ vectorized::ColumnDictionary<vectorized::Int32>>(nested_col); \
+ auto& data_array = nested_col_ptr->get_data(); \
+ auto dict_code = \
+ IS_RANGE ? nested_col_ptr->find_code_by_bound(_value, 1 OP 0, 1 OP 1) \
+ : nested_col_ptr->find_code(_value); \
+ for (uint16_t i = 0; i < size; i++) { \
+ if (SHORT_OP(flags[i])) continue; \
+ uint16_t idx = sel[i]; \
+ bool ret = !null_bitmap[idx] && (data_array[idx] OP dict_code); \
+ flags[i] = flags[i] BOOL_OP(_opposite ? !ret : ret); \
+ } \
+ } \
+ } else { \
+ auto& data_array = \
+ reinterpret_cast<const vectorized::PredicateColumnType<T>&>(nested_col) \
+ .get_data(); \
+ for (uint16_t i = 0; i < size; i++) { \
+ if (SHORT_OP(flags[i])) continue; \
+ uint16_t idx = sel[i]; \
+ bool ret = !null_bitmap[idx] && (data_array[idx] OP _value); \
+ flags[i] = flags[i] BOOL_OP(_opposite ? !ret : ret); \
+ } \
+ } \
+ } else if (column.is_column_dictionary()) { \
+ if constexpr (std::is_same_v<T, StringValue>) { \
+ auto& dict_col = \
+ reinterpret_cast<vectorized::ColumnDictionary<vectorized::Int32>&>( \
+ column); \
+ auto& data_array = dict_col.get_data(); \
+ auto dict_code = IS_RANGE ? dict_col.find_code_by_bound(_value, 1 OP 0, 1 OP 1) \
+ : dict_col.find_code(_value); \
+ for (uint16_t i = 0; i < size; i++) { \
+ if (SHORT_OP(flags[i])) continue; \
+ uint16_t idx = sel[i]; \
+ bool ret = data_array[idx] OP dict_code; \
+ flags[i] = flags[i] BOOL_OP(_opposite ? !ret : ret); \
+ } \
+ } \
+ } else { \
+ auto& predicate_column = \
+ reinterpret_cast<vectorized::PredicateColumnType<T>&>(column); \
+ auto& data_array = predicate_column.get_data(); \
+ for (uint16_t i = 0; i < size; ++i) { \
+ if (SHORT_OP(flags[i])) continue; \
+ uint16_t idx = sel[i]; \
+ bool ret = data_array[idx] OP _value; \
+ flags[i] = flags[i] BOOL_OP(_opposite ? !ret : ret); \
+ } \
+ } \
}
-COMPARISON_PRED_COLUMN_BLOCK_EVALUATE_AND(EqualPredicate, ==)
-COMPARISON_PRED_COLUMN_BLOCK_EVALUATE_AND(NotEqualPredicate, !=)
-COMPARISON_PRED_COLUMN_BLOCK_EVALUATE_AND(LessPredicate, <)
-COMPARISON_PRED_COLUMN_BLOCK_EVALUATE_AND(LessEqualPredicate, <=)
-COMPARISON_PRED_COLUMN_BLOCK_EVALUATE_AND(GreaterPredicate, >)
-COMPARISON_PRED_COLUMN_BLOCK_EVALUATE_AND(GreaterEqualPredicate, >=)
-
-#define COMPARISON_PRED_COLUMN_EVALUATE_AND(CLASS, OP) \
- template <class T> \
- void CLASS<T>::evaluate_and(vectorized::IColumn& column, uint16_t* sel, uint16_t size, bool* flags) const { \
- if (column.is_nullable()) { \
- auto* nullable_column = vectorized::check_and_get_column<vectorized::ColumnNullable>(column); \
- auto& data_array = reinterpret_cast<const vectorized::PredicateColumnType<T>&>(nullable_column->get_nested_column()).get_data(); \
- auto& null_bitmap = reinterpret_cast<const vectorized::ColumnVector<uint8_t>&>(*(nullable_column->get_null_map_column_ptr())).get_data();\
- for (uint16_t i = 0; i < size; i++) { \
- if (!flags[i]) continue; \
- uint16_t idx = sel[i]; \
- bool ret = !null_bitmap[idx] && (data_array[idx] OP _value); \
- flags[i] &= _opposite ? !ret : ret; \
- } \
- } else { \
- auto& predicate_column = reinterpret_cast<vectorized::PredicateColumnType<T>&>(column); \
- auto& data_array = predicate_column.get_data(); \
- for (uint16_t i = 0; i < size; ++i) { \
- if (!flags[i]) continue; \
- uint16_t idx = sel[i]; \
- bool ret = data_array[idx] OP _value; \
- flags[i] &= _opposite ? !ret : ret; \
- } \
- } \
- }
-
-COMPARISON_PRED_COLUMN_EVALUATE_AND(EqualPredicate, ==)
-COMPARISON_PRED_COLUMN_EVALUATE_AND(NotEqualPredicate, !=)
-COMPARISON_PRED_COLUMN_EVALUATE_AND(LessPredicate, <)
-COMPARISON_PRED_COLUMN_EVALUATE_AND(LessEqualPredicate, <=)
-COMPARISON_PRED_COLUMN_EVALUATE_AND(GreaterPredicate, >)
-COMPARISON_PRED_COLUMN_EVALUATE_AND(GreaterEqualPredicate, >=)
+#define COMPARISON_PRED_COLUMN_EVALUATE_BOOL2(BOOL_NAME, BOOL_OP, SHORT_OP) \
+ COMPARISON_PRED_COLUMN_EVALUATE_BOOL(EqualPredicate, ==, false, BOOL_NAME, BOOL_OP, SHORT_OP) \
+ COMPARISON_PRED_COLUMN_EVALUATE_BOOL(NotEqualPredicate, !=, false, BOOL_NAME, BOOL_OP, \
+ SHORT_OP) \
+ COMPARISON_PRED_COLUMN_EVALUATE_BOOL(LessPredicate, <, true, BOOL_NAME, BOOL_OP, SHORT_OP) \
+ COMPARISON_PRED_COLUMN_EVALUATE_BOOL(LessEqualPredicate, <=, true, BOOL_NAME, BOOL_OP, \
+ SHORT_OP) \
+ COMPARISON_PRED_COLUMN_EVALUATE_BOOL(GreaterPredicate, >, true, BOOL_NAME, BOOL_OP, SHORT_OP) \
+ COMPARISON_PRED_COLUMN_EVALUATE_BOOL(GreaterEqualPredicate, >=, true, BOOL_NAME, BOOL_OP, \
+ SHORT_OP)
+
+COMPARISON_PRED_COLUMN_EVALUATE_BOOL2(or, |, )
+COMPARISON_PRED_COLUMN_EVALUATE_BOOL2(and, &, !)
#define BITMAP_COMPARE_EqualPredicate(s, exact_match, seeked_ordinal, iterator, bitmap, roaring) \
do { \
@@ -479,8 +462,8 @@ COMPARISON_PRED_COLUMN_EVALUATE_AND(GreaterEqualPredicate, >=)
#define COMPARISON_PRED_BITMAP_EVALUATE(CLASS, OP) \
template <class T> \
Status CLASS<T>::evaluate(const Schema& schema, \
- const std::vector<BitmapIndexIterator*>& iterators, \
- uint32_t num_rows, roaring::Roaring* bitmap) const { \
+ const std::vector<BitmapIndexIterator*>& iterators, \
+ uint32_t num_rows, roaring::Roaring* bitmap) const { \
BitmapIndexIterator* iterator = iterators[_column_id]; \
if (iterator == nullptr) { \
return Status::OK(); \
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@doris.apache.org
For additional commands, e-mail: commits-help@doris.apache.org