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 <[email protected]> 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: [email protected] For additional commands, e-mail: [email protected]
