This is an automated email from the ASF dual-hosted git repository.
gabriellee 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 551c2a26a2a [refactor](field) Use Field to replace StringRef (#60253)
551c2a26a2a is described below
commit 551c2a26a2a2f06f8e3fa98135ccae490e63a762
Author: Gabriel <[email protected]>
AuthorDate: Tue Feb 3 14:16:47 2026 +0800
[refactor](field) Use Field to replace StringRef (#60253)
---
be/src/exec/olap_common.h | 24 +-
be/src/olap/comparison_predicate.h | 151 ++++++----
be/src/olap/delete_handler.cpp | 55 ++--
be/src/olap/in_list_predicate.h | 77 +++--
be/src/olap/predicate_creator.h | 139 ++++-----
be/src/pipeline/exec/file_scan_operator.cpp | 5 +-
be/src/pipeline/exec/file_scan_operator.h | 2 +-
be/src/pipeline/exec/mock_scan_operator.h | 5 +-
be/src/pipeline/exec/olap_scan_operator.cpp | 5 +-
be/src/pipeline/exec/olap_scan_operator.h | 2 +-
be/src/pipeline/exec/scan_operator.cpp | 94 +++----
be/src/pipeline/exec/scan_operator.h | 6 +-
be/src/runtime/runtime_predicate.cpp | 113 +-------
be/src/runtime/runtime_predicate.h | 8 +-
be/src/runtime/type_limit.h | 6 +
be/test/olap/block_column_predicate_test.cpp | 310 +++++++++++++--------
be/test/olap/date_bloom_filter_test.cpp | 6 +-
.../vec/exec/format/parquet/parquet_expr_test.cpp | 40 ++-
18 files changed, 531 insertions(+), 517 deletions(-)
diff --git a/be/src/exec/olap_common.h b/be/src/exec/olap_common.h
index 91e6e5f8231..da1ed516eaa 100644
--- a/be/src/exec/olap_common.h
+++ b/be/src/exec/olap_common.h
@@ -99,9 +99,8 @@ std::string cast_to_string(T value, int scale) {
template <PrimitiveType primitive_type>
class ColumnValueRange {
public:
- using CppType =
- std::conditional_t<primitive_type == TYPE_HLL ||
is_string_type(primitive_type),
- StringRef, typename
PrimitiveTypeTraits<primitive_type>::CppType>;
+ using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
+ typename
PrimitiveTypeTraits<primitive_type>::CppType>;
using SetType = std::set<CppType, doris::Less<CppType>>;
using IteratorType = typename SetType::iterator;
@@ -216,21 +215,21 @@ public:
int scale() const { return _scale; }
static void add_fixed_value_range(ColumnValueRange<primitive_type>& range,
SQLFilterOp op,
- const CppType* value) {
- static_cast<void>(range.add_fixed_value(*value));
+ const CppType& value) {
+ static_cast<void>(range.add_fixed_value(value));
}
static void remove_fixed_value_range(ColumnValueRange<primitive_type>&
range, SQLFilterOp op,
- const CppType* value) {
- range.remove_fixed_value(*value);
+ const CppType& value) {
+ range.remove_fixed_value(value);
}
static void empty_function(ColumnValueRange<primitive_type>& range,
SQLFilterOp op,
- const CppType* value) {}
+ const CppType& value) {}
static void add_value_range(ColumnValueRange<primitive_type>& range,
SQLFilterOp op,
- const CppType* value) {
- static_cast<void>(range.add_range(op, *value));
+ const CppType& value) {
+ static_cast<void>(range.add_range(op, value));
}
static ColumnValueRange<primitive_type>
create_empty_column_value_range(bool is_nullable_col,
@@ -821,9 +820,8 @@ template <PrimitiveType primitive_type>
Status OlapScanKeys::extend_scan_key(ColumnValueRange<primitive_type>& range,
int32_t max_scan_key_num, bool*
exact_value, bool* eos,
bool* should_break) {
- using CppType =
- std::conditional_t<primitive_type == TYPE_HLL ||
is_string_type(primitive_type),
- StringRef, typename
PrimitiveTypeTraits<primitive_type>::CppType>;
+ using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
+ typename
PrimitiveTypeTraits<primitive_type>::CppType>;
using ConstIterator = typename
ColumnValueRange<primitive_type>::SetType::const_iterator;
// 1. clear ScanKey if some column range is empty
diff --git a/be/src/olap/comparison_predicate.h
b/be/src/olap/comparison_predicate.h
index feae988edd8..cf3a4dce6ba 100644
--- a/be/src/olap/comparison_predicate.h
+++ b/be/src/olap/comparison_predicate.h
@@ -34,11 +34,11 @@ template <PrimitiveType Type, PredicateType PT>
class ComparisonPredicateBase final : public ColumnPredicate {
public:
ENABLE_FACTORY_CREATOR(ComparisonPredicateBase);
- using T = std::conditional_t<is_string_type(Type), StringRef,
- typename PrimitiveTypeTraits<Type>::CppType>;
- ComparisonPredicateBase(uint32_t column_id, std::string col_name, const T&
value,
- bool opposite = false)
- : ColumnPredicate(column_id, col_name, Type, opposite),
_value(value) {}
+ using T = typename PrimitiveTypeTraits<Type>::CppType;
+ ComparisonPredicateBase(uint32_t column_id, std::string col_name,
+ const vectorized::Field& value, bool opposite =
false)
+ : ColumnPredicate(column_id, col_name, Type, opposite),
+ _value(value.template get<Type>()) {}
ComparisonPredicateBase(const ComparisonPredicateBase<Type, PT>& other,
uint32_t col_id)
: ColumnPredicate(other, col_id), _value(other._value) {}
ComparisonPredicateBase(const ComparisonPredicateBase<Type, PT>& other) =
delete;
@@ -139,22 +139,29 @@ public:
return false;
}
- T tmp_min_value = get_zone_map_value<Type,
T>(statistic.first->cell_ptr());
- T tmp_max_value = get_zone_map_value<Type,
T>(statistic.second->cell_ptr());
+ using CompareType = typename std::conditional<is_string_type(Type),
StringRef, T>::type;
+ auto tmp_min_value = get_zone_map_value<Type,
CompareType>(statistic.first->cell_ptr());
+ auto tmp_max_value = get_zone_map_value<Type,
CompareType>(statistic.second->cell_ptr());
+ CompareType tmp_value;
+ if constexpr (is_string_type(Type)) {
+ tmp_value = StringRef(_value.data(), _value.size());
+ } else {
+ tmp_value = _value;
+ }
if constexpr (PT == PredicateType::EQ) {
- return _operator(Compare::less_equal(tmp_min_value, _value) &&
- Compare::greater_equal(tmp_max_value,
_value),
+ return _operator(Compare::less_equal(tmp_min_value, tmp_value) &&
+ Compare::greater_equal(tmp_max_value,
tmp_value),
true);
} else if constexpr (PT == PredicateType::NE) {
- return _operator(
- Compare::equal(tmp_min_value, _value) &&
Compare::equal(tmp_max_value, _value),
- true);
+ return _operator(Compare::equal(tmp_min_value, tmp_value) &&
+ Compare::equal(tmp_max_value, tmp_value),
+ true);
} else if constexpr (PT == PredicateType::LT || PT ==
PredicateType::LE) {
- return _operator(tmp_min_value, _value);
+ return _operator(tmp_min_value, tmp_value);
} else {
static_assert(PT == PredicateType::GT || PT == PredicateType::GE);
- return _operator(tmp_max_value, _value);
+ return _operator(tmp_max_value, tmp_value);
}
}
@@ -168,17 +175,8 @@ public:
*/
bool camp_field(const vectorized::Field& min_field, const
vectorized::Field& max_field) const {
- T min_value;
- T max_value;
- if constexpr (is_string_type(Type)) {
- auto& tmp_min = min_field.template get<Type>();
- auto& tmp_max = max_field.template get<Type>();
- min_value = StringRef(tmp_min.data(), tmp_min.size());
- max_value = StringRef(tmp_max.data(), tmp_max.size());
- } else {
- min_value = min_field.template get<Type>();
- max_value = max_field.template get<Type>();
- }
+ T min_value = min_field.template get<Type>();
+ T max_value = max_field.template get<Type>();
if constexpr (PT == PredicateType::EQ) {
return Compare::less_equal(min_value, _value) &&
@@ -259,17 +257,24 @@ public:
return false;
}
- T tmp_min_value = get_zone_map_value<Type,
T>(statistic.first->cell_ptr());
- T tmp_max_value = get_zone_map_value<Type,
T>(statistic.second->cell_ptr());
+ using CompareType = typename std::conditional<is_string_type(Type),
StringRef, T>::type;
+ auto tmp_min_value = get_zone_map_value<Type,
CompareType>(statistic.first->cell_ptr());
+ auto tmp_max_value = get_zone_map_value<Type,
CompareType>(statistic.second->cell_ptr());
+ CompareType tmp_value;
+ if constexpr (is_string_type(Type)) {
+ tmp_value = StringRef(_value.data(), _value.size());
+ } else {
+ tmp_value = _value;
+ }
if constexpr (PT == PredicateType::LT) {
- return _value > tmp_max_value;
+ return tmp_value > tmp_max_value;
} else if constexpr (PT == PredicateType::LE) {
- return _value >= tmp_max_value;
+ return tmp_value >= tmp_max_value;
} else if constexpr (PT == PredicateType::GT) {
- return _value < tmp_min_value;
+ return tmp_value < tmp_min_value;
} else if constexpr (PT == PredicateType::GE) {
- return _value <= tmp_min_value;
+ return tmp_value <= tmp_min_value;
}
return false;
@@ -280,18 +285,25 @@ public:
return false;
}
- T tmp_min_value = get_zone_map_value<Type,
T>(statistic.first->cell_ptr());
- T tmp_max_value = get_zone_map_value<Type,
T>(statistic.second->cell_ptr());
+ using CompareType = typename std::conditional<is_string_type(Type),
StringRef, T>::type;
+ auto tmp_min_value = get_zone_map_value<Type,
CompareType>(statistic.first->cell_ptr());
+ auto tmp_max_value = get_zone_map_value<Type,
CompareType>(statistic.second->cell_ptr());
+ CompareType tmp_value;
+ if constexpr (is_string_type(Type)) {
+ tmp_value = StringRef(_value.data(), _value.size());
+ } else {
+ tmp_value = _value;
+ }
if constexpr (PT == PredicateType::EQ) {
- return tmp_min_value == _value && tmp_max_value == _value;
+ return tmp_min_value == tmp_value && tmp_max_value == tmp_value;
} else if constexpr (PT == PredicateType::NE) {
- return tmp_min_value > _value || tmp_max_value < _value;
+ return tmp_min_value > tmp_value || tmp_max_value < tmp_value;
} else if constexpr (PT == PredicateType::LT || PT ==
PredicateType::LE) {
- return _operator(tmp_max_value, _value);
+ return _operator(tmp_max_value, tmp_value);
} else {
static_assert(PT == PredicateType::GT || PT == PredicateType::GE);
- return _operator(tmp_min_value, _value);
+ return _operator(tmp_min_value, tmp_value);
}
}
@@ -301,8 +313,8 @@ public:
if (bf->is_ngram_bf()) {
return true;
}
- if constexpr (std::is_same_v<T, StringRef>) {
- return bf->test_bytes(_value.data, _value.size);
+ if constexpr (is_string_type(Type)) {
+ return bf->test_bytes(_value.data(), _value.size());
} else {
// DecimalV2 using decimal12_t in bloom filter, should convert
value to decimal12_t
if constexpr (Type == PrimitiveType::TYPE_DECIMALV2) {
@@ -330,7 +342,7 @@ public:
}
bool evaluate_and(const StringRef* dict_words, const size_t count) const
override {
- if constexpr (std::is_same_v<T, StringRef>) {
+ if constexpr (is_string_type(Type)) {
for (size_t i = 0; i != count; ++i) {
if (_operator(dict_words[i], _value) ^ _opposite) {
return true;
@@ -370,9 +382,9 @@ public:
} else if constexpr (Type == PrimitiveType::TYPE_DOUBLE) {
// DOUBLE -> hash as double
return test_bytes(_value);
- } else if constexpr (std::is_same_v<T, StringRef>) {
+ } else if constexpr (is_string_type(Type)) {
// VARCHAR/STRING -> hash bytes
- return bf->test_bytes(_value.data, _value.size);
+ return bf->test_bytes(_value.data(), _value.size());
} else {
// Unsupported types: return true (accept)
return true;
@@ -422,7 +434,7 @@ public:
.get_data();
if (nested_column.is_column_dictionary()) {
- if constexpr (std::is_same_v<T, StringRef>) {
+ if constexpr (is_string_type(Type)) {
const auto* dict_column_ptr =
vectorized::check_and_get_column<vectorized::ColumnDictI32>(
nested_column);
@@ -456,7 +468,7 @@ public:
}
} else {
if (column.is_column_dictionary()) {
- if constexpr (std::is_same_v<T, StringRef>) {
+ if constexpr (is_string_type(Type)) {
const auto* dict_column_ptr =
vectorized::check_and_get_column<vectorized::ColumnDictI32>(column);
auto dict_code =
_find_code_from_dictionary_column(*dict_column_ptr);
@@ -533,18 +545,34 @@ private:
template <typename LeftT, typename RightT>
bool _operator(const LeftT& lhs, const RightT& rhs) const {
- if constexpr (PT == PredicateType::EQ) {
- return Compare::equal(lhs, rhs);
- } else if constexpr (PT == PredicateType::NE) {
- return Compare::not_equal(lhs, rhs);
- } else if constexpr (PT == PredicateType::LT) {
- return Compare::less(lhs, rhs);
- } else if constexpr (PT == PredicateType::LE) {
- return Compare::less_equal(lhs, rhs);
- } else if constexpr (PT == PredicateType::GT) {
- return Compare::greater(lhs, rhs);
- } else if constexpr (PT == PredicateType::GE) {
- return Compare::greater_equal(lhs, rhs);
+ if constexpr (std::is_same_v<std::string, RightT> &&
!std::is_same_v<LeftT, RightT>) {
+ if constexpr (PT == PredicateType::EQ) {
+ return Compare::equal(lhs, StringRef(rhs.data(), rhs.size()));
+ } else if constexpr (PT == PredicateType::NE) {
+ return Compare::not_equal(lhs, StringRef(rhs.data(),
rhs.size()));
+ } else if constexpr (PT == PredicateType::LT) {
+ return Compare::less(lhs, StringRef(rhs.data(), rhs.size()));
+ } else if constexpr (PT == PredicateType::LE) {
+ return Compare::less_equal(lhs, StringRef(rhs.data(),
rhs.size()));
+ } else if constexpr (PT == PredicateType::GT) {
+ return Compare::greater(lhs, StringRef(rhs.data(),
rhs.size()));
+ } else if constexpr (PT == PredicateType::GE) {
+ return Compare::greater_equal(lhs, StringRef(rhs.data(),
rhs.size()));
+ }
+ } else {
+ if constexpr (PT == PredicateType::EQ) {
+ return Compare::equal(lhs, rhs);
+ } else if constexpr (PT == PredicateType::NE) {
+ return Compare::not_equal(lhs, rhs);
+ } else if constexpr (PT == PredicateType::LT) {
+ return Compare::less(lhs, rhs);
+ } else if constexpr (PT == PredicateType::LE) {
+ return Compare::less_equal(lhs, rhs);
+ } else if constexpr (PT == PredicateType::GT) {
+ return Compare::greater(lhs, rhs);
+ } else if constexpr (PT == PredicateType::GE) {
+ return Compare::greater_equal(lhs, rhs);
+ }
}
}
@@ -621,7 +649,7 @@ private:
void _base_evaluate_bit(const vectorized::IColumn* column, const uint8_t*
null_map,
const uint16_t* sel, uint16_t size, bool* flags)
const {
if (column->is_column_dictionary()) {
- if constexpr (std::is_same_v<T, StringRef>) {
+ if constexpr (is_string_type(Type)) {
const auto* dict_column_ptr =
vectorized::check_and_get_column<vectorized::ColumnDictI32>(column);
const auto* data_array = dict_column_ptr->get_data().data();
@@ -647,7 +675,7 @@ private:
uint16_t _base_evaluate(const vectorized::IColumn* column, const uint8_t*
null_map,
uint16_t* sel, uint16_t size) const {
if (column->is_column_dictionary()) {
- if constexpr (std::is_same_v<T, StringRef>) {
+ if constexpr (is_string_type(Type)) {
const auto* dict_column_ptr =
vectorized::check_and_get_column<vectorized::ColumnDictI32>(column);
const auto& pred_col = dict_column_ptr->get_data();
@@ -691,14 +719,17 @@ private:
int32_t __attribute__((flatten))
_find_code_from_dictionary_column(const vectorized::ColumnDictI32& column)
const {
+ static_assert(is_string_type(Type),
+ "Only string type predicate can use dictionary column.");
int32_t code = 0;
if (_segment_id_to_cached_code.if_contains(
column.get_rowset_segment_id(),
[&code](const auto& pair) { code = pair.second; })) {
return code;
}
- code = _is_range() ? column.find_code_by_bound(_value, _is_greater(),
_is_eq())
- : column.find_code(_value);
+ code = _is_range() ?
column.find_code_by_bound(StringRef(_value.data(), _value.size()),
+ _is_greater(), _is_eq())
+ : column.find_code(StringRef(_value.data(),
_value.size()));
// Sometimes the dict is not initialized when run comparison predicate
here, for example,
// the full page is null, then the reader will skip read, so that the
dictionary is not
// inited. The cached code is wrong during this case, because the
following page maybe not
diff --git a/be/src/olap/delete_handler.cpp b/be/src/olap/delete_handler.cpp
index 3044b6e2d95..ab85af0bed2 100644
--- a/be/src/olap/delete_handler.cpp
+++ b/be/src/olap/delete_handler.cpp
@@ -248,32 +248,31 @@ Status convert(const vectorized::DataTypePtr& data_type,
const std::list<std::st
case PType: {
\
typename PrimitiveTypeTraits<PType>::CppType tmp;
\
RETURN_IF_ERROR(convert<PType>(type, res.value_str.front(), arena,
tmp)); \
- v.data = reinterpret_cast<const char*>(&tmp);
\
- v.size = sizeof(tmp);
\
+ v = vectorized::Field::create_field<PType>(tmp);
\
switch (res.condition_op) {
\
case PredicateType::EQ:
\
- predicate = create_comparison_predicate0<PredicateType::EQ>(index,
col_name, type, v, \
- true,
arena); \
+ predicate = create_comparison_predicate<PredicateType::EQ>(index,
col_name, type, v, \
+ true);
\
return Status::OK();
\
case PredicateType::NE:
\
- predicate = create_comparison_predicate0<PredicateType::NE>(index,
col_name, type, v, \
- true,
arena); \
+ predicate = create_comparison_predicate<PredicateType::NE>(index,
col_name, type, v, \
+ true);
\
return Status::OK();
\
case PredicateType::GT:
\
- predicate = create_comparison_predicate0<PredicateType::GT>(index,
col_name, type, v, \
- true,
arena); \
+ predicate = create_comparison_predicate<PredicateType::GT>(index,
col_name, type, v, \
+ true);
\
return Status::OK();
\
case PredicateType::GE:
\
- predicate = create_comparison_predicate0<PredicateType::GE>(index,
col_name, type, v, \
- true,
arena); \
+ predicate = create_comparison_predicate<PredicateType::GE>(index,
col_name, type, v, \
+ true);
\
return Status::OK();
\
case PredicateType::LT:
\
- predicate = create_comparison_predicate0<PredicateType::LT>(index,
col_name, type, v, \
- true,
arena); \
+ predicate = create_comparison_predicate<PredicateType::LT>(index,
col_name, type, v, \
+ true);
\
return Status::OK();
\
case PredicateType::LE:
\
- predicate = create_comparison_predicate0<PredicateType::LE>(index,
col_name, type, v, \
- true,
arena); \
+ predicate = create_comparison_predicate<PredicateType::LE>(index,
col_name, type, v, \
+ true);
\
return Status::OK();
\
default:
\
return Status::Error<ErrorCode::INVALID_ARGUMENT>(
\
@@ -292,7 +291,7 @@ Status parse_to_predicate(const uint32_t index, const
std::string col_name,
type->get_primitive_type());
return Status::OK();
}
- StringRef v;
+ vectorized::Field v;
switch (type->get_primitive_type()) {
CONVERT_CASE(TYPE_TINYINT);
CONVERT_CASE(TYPE_SMALLINT);
@@ -317,31 +316,31 @@ Status parse_to_predicate(const uint32_t index, const
std::string col_name,
case TYPE_CHAR:
case TYPE_VARCHAR:
case TYPE_STRING: {
- v = {res.value_str.front().data(), res.value_str.front().size()};
+ v =
vectorized::Field::create_field<TYPE_STRING>(res.value_str.front());
switch (res.condition_op) {
case PredicateType::EQ:
- predicate = create_comparison_predicate0<PredicateType::EQ>(index,
col_name, type, v,
- true,
arena);
+ predicate =
+ create_comparison_predicate<PredicateType::EQ>(index,
col_name, type, v, true);
return Status::OK();
case PredicateType::NE:
- predicate = create_comparison_predicate0<PredicateType::NE>(index,
col_name, type, v,
- true,
arena);
+ predicate =
+ create_comparison_predicate<PredicateType::NE>(index,
col_name, type, v, true);
return Status::OK();
case PredicateType::GT:
- predicate = create_comparison_predicate0<PredicateType::GT>(index,
col_name, type, v,
- true,
arena);
+ predicate =
+ create_comparison_predicate<PredicateType::GT>(index,
col_name, type, v, true);
return Status::OK();
case PredicateType::GE:
- predicate = create_comparison_predicate0<PredicateType::GE>(index,
col_name, type, v,
- true,
arena);
+ predicate =
+ create_comparison_predicate<PredicateType::GE>(index,
col_name, type, v, true);
return Status::OK();
case PredicateType::LT:
- predicate = create_comparison_predicate0<PredicateType::LT>(index,
col_name, type, v,
- true,
arena);
+ predicate =
+ create_comparison_predicate<PredicateType::LT>(index,
col_name, type, v, true);
return Status::OK();
case PredicateType::LE:
- predicate = create_comparison_predicate0<PredicateType::LE>(index,
col_name, type, v,
- true,
arena);
+ predicate =
+ create_comparison_predicate<PredicateType::LE>(index,
col_name, type, v, true);
return Status::OK();
default:
return Status::Error<ErrorCode::INVALID_ARGUMENT>(
diff --git a/be/src/olap/in_list_predicate.h b/be/src/olap/in_list_predicate.h
index d78856eee0d..3a388894f4d 100644
--- a/be/src/olap/in_list_predicate.h
+++ b/be/src/olap/in_list_predicate.h
@@ -66,16 +66,15 @@ template <PrimitiveType Type, PredicateType PT, int N>
class InListPredicateBase final : public ColumnPredicate {
public:
ENABLE_FACTORY_CREATOR(InListPredicateBase);
- using T = std::conditional_t<is_string_type(Type), StringRef,
- typename PrimitiveTypeTraits<Type>::CppType>;
+ using T = typename PrimitiveTypeTraits<Type>::CppType;
using HybridSetType = std::conditional_t<
N >= 1 && N <= FIXED_CONTAINER_MAX_SIZE,
std::conditional_t<
- std::is_same_v<T, StringRef>,
StringSet<FixedContainer<std::string, N>>,
+ is_string_type(Type),
StringSet<FixedContainer<std::string, N>>,
HybridSet<Type, FixedContainer<T, N>,
vectorized::PredicateColumnType<PredicateEvaluateType<Type>>>>,
std::conditional_t<
- std::is_same_v<T, StringRef>,
StringSet<DynamicContainer<std::string>>,
+ is_string_type(Type),
StringSet<DynamicContainer<std::string>>,
HybridSet<Type, DynamicContainer<T>,
vectorized::PredicateColumnType<PredicateEvaluateType<Type>>>>>;
InListPredicateBase(uint32_t column_id, std::string col_name,
@@ -244,34 +243,52 @@ public:
if (statistic.first->is_null() && statistic.second->is_null()) {
return false;
}
+ using CompareType = typename std::conditional<is_string_type(Type),
StringRef, T>::type;
+ CompareType tmp_min_value;
+ CompareType tmp_max_value;
+ if constexpr (is_string_type(Type)) {
+ tmp_min_value = StringRef(_min_value.data(), _min_value.size());
+ tmp_max_value = StringRef(_max_value.data(), _max_value.size());
+ } else {
+ tmp_min_value = _min_value;
+ tmp_max_value = _max_value;
+ }
if constexpr (PT == PredicateType::IN_LIST) {
- return Compare::less_equal(get_zone_map_value<Type,
T>(statistic.first->cell_ptr()),
- _max_value) &&
- Compare::greater_equal(get_zone_map_value<Type,
T>(statistic.second->cell_ptr()),
- _min_value);
+ return Compare::less_equal(
+ get_zone_map_value<Type,
CompareType>(statistic.first->cell_ptr()),
+ tmp_max_value) &&
+ Compare::greater_equal(
+ get_zone_map_value<Type,
CompareType>(statistic.second->cell_ptr()),
+ tmp_min_value);
} else {
return true;
}
}
bool camp_field(const vectorized::Field& min_field, const
vectorized::Field& max_field) const {
- T min_value;
- T max_value;
+ using CompareType = typename std::conditional<is_string_type(Type),
StringRef, T>::type;
+ CompareType min_value;
+ CompareType max_value;
+ CompareType tmp_min_value;
+ CompareType tmp_max_value;
if constexpr (is_string_type(Type)) {
+ tmp_min_value = StringRef(_min_value.data(), _min_value.size());
+ tmp_max_value = StringRef(_max_value.data(), _max_value.size());
auto& tmp_min = min_field.template get<Type>();
auto& tmp_max = max_field.template get<Type>();
min_value = StringRef(tmp_min.data(), tmp_min.size());
max_value = StringRef(tmp_max.data(), tmp_max.size());
} else {
+ tmp_min_value = _min_value;
+ tmp_max_value = _max_value;
min_value = min_field.template get<Type>();
max_value = max_field.template get<Type>();
}
-
if constexpr (PT == PredicateType::IN_LIST) {
- return (Compare::less_equal(min_value, _max_value) &&
- Compare::greater_equal(max_value, _min_value)) ||
- (Compare::greater_equal(max_value, _min_value) &&
- Compare::less_equal(min_value, _max_value));
+ return (Compare::less_equal(min_value, tmp_max_value) &&
+ Compare::greater_equal(max_value, tmp_min_value)) ||
+ (Compare::greater_equal(max_value, tmp_min_value) &&
+ Compare::less_equal(min_value, tmp_max_value));
} else {
return true;
}
@@ -354,10 +371,22 @@ public:
return false;
}
if constexpr (PT == PredicateType::NOT_IN_LIST) {
- return Compare::greater(get_zone_map_value<Type,
T>(statistic.first->cell_ptr()),
- _max_value) ||
- Compare::less(get_zone_map_value<Type,
T>(statistic.second->cell_ptr()),
- _min_value);
+ using CompareType = typename
std::conditional<is_string_type(Type), StringRef, T>::type;
+ CompareType tmp_min_value;
+ CompareType tmp_max_value;
+ if constexpr (is_string_type(Type)) {
+ tmp_min_value = StringRef(_min_value.data(),
_min_value.size());
+ tmp_max_value = StringRef(_max_value.data(),
_max_value.size());
+ } else {
+ tmp_min_value = _min_value;
+ tmp_max_value = _max_value;
+ }
+ return Compare::greater(
+ get_zone_map_value<Type,
CompareType>(statistic.first->cell_ptr()),
+ tmp_max_value) ||
+ Compare::less(
+ get_zone_map_value<Type,
CompareType>(statistic.second->cell_ptr()),
+ tmp_min_value);
} else {
return false;
}
@@ -371,7 +400,7 @@ public:
}
HybridSetBase::IteratorBase* iter = _values->begin();
while (iter->has_next()) {
- if constexpr (std::is_same_v<T, StringRef>) {
+ if constexpr (is_string_type(Type)) {
const auto* value = (const StringRef*)iter->get_value();
if (bf->test_bytes(value->data, value->size)) {
return true;
@@ -458,9 +487,9 @@ public:
if (test_bytes(*value)) {
return true;
}
- } else if constexpr (std::is_same_v<T, StringRef>) {
+ } else if constexpr (is_string_type(Type)) {
// VARCHAR/STRING -> hash bytes
- if (bf->test_bytes(value->data, value->size)) {
+ if (bf->test_bytes(value->data(), value->size())) {
return true;
}
} else {
@@ -519,7 +548,7 @@ private:
uint16_t new_size = 0;
if (column->is_column_dictionary()) {
- if constexpr (std::is_same_v<T, StringRef>) {
+ if constexpr (is_string_type(Type)) {
const auto* nested_col_ptr =
vectorized::check_and_get_column<vectorized::ColumnDictI32>(column);
const auto& data_array = nested_col_ptr->get_data();
@@ -586,7 +615,7 @@ private:
const
vectorized::PaddedPODArray<vectorized::UInt8>* null_map,
const uint16_t* sel, uint16_t size, bool* flags)
const {
if (column->is_column_dictionary()) {
- if constexpr (std::is_same_v<T, StringRef>) {
+ if constexpr (is_string_type(Type)) {
const auto* nested_col_ptr =
vectorized::check_and_get_column<vectorized::ColumnDictI32>(column);
const auto& data_array = nested_col_ptr->get_data();
diff --git a/be/src/olap/predicate_creator.h b/be/src/olap/predicate_creator.h
index c225dcfc3d9..08c94d0bba6 100644
--- a/be/src/olap/predicate_creator.h
+++ b/be/src/olap/predicate_creator.h
@@ -172,134 +172,113 @@ std::shared_ptr<ColumnPredicate>
create_in_list_predicate(const uint32_t cid,
}
template <PredicateType PT>
-std::shared_ptr<ColumnPredicate> create_comparison_predicate0(
+std::shared_ptr<ColumnPredicate> create_comparison_predicate(
const uint32_t cid, const std::string col_name, const
vectorized::DataTypePtr& data_type,
- StringRef& value, bool opposite, vectorized::Arena& arena) {
+ const vectorized::Field& value, bool opposite) {
switch (data_type->get_primitive_type()) {
case TYPE_TINYINT: {
- return ComparisonPredicateBase<TYPE_TINYINT, PT>::create_shared(
- cid, col_name, *(typename
PrimitiveTypeTraits<TYPE_TINYINT>::CppType*)value.data,
- opposite);
+ return ComparisonPredicateBase<TYPE_TINYINT, PT>::create_shared(cid,
col_name, value,
+
opposite);
}
case TYPE_SMALLINT: {
- return ComparisonPredicateBase<TYPE_SMALLINT, PT>::create_shared(
- cid, col_name, *(typename
PrimitiveTypeTraits<TYPE_SMALLINT>::CppType*)value.data,
- opposite);
+ return ComparisonPredicateBase<TYPE_SMALLINT, PT>::create_shared(cid,
col_name, value,
+
opposite);
}
case TYPE_INT: {
- return ComparisonPredicateBase<TYPE_INT, PT>::create_shared(
- cid, col_name, *(typename
PrimitiveTypeTraits<TYPE_INT>::CppType*)value.data,
- opposite);
+ return ComparisonPredicateBase<TYPE_INT, PT>::create_shared(cid,
col_name, value, opposite);
}
case TYPE_BIGINT: {
- return ComparisonPredicateBase<TYPE_BIGINT, PT>::create_shared(
- cid, col_name, *(typename
PrimitiveTypeTraits<TYPE_BIGINT>::CppType*)value.data,
- opposite);
+ return ComparisonPredicateBase<TYPE_BIGINT, PT>::create_shared(cid,
col_name, value,
+
opposite);
}
case TYPE_LARGEINT: {
- return ComparisonPredicateBase<TYPE_LARGEINT, PT>::create_shared(
- cid, col_name, *(typename
PrimitiveTypeTraits<TYPE_LARGEINT>::CppType*)value.data,
- opposite);
+ return ComparisonPredicateBase<TYPE_LARGEINT, PT>::create_shared(cid,
col_name, value,
+
opposite);
}
case TYPE_FLOAT: {
- return ComparisonPredicateBase<TYPE_FLOAT, PT>::create_shared(
- cid, col_name, *(typename
PrimitiveTypeTraits<TYPE_FLOAT>::CppType*)value.data,
- opposite);
+ return ComparisonPredicateBase<TYPE_FLOAT, PT>::create_shared(cid,
col_name, value,
+
opposite);
}
case TYPE_DOUBLE: {
- return ComparisonPredicateBase<TYPE_DOUBLE, PT>::create_shared(
- cid, col_name, *(typename
PrimitiveTypeTraits<TYPE_DOUBLE>::CppType*)value.data,
- opposite);
+ return ComparisonPredicateBase<TYPE_DOUBLE, PT>::create_shared(cid,
col_name, value,
+
opposite);
}
case TYPE_DECIMALV2: {
- return ComparisonPredicateBase<TYPE_DECIMALV2, PT>::create_shared(
- cid, col_name, *(typename
PrimitiveTypeTraits<TYPE_DECIMALV2>::CppType*)value.data,
- opposite);
+ return ComparisonPredicateBase<TYPE_DECIMALV2, PT>::create_shared(cid,
col_name, value,
+
opposite);
}
case TYPE_DECIMAL32: {
- return ComparisonPredicateBase<TYPE_DECIMAL32, PT>::create_shared(
- cid, col_name, *(typename
PrimitiveTypeTraits<TYPE_DECIMAL32>::CppType*)value.data,
- opposite);
+ return ComparisonPredicateBase<TYPE_DECIMAL32, PT>::create_shared(cid,
col_name, value,
+
opposite);
}
case TYPE_DECIMAL64: {
- return ComparisonPredicateBase<TYPE_DECIMAL64, PT>::create_shared(
- cid, col_name, *(typename
PrimitiveTypeTraits<TYPE_DECIMAL64>::CppType*)value.data,
- opposite);
+ return ComparisonPredicateBase<TYPE_DECIMAL64, PT>::create_shared(cid,
col_name, value,
+
opposite);
}
case TYPE_DECIMAL128I: {
- return ComparisonPredicateBase<TYPE_DECIMAL128I, PT>::create_shared(
- cid, col_name,
- *(typename
PrimitiveTypeTraits<TYPE_DECIMAL128I>::CppType*)value.data, opposite);
+ return ComparisonPredicateBase<TYPE_DECIMAL128I,
PT>::create_shared(cid, col_name, value,
+
opposite);
}
case TYPE_DECIMAL256: {
- return ComparisonPredicateBase<TYPE_DECIMAL256, PT>::create_shared(
- cid, col_name, *(typename
PrimitiveTypeTraits<TYPE_DECIMAL256>::CppType*)value.data,
- opposite);
+ return ComparisonPredicateBase<TYPE_DECIMAL256,
PT>::create_shared(cid, col_name, value,
+
opposite);
}
case TYPE_CHAR: {
- // TODO(gabriel): Use std::string instead of StringRef
auto target =
std::max(cast_set<size_t>(assert_cast<const
vectorized::DataTypeString*>(
vectorized::remove_nullable(data_type).get())
->len()),
- value.size);
- char* buffer = arena.alloc(target);
- memset(buffer, 0, target);
- memcpy(buffer, value.data, value.size);
- StringRef v = {buffer, target};
- return ComparisonPredicateBase<TYPE_CHAR, PT>::create_shared(cid,
col_name, v, opposite);
- }
- case TYPE_VARCHAR: {
- char* buffer = arena.alloc(value.size);
- memcpy(buffer, value.data, value.size);
- StringRef v = {buffer, value.size};
- return ComparisonPredicateBase<TYPE_VARCHAR, PT>::create_shared(cid,
col_name, v, opposite);
- }
+ value.template get<TYPE_CHAR>().size());
+ if (target > value.template get<TYPE_CHAR>().size()) {
+ std::string tmp(target, '\0');
+ memcpy(tmp.data(), value.template get<TYPE_CHAR>().data(),
+ value.template get<TYPE_CHAR>().size());
+ return ComparisonPredicateBase<TYPE_CHAR, PT>::create_shared(
+ cid, col_name,
vectorized::Field::create_field<TYPE_CHAR>(std::move(tmp)),
+ opposite);
+ } else {
+ return ComparisonPredicateBase<TYPE_CHAR, PT>::create_shared(
+ cid, col_name,
+ vectorized::Field::create_field<TYPE_CHAR>(value.template
get<TYPE_CHAR>()),
+ opposite);
+ }
+ }
+ case TYPE_VARCHAR:
case TYPE_STRING: {
- char* buffer = arena.alloc(value.size);
- memcpy(buffer, value.data, value.size);
- StringRef v = {buffer, value.size};
- return ComparisonPredicateBase<TYPE_STRING, PT>::create_shared(cid,
col_name, v, opposite);
+ return ComparisonPredicateBase<TYPE_STRING, PT>::create_shared(cid,
col_name, value,
+
opposite);
}
case TYPE_DATE: {
- return ComparisonPredicateBase<TYPE_DATE, PT>::create_shared(
- cid, col_name, *(typename
PrimitiveTypeTraits<TYPE_DATE>::CppType*)value.data,
- opposite);
+ return ComparisonPredicateBase<TYPE_DATE, PT>::create_shared(cid,
col_name, value,
+ opposite);
}
case TYPE_DATEV2: {
- return ComparisonPredicateBase<TYPE_DATEV2, PT>::create_shared(
- cid, col_name, *(typename
PrimitiveTypeTraits<TYPE_DATEV2>::CppType*)value.data,
- opposite);
+ return ComparisonPredicateBase<TYPE_DATEV2, PT>::create_shared(cid,
col_name, value,
+
opposite);
}
case TYPE_DATETIME: {
- return ComparisonPredicateBase<TYPE_DATETIME, PT>::create_shared(
- cid, col_name, *(typename
PrimitiveTypeTraits<TYPE_DATETIME>::CppType*)value.data,
- opposite);
+ return ComparisonPredicateBase<TYPE_DATETIME, PT>::create_shared(cid,
col_name, value,
+
opposite);
}
case TYPE_DATETIMEV2: {
- return ComparisonPredicateBase<TYPE_DATETIMEV2, PT>::create_shared(
- cid, col_name, *(typename
PrimitiveTypeTraits<TYPE_DATETIMEV2>::CppType*)value.data,
- opposite);
+ return ComparisonPredicateBase<TYPE_DATETIMEV2,
PT>::create_shared(cid, col_name, value,
+
opposite);
}
case TYPE_TIMESTAMPTZ: {
- return ComparisonPredicateBase<TYPE_TIMESTAMPTZ, PT>::create_shared(
- cid, col_name,
- *(typename
PrimitiveTypeTraits<TYPE_TIMESTAMPTZ>::CppType*)value.data, opposite);
+ return ComparisonPredicateBase<TYPE_TIMESTAMPTZ,
PT>::create_shared(cid, col_name, value,
+
opposite);
}
case TYPE_BOOLEAN: {
- return ComparisonPredicateBase<TYPE_BOOLEAN, PT>::create_shared(
- cid, col_name, *(typename
PrimitiveTypeTraits<TYPE_BOOLEAN>::CppType*)value.data,
- opposite);
+ return ComparisonPredicateBase<TYPE_BOOLEAN, PT>::create_shared(cid,
col_name, value,
+
opposite);
}
case TYPE_IPV4: {
- return ComparisonPredicateBase<TYPE_IPV4, PT>::create_shared(
- cid, col_name, *(typename
PrimitiveTypeTraits<TYPE_IPV4>::CppType*)value.data,
- opposite);
+ return ComparisonPredicateBase<TYPE_IPV4, PT>::create_shared(cid,
col_name, value,
+ opposite);
}
case TYPE_IPV6: {
- return ComparisonPredicateBase<TYPE_IPV6, PT>::create_shared(
- cid, col_name, *(typename
PrimitiveTypeTraits<TYPE_IPV6>::CppType*)value.data,
- opposite);
+ return ComparisonPredicateBase<TYPE_IPV6, PT>::create_shared(cid,
col_name, value,
+ opposite);
}
default:
throw Exception(Status::InternalError("Unsupported type {} for
comparison_predicate",
diff --git a/be/src/pipeline/exec/file_scan_operator.cpp
b/be/src/pipeline/exec/file_scan_operator.cpp
index 2ffa0e64465..ace81d0b97c 100644
--- a/be/src/pipeline/exec/file_scan_operator.cpp
+++ b/be/src/pipeline/exec/file_scan_operator.cpp
@@ -34,11 +34,10 @@ namespace doris::pipeline {
PushDownType FileScanLocalState::_should_push_down_binary_predicate(
vectorized::VectorizedFnCall* fn_call, vectorized::VExprContext*
expr_ctx,
- StringRef* constant_val, const std::set<std::string> fn_name) const {
+ vectorized::Field& constant_val, const std::set<std::string> fn_name)
const {
if (!fn_name.contains(fn_call->fn().name.function_name)) {
return PushDownType::UNACCEPTABLE;
}
- DCHECK(constant_val->data == nullptr) << "constant_val should not have a
value";
const auto& children = fn_call->children();
DCHECK(children.size() == 2);
DCHECK_EQ(children[0]->node_type(), TExprNodeType::SLOT_REF);
@@ -47,7 +46,7 @@ PushDownType
FileScanLocalState::_should_push_down_binary_predicate(
THROW_IF_ERROR(children[1]->get_const_col(expr_ctx,
&const_col_wrapper));
const auto* const_column =
assert_cast<const
vectorized::ColumnConst*>(const_col_wrapper->column_ptr.get());
- *constant_val = const_column->get_data_at(0);
+ constant_val = const_column->operator[](0);
return PushDownType::PARTIAL_ACCEPTABLE;
} else {
// only handle constant value
diff --git a/be/src/pipeline/exec/file_scan_operator.h
b/be/src/pipeline/exec/file_scan_operator.h
index 9c99df14874..31aa92cfbb2 100644
--- a/be/src/pipeline/exec/file_scan_operator.h
+++ b/be/src/pipeline/exec/file_scan_operator.h
@@ -87,7 +87,7 @@ private:
}
PushDownType _should_push_down_binary_predicate(
vectorized::VectorizedFnCall* fn_call, vectorized::VExprContext*
expr_ctx,
- StringRef* constant_val, const std::set<std::string> fn_name)
const override;
+ vectorized::Field& constant_val, const std::set<std::string>
fn_name) const override;
std::shared_ptr<vectorized::SplitSourceConnector> _split_source = nullptr;
int _max_scanners;
// A in memory cache to save some common components
diff --git a/be/src/pipeline/exec/mock_scan_operator.h
b/be/src/pipeline/exec/mock_scan_operator.h
index 65e6cd32782..7f651e3391a 100644
--- a/be/src/pipeline/exec/mock_scan_operator.h
+++ b/be/src/pipeline/exec/mock_scan_operator.h
@@ -56,11 +56,10 @@ private:
}
PushDownType _should_push_down_binary_predicate(
vectorized::VectorizedFnCall* fn_call, vectorized::VExprContext*
expr_ctx,
- StringRef* constant_val, const std::set<std::string> fn_name)
const override {
+ vectorized::Field& constant_val, const std::set<std::string>
fn_name) const override {
if (!fn_name.contains(fn_call->fn().name.function_name)) {
return PushDownType::UNACCEPTABLE;
}
- DCHECK(constant_val->data == nullptr) << "constant_val should not have
a value";
const auto& children = fn_call->children();
DCHECK(children.size() == 2);
DCHECK_EQ(children[0]->node_type(), TExprNodeType::SLOT_REF);
@@ -69,7 +68,7 @@ private:
THROW_IF_ERROR(children[1]->get_const_col(expr_ctx,
&const_col_wrapper));
const auto* const_column = assert_cast<const
vectorized::ColumnConst*>(
const_col_wrapper->column_ptr.get());
- *constant_val = const_column->get_data_at(0);
+ constant_val = const_column->operator[](0);
return PushDownType::ACCEPTABLE;
} else {
// only handle constant value
diff --git a/be/src/pipeline/exec/olap_scan_operator.cpp
b/be/src/pipeline/exec/olap_scan_operator.cpp
index 46aa38577bf..09c3b742864 100644
--- a/be/src/pipeline/exec/olap_scan_operator.cpp
+++ b/be/src/pipeline/exec/olap_scan_operator.cpp
@@ -85,11 +85,10 @@ Status OlapScanLocalState::init(RuntimeState* state,
LocalStateInfo& info) {
PushDownType OlapScanLocalState::_should_push_down_binary_predicate(
vectorized::VectorizedFnCall* fn_call, vectorized::VExprContext*
expr_ctx,
- StringRef* constant_val, const std::set<std::string> fn_name) const {
+ vectorized::Field& constant_val, const std::set<std::string> fn_name)
const {
if (!fn_name.contains(fn_call->fn().name.function_name)) {
return PushDownType::UNACCEPTABLE;
}
- DCHECK(constant_val->data == nullptr) << "constant_val should not have a
value";
const auto& children = fn_call->children();
DCHECK(children.size() == 2);
DCHECK_EQ(children[0]->node_type(), TExprNodeType::SLOT_REF);
@@ -98,7 +97,7 @@ PushDownType
OlapScanLocalState::_should_push_down_binary_predicate(
THROW_IF_ERROR(children[1]->get_const_col(expr_ctx,
&const_col_wrapper));
const auto* const_column =
assert_cast<const
vectorized::ColumnConst*>(const_col_wrapper->column_ptr.get());
- *constant_val = const_column->get_data_at(0);
+ constant_val = const_column->operator[](0);
return PushDownType::ACCEPTABLE;
} else {
// only handle constant value
diff --git a/be/src/pipeline/exec/olap_scan_operator.h
b/be/src/pipeline/exec/olap_scan_operator.h
index cd054c66408..292081b29a6 100644
--- a/be/src/pipeline/exec/olap_scan_operator.h
+++ b/be/src/pipeline/exec/olap_scan_operator.h
@@ -99,7 +99,7 @@ private:
}
PushDownType _should_push_down_binary_predicate(
vectorized::VectorizedFnCall* fn_call, vectorized::VExprContext*
expr_ctx,
- StringRef* constant_val, const std::set<std::string> fn_name)
const override;
+ vectorized::Field& constant_val, const std::set<std::string>
fn_name) const override;
bool _should_push_down_common_expr() override;
diff --git a/be/src/pipeline/exec/scan_operator.cpp
b/be/src/pipeline/exec/scan_operator.cpp
index e8d8193a289..404d3e412e5 100644
--- a/be/src/pipeline/exec/scan_operator.cpp
+++ b/be/src/pipeline/exec/scan_operator.cpp
@@ -735,8 +735,20 @@ Status ScanLocalState<Derived>::_normalize_in_predicate(
// dispose next item
DCHECK(iter->get_value() != nullptr);
const auto* value = iter->get_value();
- RETURN_IF_ERROR(
- _change_value_range(is_in, temp_range, value, fn, is_in ?
"in" : "not_in"));
+ if constexpr (is_string_type(T)) {
+ const auto* str_value = reinterpret_cast<const
StringRef*>(value);
+ RETURN_IF_ERROR(_change_value_range(is_in, temp_range,
+
vectorized::Field::create_field<T>(std::string(
+ str_value->data,
str_value->size)),
+ fn, is_in ? "in" :
"not_in"));
+ } else {
+ RETURN_IF_ERROR(_change_value_range(
+ is_in, temp_range,
+ vectorized::Field::create_field<T>(
+ *reinterpret_cast<const typename
PrimitiveTypeTraits<T>::CppType*>(
+ value)),
+ fn, is_in ? "in" : "not_in"));
+ }
iter->next();
}
if (is_in) {
@@ -785,9 +797,9 @@ Status ScanLocalState<Derived>::_normalize_binary_predicate(
DCHECK(!root->is_rf_wrapper()) << root->debug_string();
DCHECK(TExprNodeType::BINARY_PRED == root->node_type()) <<
root->debug_string();
DCHECK(root->get_num_children() == 2);
- StringRef value;
+ vectorized::Field value;
*pdt = _should_push_down_binary_predicate(
- assert_cast<vectorized::VectorizedFnCall*>(root.get()), expr_ctx,
&value,
+ assert_cast<vectorized::VectorizedFnCall*>(root.get()), expr_ctx,
value,
{"eq", "ne", "lt", "gt", "le", "ge"});
if (*pdt == PushDownType::UNACCEPTABLE) {
return Status::OK();
@@ -799,60 +811,55 @@ Status
ScanLocalState<Derived>::_normalize_binary_predicate(
auto empty_range = ColumnValueRange<T>::create_empty_column_value_range(
slot->is_nullable(), range.precision(), range.scale());
auto& temp_range = op == SQLFilterOp::FILTER_EQ ? empty_range : range;
- if (value.data != nullptr) {
- if (!is_string_type(T) && sizeof(typename
PrimitiveTypeTraits<T>::CppType) != value.size) {
- return Status::InternalError(
- "PrimitiveType {} meet invalid input value size {}, expect
size {}", T,
- value.size, sizeof(typename
PrimitiveTypeTraits<T>::CppType));
- }
+ if (value.get_type() != TYPE_NULL) {
switch (op) {
case SQLFilterOp::FILTER_EQ:
- pred = create_comparison_predicate0<PredicateType::EQ>(
+ pred = create_comparison_predicate<PredicateType::EQ>(
_parent->intermediate_row_desc().get_column_id(slot->id()), slot->col_name(),
slot->type()->get_primitive_type() == TYPE_VARIANT
? root->get_child(0)->data_type()
: slot->type(),
- value, false, _arena);
+ value, false);
break;
case SQLFilterOp::FILTER_NE:
- pred = create_comparison_predicate0<PredicateType::NE>(
+ pred = create_comparison_predicate<PredicateType::NE>(
_parent->intermediate_row_desc().get_column_id(slot->id()), slot->col_name(),
slot->type()->get_primitive_type() == TYPE_VARIANT
? root->get_child(0)->data_type()
: slot->type(),
- value, false, _arena);
+ value, false);
break;
case SQLFilterOp::FILTER_LESS:
- pred = create_comparison_predicate0<PredicateType::LT>(
+ pred = create_comparison_predicate<PredicateType::LT>(
_parent->intermediate_row_desc().get_column_id(slot->id()), slot->col_name(),
slot->type()->get_primitive_type() == TYPE_VARIANT
? root->get_child(0)->data_type()
: slot->type(),
- value, false, _arena);
+ value, false);
break;
case SQLFilterOp::FILTER_LARGER:
- pred = create_comparison_predicate0<PredicateType::GT>(
+ pred = create_comparison_predicate<PredicateType::GT>(
_parent->intermediate_row_desc().get_column_id(slot->id()), slot->col_name(),
slot->type()->get_primitive_type() == TYPE_VARIANT
? root->get_child(0)->data_type()
: slot->type(),
- value, false, _arena);
+ value, false);
break;
case SQLFilterOp::FILTER_LESS_OR_EQUAL:
- pred = create_comparison_predicate0<PredicateType::LE>(
+ pred = create_comparison_predicate<PredicateType::LE>(
_parent->intermediate_row_desc().get_column_id(slot->id()), slot->col_name(),
slot->type()->get_primitive_type() == TYPE_VARIANT
? root->get_child(0)->data_type()
: slot->type(),
- value, false, _arena);
+ value, false);
break;
case SQLFilterOp::FILTER_LARGER_OR_EQUAL:
- pred = create_comparison_predicate0<PredicateType::GE>(
+ pred = create_comparison_predicate<PredicateType::GE>(
_parent->intermediate_row_desc().get_column_id(slot->id()), slot->col_name(),
slot->type()->get_primitive_type() == TYPE_VARIANT
? root->get_child(0)->data_type()
: slot->type(),
- value, false, _arena);
+ value, false);
break;
default:
throw Exception(Status::InternalError("Unsupported function name:
{}", function_name));
@@ -864,20 +871,7 @@ Status
ScanLocalState<Derived>::_normalize_binary_predicate(
?
ColumnValueRange<T>::remove_fixed_value_range
: ColumnValueRange<T>::empty_function)
: ColumnValueRange<T>::add_value_range;
- if constexpr (T == TYPE_CHAR || T == TYPE_VARCHAR || T == TYPE_STRING
|| T == TYPE_HLL) {
- auto val = StringRef(value.data, value.size);
- RETURN_IF_ERROR(_change_value_range(is_equal_op, temp_range,
- reinterpret_cast<void*>(&val),
fn, function_name));
- } else {
- if (sizeof(typename PrimitiveTypeTraits<T>::CppType) !=
value.size) {
- return Status::InternalError(
- "PrimitiveType {} meet invalid input value size {},
expect size {}", T,
- value.size, sizeof(typename
PrimitiveTypeTraits<T>::CppType));
- }
- RETURN_IF_ERROR(_change_value_range(is_equal_op, temp_range,
- reinterpret_cast<const
void*>(value.data), fn,
- function_name));
- }
+ RETURN_IF_ERROR(_change_value_range(is_equal_op, temp_range, value,
fn, function_name));
if (op == SQLFilterOp::FILTER_EQ) {
range.intersection(temp_range);
}
@@ -894,17 +888,14 @@ template <typename Derived>
template <PrimitiveType PrimitiveType, typename ChangeFixedValueRangeFunc>
Status ScanLocalState<Derived>::_change_value_range(bool is_equal_op,
ColumnValueRange<PrimitiveType>& temp_range,
- const void* value,
+ const vectorized::Field&
value,
const
ChangeFixedValueRangeFunc& func,
const std::string&
fn_name) {
if constexpr (PrimitiveType == TYPE_DATE) {
- VecDateTimeValue tmp_value;
- memcpy(&tmp_value, value, sizeof(VecDateTimeValue));
+ auto tmp_value = value.template get<TYPE_DATE>();
if (is_equal_op) {
if (!tmp_value.check_loss_accuracy_cast_to_date()) {
- func(temp_range, to_olap_filter_type(fn_name),
- reinterpret_cast<typename
PrimitiveTypeTraits<PrimitiveType>::CppType*>(
- &tmp_value));
+ func(temp_range, to_olap_filter_type(fn_name), tmp_value);
}
} else {
if (tmp_value.check_loss_accuracy_cast_to_date()) {
@@ -912,15 +903,8 @@ Status ScanLocalState<Derived>::_change_value_range(bool
is_equal_op,
++tmp_value;
}
}
- func(temp_range, to_olap_filter_type(fn_name),
- reinterpret_cast<typename
PrimitiveTypeTraits<PrimitiveType>::CppType*>(
- &tmp_value));
+ func(temp_range, to_olap_filter_type(fn_name), tmp_value);
}
- } else if constexpr (PrimitiveType == TYPE_DATETIME) {
- func(temp_range, to_olap_filter_type(fn_name),
- reinterpret_cast<const typename
PrimitiveTypeTraits<PrimitiveType>::CppType*>(value));
- } else if constexpr (PrimitiveType == TYPE_HLL) {
- func(temp_range, to_olap_filter_type(fn_name), reinterpret_cast<const
StringRef*>(value));
} else if constexpr ((PrimitiveType == TYPE_DECIMALV2) || (PrimitiveType
== TYPE_DATETIMEV2) ||
(PrimitiveType == TYPE_TINYINT) || (PrimitiveType ==
TYPE_SMALLINT) ||
(PrimitiveType == TYPE_INT) || (PrimitiveType ==
TYPE_BIGINT) ||
@@ -929,11 +913,13 @@ Status ScanLocalState<Derived>::_change_value_range(bool
is_equal_op,
(PrimitiveType == TYPE_IPV6) || (PrimitiveType ==
TYPE_DECIMAL32) ||
(PrimitiveType == TYPE_DECIMAL64) || (PrimitiveType
== TYPE_DECIMAL128I) ||
(PrimitiveType == TYPE_DECIMAL256) || (PrimitiveType
== TYPE_BOOLEAN) ||
- (PrimitiveType == TYPE_DATEV2) || (PrimitiveType ==
TYPE_TIMESTAMPTZ)) {
+ (PrimitiveType == TYPE_DATEV2) || (PrimitiveType ==
TYPE_TIMESTAMPTZ) ||
+ (PrimitiveType == TYPE_DATETIME) ||
is_string_type(PrimitiveType)) {
+ func(temp_range, to_olap_filter_type(fn_name), value.template
get<PrimitiveType>());
+ } else if constexpr (PrimitiveType == TYPE_HLL) {
+ auto tmp = value.template get<PrimitiveType>();
func(temp_range, to_olap_filter_type(fn_name),
- reinterpret_cast<const typename
PrimitiveTypeTraits<PrimitiveType>::CppType*>(value));
- } else if constexpr (is_string_type(PrimitiveType)) {
- func(temp_range, to_olap_filter_type(fn_name), reinterpret_cast<const
StringRef*>(value));
+ StringRef(reinterpret_cast<const char*>(&tmp), sizeof(tmp)));
} else {
static_assert(always_false_v<PrimitiveType>);
}
diff --git a/be/src/pipeline/exec/scan_operator.h
b/be/src/pipeline/exec/scan_operator.h
index f3deca4b55e..8e6fcf98a3a 100644
--- a/be/src/pipeline/exec/scan_operator.h
+++ b/be/src/pipeline/exec/scan_operator.h
@@ -223,7 +223,7 @@ protected:
}
virtual PushDownType _should_push_down_binary_predicate(
vectorized::VectorizedFnCall* fn_call, vectorized::VExprContext*
expr_ctx,
- StringRef* constant_val, const std::set<std::string> fn_name)
const {
+ vectorized::Field& constant_val, const std::set<std::string>
fn_name) const {
return PushDownType::UNACCEPTABLE;
}
@@ -289,8 +289,8 @@ protected:
template <PrimitiveType PrimitiveType, typename ChangeFixedValueRangeFunc>
Status _change_value_range(bool is_equal_op,
ColumnValueRange<PrimitiveType>& range,
- const void* value, const
ChangeFixedValueRangeFunc& func,
- const std::string& fn_name);
+ const vectorized::Field& value,
+ const ChangeFixedValueRangeFunc& func, const
std::string& fn_name);
Status _prepare_scanners();
diff --git a/be/src/runtime/runtime_predicate.cpp
b/be/src/runtime/runtime_predicate.cpp
index cd61775ef7c..8e0421c8af3 100644
--- a/be/src/runtime/runtime_predicate.cpp
+++ b/be/src/runtime/runtime_predicate.cpp
@@ -51,8 +51,8 @@ RuntimePredicate::RuntimePredicate(const TTopnFilterDesc&
desc)
// since values that > min_top_value are large than any value in current
topn values
// For DESC sort, create runtime predicate col_name >= min_top_value
// since values that < min_top_value are less than any value in current
topn values
- _pred_constructor = _is_asc ?
create_comparison_predicate0<PredicateType::LE>
- :
create_comparison_predicate0<PredicateType::GE>;
+ _pred_constructor = _is_asc ?
create_comparison_predicate<PredicateType::LE>
+ :
create_comparison_predicate<PredicateType::GE>;
}
Status RuntimePredicate::init_target(
@@ -79,112 +79,6 @@ Status RuntimePredicate::init_target(
return Status::OK();
}
-StringRef RuntimePredicate::_get_string_ref(const Field& field, const
PrimitiveType type) {
- switch (type) {
- case PrimitiveType::TYPE_BOOLEAN: {
- const auto& v = field.get<TYPE_BOOLEAN>();
- return StringRef((char*)&v, sizeof(v));
- }
- case PrimitiveType::TYPE_TINYINT: {
- const auto& v = field.get<TYPE_TINYINT>();
- return StringRef((char*)&v, sizeof(v));
- }
- case PrimitiveType::TYPE_SMALLINT: {
- const auto& v = field.get<TYPE_SMALLINT>();
- return StringRef((char*)&v, sizeof(v));
- }
- case PrimitiveType::TYPE_INT: {
- const auto& v = field.get<TYPE_INT>();
- return StringRef((char*)&v, sizeof(v));
- }
- case PrimitiveType::TYPE_BIGINT: {
- const auto& v = field.get<TYPE_BIGINT>();
- return StringRef((char*)&v, sizeof(v));
- }
- case PrimitiveType::TYPE_LARGEINT: {
- const auto& v = field.get<TYPE_LARGEINT>();
- return StringRef((char*)&v, sizeof(v));
- }
- case PrimitiveType::TYPE_CHAR:
- case PrimitiveType::TYPE_VARCHAR:
- case PrimitiveType::TYPE_STRING: {
- const auto& v = field.get<TYPE_STRING>();
- auto length = v.size();
- char* buffer = _predicate_arena.alloc(length);
- memset(buffer, 0, length);
- memcpy(buffer, v.data(), v.length());
-
- return {buffer, length};
- }
- case PrimitiveType::TYPE_DATEV2: {
- const auto& v = field.get<TYPE_DATEV2>();
- return StringRef((char*)&v, sizeof(v));
- }
- case PrimitiveType::TYPE_DATETIMEV2: {
- const auto& v = field.get<TYPE_DATETIMEV2>();
- return StringRef((char*)&v, sizeof(v));
- }
- case PrimitiveType::TYPE_TIMESTAMPTZ: {
- const auto& v = field.get<TYPE_TIMESTAMPTZ>();
- return StringRef((char*)&v, sizeof(v));
- break;
- }
- case PrimitiveType::TYPE_DATE: {
- const auto& v = field.get<TYPE_DATE>();
- return StringRef((char*)&v, sizeof(v));
- }
- case PrimitiveType::TYPE_DATETIME: {
- const auto& v = field.get<TYPE_DATETIME>();
- return StringRef((char*)&v, sizeof(v));
- }
- case PrimitiveType::TYPE_TIMEV2: {
- const auto& v = field.get<TYPE_TIMEV2>();
- return StringRef((char*)&v, sizeof(v));
- }
- case PrimitiveType::TYPE_DECIMAL32: {
- const auto& v = field.get<TYPE_DECIMAL32>();
- return StringRef((char*)&v, sizeof(v));
- }
- case PrimitiveType::TYPE_DECIMAL64: {
- const auto& v = field.get<TYPE_DECIMAL64>();
- return StringRef((char*)&v, sizeof(v));
- }
- case PrimitiveType::TYPE_DECIMALV2: {
- const auto& v = field.get<TYPE_DECIMALV2>();
- return StringRef((char*)&v, sizeof(v));
- }
- case PrimitiveType::TYPE_DECIMAL128I: {
- const auto& v = field.get<TYPE_DECIMAL128I>();
- return StringRef((char*)&v, sizeof(v));
- }
- case PrimitiveType::TYPE_DECIMAL256: {
- const auto& v = field.get<TYPE_DECIMAL256>();
- return StringRef((char*)&v, sizeof(v));
- }
- case PrimitiveType::TYPE_IPV4: {
- const auto& v = field.get<TYPE_IPV4>();
- return StringRef((char*)&v, sizeof(v));
- }
- case PrimitiveType::TYPE_IPV6: {
- const auto& v = field.get<TYPE_IPV6>();
- return StringRef((char*)&v, sizeof(v));
- }
- case doris::PrimitiveType::TYPE_VARBINARY: {
- const auto& v = field.get<TYPE_VARBINARY>();
- auto length = v.size();
- char* buffer = _predicate_arena.alloc(length);
- memset(buffer, 0, length);
- memcpy(buffer, v.data(), length);
- return {buffer, length};
- }
- default:
- break;
- }
-
- throw Exception(ErrorCode::INTERNAL_ERROR, "meet invalid type, type={}",
type_to_string(type));
- return {};
-}
-
bool RuntimePredicate::_init(PrimitiveType type) {
return is_int_or_bool(type) || is_decimal(type) || is_string_type(type) ||
is_date_type(type) ||
is_time_type(type) || is_ip(type) || is_varbinary(type);
@@ -233,10 +127,9 @@ Status RuntimePredicate::update(const Field& value) {
//) ORDER BY 1 LIMIT 1 ;
continue;
}
- auto str_ref = _get_string_ref(_orderby_extrem, _type);
std::shared_ptr<ColumnPredicate> pred =
_pred_constructor(ctx.predicate->column_id(), ctx.col_name,
ctx.col_data_type,
- str_ref, false, _predicate_arena);
+ _orderby_extrem, false);
// For NULLS FIRST, wrap a AcceptNullPredicate to return true for NULL
// since ORDER BY ASC/DESC should get NULL first but pred returns NULL
diff --git a/be/src/runtime/runtime_predicate.h
b/be/src/runtime/runtime_predicate.h
index 632c6bfb78d..c9a68e8ffba 100644
--- a/be/src/runtime/runtime_predicate.h
+++ b/be/src/runtime/runtime_predicate.h
@@ -98,7 +98,6 @@ public:
}
private:
- StringRef _get_string_ref(const Field& field, const PrimitiveType type);
void check_target_node_id(int32_t target_node_id) const {
if (!_contexts.contains(target_node_id)) {
std::string msg = "context target node ids: [";
@@ -136,10 +135,9 @@ private:
std::map<int32_t, TargetContext> _contexts;
Field _orderby_extrem {PrimitiveType::TYPE_NULL};
- Arena _predicate_arena;
- std::function<std::shared_ptr<ColumnPredicate>(
- const int cid, const std::string& col_name, const
vectorized::DataTypePtr& data_type,
- StringRef& value, bool opposite, vectorized::Arena& arena)>
+ std::function<std::shared_ptr<ColumnPredicate>(const int cid, const
std::string& col_name,
+ const
vectorized::DataTypePtr& data_type,
+ const vectorized::Field&
value, bool opposite)>
_pred_constructor;
bool _detected_source = false;
bool _detected_target = false;
diff --git a/be/src/runtime/type_limit.h b/be/src/runtime/type_limit.h
index 02e455e49d0..202455d5327 100644
--- a/be/src/runtime/type_limit.h
+++ b/be/src/runtime/type_limit.h
@@ -36,6 +36,12 @@ struct type_limit<StringRef> {
static StringRef max() { return StringRef::max_string_val(); }
};
+template <>
+struct type_limit<std::string> {
+ static std::string min() { return
std::string((char*)(&StringRef::MIN_CHAR), 0); }
+ static std::string max() { return
std::string((char*)(&StringRef::MAX_CHAR), 1); }
+};
+
template <>
struct type_limit<uint8_t> {
static uint8_t min() { return 0; }
diff --git a/be/test/olap/block_column_predicate_test.cpp
b/be/test/olap/block_column_predicate_test.cpp
index 6ad31db343c..2a387236af2 100644
--- a/be/test/olap/block_column_predicate_test.cpp
+++ b/be/test/olap/block_column_predicate_test.cpp
@@ -79,7 +79,7 @@ TEST_F(BlockColumnPredicateTest, SINGLE_COLUMN_VEC) {
vectorized::MutableColumns block;
block.push_back(vectorized::PredicateColumnType<TYPE_INT>::create());
- int value = 5;
+ auto value = vectorized::Field::create_field<TYPE_INT>(5);
int rows = 10;
int col_idx = 0;
std::shared_ptr<ColumnPredicate> pred(
@@ -99,15 +99,15 @@ TEST_F(BlockColumnPredicateTest, SINGLE_COLUMN_VEC) {
EXPECT_EQ(selected_size, 1);
auto* pred_col =
reinterpret_cast<vectorized::PredicateColumnType<TYPE_INT>*>(block[col_idx].get());
- EXPECT_EQ(pred_col->get_data()[sel_idx[0]], value);
+ EXPECT_EQ(pred_col->get_data()[sel_idx[0]], value.template
get<TYPE_INT>());
}
TEST_F(BlockColumnPredicateTest, AND_MUTI_COLUMN_VEC) {
vectorized::MutableColumns block;
block.push_back(vectorized::PredicateColumnType<TYPE_INT>::create());
- int less_value = 5;
- int great_value = 3;
+ auto less_value = vectorized::Field::create_field<TYPE_INT>(5);
+ auto great_value = vectorized::Field::create_field<TYPE_INT>(3);
int rows = 10;
int col_idx = 0;
std::shared_ptr<ColumnPredicate> less_pred(
@@ -141,8 +141,8 @@ TEST_F(BlockColumnPredicateTest, OR_MUTI_COLUMN_VEC) {
vectorized::MutableColumns block;
block.push_back(vectorized::PredicateColumnType<TYPE_INT>::create());
- int less_value = 5;
- int great_value = 3;
+ auto less_value = vectorized::Field::create_field<TYPE_INT>(5);
+ auto great_value = vectorized::Field::create_field<TYPE_INT>(3);
int rows = 10;
int col_idx = 0;
std::shared_ptr<ColumnPredicate> less_pred(
@@ -176,8 +176,8 @@ TEST_F(BlockColumnPredicateTest, OR_AND_MUTI_COLUMN_VEC) {
vectorized::MutableColumns block;
block.push_back(vectorized::PredicateColumnType<TYPE_INT>::create());
- int less_value = 5;
- int great_value = 3;
+ auto less_value = vectorized::Field::create_field<TYPE_INT>(5);
+ auto great_value = vectorized::Field::create_field<TYPE_INT>(3);
int rows = 10;
int col_idx = 0;
std::shared_ptr<ColumnPredicate> less_pred(
@@ -243,8 +243,8 @@ TEST_F(BlockColumnPredicateTest, AND_OR_MUTI_COLUMN_VEC) {
vectorized::MutableColumns block;
block.push_back(vectorized::PredicateColumnType<TYPE_INT>::create());
- int less_value = 5;
- int great_value = 3;
+ auto less_value = vectorized::Field::create_field<TYPE_INT>(5);
+ auto great_value = vectorized::Field::create_field<TYPE_INT>(3);
int rows = 10;
int col_idx = 0;
std::shared_ptr<ColumnPredicate> less_pred(
@@ -302,8 +302,19 @@ TEST_F(BlockColumnPredicateTest, AND_OR_MUTI_COLUMN_VEC) {
template <PrimitiveType T, PredicateType PT>
void single_column_predicate_test_func(const std::pair<WrapperField*,
WrapperField*>& statistic,
- typename
PrimitiveTypeTraits<T>::CppType check_value,
- bool expect_match) {
+ vectorized::Field& check_value, bool
expect_match) {
+ int col_idx = 0;
+ std::shared_ptr<ColumnPredicate> pred(
+ new ComparisonPredicateBase<T, PT>(col_idx, "", check_value));
+ SingleColumnBlockPredicate single_column_block_pred(pred);
+
+ bool matched = single_column_block_pred.evaluate_and(statistic);
+ EXPECT_EQ(matched, expect_match);
+}
+
+template <PrimitiveType T, PredicateType PT>
+void single_column_predicate_test_func(const std::pair<WrapperField*,
WrapperField*>& statistic,
+ vectorized::Field&& check_value, bool
expect_match) {
int col_idx = 0;
std::shared_ptr<ColumnPredicate> pred(
new ComparisonPredicateBase<T, PT>(col_idx, "", check_value));
@@ -318,17 +329,20 @@ TEST_F(BlockColumnPredicateTest,
test_double_single_column_predicate) {
FieldType type = FieldType::OLAP_FIELD_TYPE_DOUBLE;
std::unique_ptr<WrapperField> min_field(WrapperField::create_by_type(type,
0));
std::unique_ptr<WrapperField> max_field(WrapperField::create_by_type(type,
0));
- static auto constexpr nan = std::numeric_limits<double>::quiet_NaN();
- static auto constexpr neg_inf = -std::numeric_limits<double>::infinity();
- static auto constexpr pos_inf = std::numeric_limits<double>::infinity();
- static auto constexpr min = std::numeric_limits<double>::lowest();
- static auto constexpr max = std::numeric_limits<double>::max();
+ auto nan =
+
vectorized::Field::create_field<TYPE_DOUBLE>(std::numeric_limits<double>::quiet_NaN());
+ auto neg_inf =
+
vectorized::Field::create_field<TYPE_DOUBLE>(-std::numeric_limits<double>::infinity());
+ auto pos_inf =
+
vectorized::Field::create_field<TYPE_DOUBLE>(std::numeric_limits<double>::infinity());
+ auto min =
vectorized::Field::create_field<TYPE_DOUBLE>(std::numeric_limits<double>::lowest());
+ auto max =
vectorized::Field::create_field<TYPE_DOUBLE>(std::numeric_limits<double>::max());
// test normal value min max:
{
std::cout << "========test normal value min max\n";
- double zonemap_min_v = std::numeric_limits<float>::lowest();
- double zonemap_max_v = std::numeric_limits<float>::max();
+ double zonemap_min_v = std::numeric_limits<double>::lowest();
+ double zonemap_max_v = std::numeric_limits<double>::max();
min_field->set_raw_value(&zonemap_min_v, sizeof(zonemap_min_v));
max_field->set_raw_value(&zonemap_max_v, sizeof(zonemap_max_v));
@@ -374,9 +388,13 @@ TEST_F(BlockColumnPredicateTest,
test_double_single_column_predicate) {
single_column_predicate_test_func<TYPE_DOUBLE, PredicateType::LE>(
{min_field.get(), max_field.get()}, neg_inf, false);
- std::vector<double> test_values_in_range = {
- zonemap_min_v, zonemap_max_v, -123456.789012345, -0.0, 0.0,
123456.789012345,
- };
+ std::vector<vectorized::Field> test_values_in_range = {
+ vectorized::Field::create_field<TYPE_DOUBLE>(zonemap_min_v),
+ vectorized::Field::create_field<TYPE_DOUBLE>(zonemap_max_v),
+
vectorized::Field::create_field<TYPE_DOUBLE>(-123456.789012345),
+ vectorized::Field::create_field<TYPE_DOUBLE>(-0.0),
+ vectorized::Field::create_field<TYPE_DOUBLE>(0.0),
+
vectorized::Field::create_field<TYPE_DOUBLE>(123456.789012345)};
for (auto v : test_values_in_range) {
// test EQ
// std::cout << "test double EQ value: " << v << std::endl;
@@ -390,7 +408,8 @@ TEST_F(BlockColumnPredicateTest,
test_double_single_column_predicate) {
// test LT
// std::cout << "test double LT value: " << v << std::endl;
single_column_predicate_test_func<TYPE_DOUBLE, PredicateType::LT>(
- {min_field.get(), max_field.get()}, v, v != zonemap_min_v);
+ {min_field.get(), max_field.get()}, v,
+ v.template get<TYPE_DOUBLE>() != zonemap_min_v);
// test LE
// std::cout << "test double LE value: " << v << std::endl;
@@ -400,7 +419,8 @@ TEST_F(BlockColumnPredicateTest,
test_double_single_column_predicate) {
// test GT
// std::cout << "test double GT value: " << v << std::endl;
single_column_predicate_test_func<TYPE_DOUBLE, PredicateType::GT>(
- {min_field.get(), max_field.get()}, v, v != zonemap_max_v);
+ {min_field.get(), max_field.get()}, v,
+ v.template get<TYPE_DOUBLE>() != zonemap_max_v);
// test GE
// std::cout << "test double GE value: " << v << std::endl;
@@ -410,7 +430,7 @@ TEST_F(BlockColumnPredicateTest,
test_double_single_column_predicate) {
// test values out of zonemap range
{
- double v = zonemap_min_v * 2;
+ auto v =
vectorized::Field::create_field<TYPE_DOUBLE>(zonemap_min_v * 2);
// test EQ
// std::cout << "test double EQ value: " << v << std::endl;
single_column_predicate_test_func<TYPE_DOUBLE, PredicateType::EQ>(
@@ -441,7 +461,7 @@ TEST_F(BlockColumnPredicateTest,
test_double_single_column_predicate) {
{min_field.get(), max_field.get()}, v, true);
}
{
- double v = zonemap_max_v * 2;
+ auto v =
vectorized::Field::create_field<TYPE_DOUBLE>(zonemap_max_v * 2);
// test EQ
// std::cout << "test double EQ value: " << v << std::endl;
single_column_predicate_test_func<TYPE_DOUBLE, PredicateType::EQ>(
@@ -475,9 +495,9 @@ TEST_F(BlockColumnPredicateTest,
test_double_single_column_predicate) {
// test special range: [normal, +Infinity]
{
std::cout << "========test special range: [normal, +Infinity]\n";
- double zonemap_min_v = std::numeric_limits<float>::lowest();
- min_field->set_raw_value(&zonemap_min_v, sizeof(zonemap_min_v));
- max_field->set_raw_value(&pos_inf, sizeof(pos_inf));
+ double zonemap_min_v = std::numeric_limits<double>::lowest();
+ min_field->set_raw_value(&zonemap_min_v, sizeof(double));
+ max_field->set_raw_value(&pos_inf.template get<TYPE_DOUBLE>(),
sizeof(double));
// test NaN
single_column_predicate_test_func<TYPE_DOUBLE, PredicateType::EQ>(
@@ -521,8 +541,14 @@ TEST_F(BlockColumnPredicateTest,
test_double_single_column_predicate) {
single_column_predicate_test_func<TYPE_DOUBLE, PredicateType::LE>(
{min_field.get(), max_field.get()}, neg_inf, false);
- std::vector<double> test_values_in_range = {
- zonemap_min_v, max, pos_inf, -123456.789012345, -0.0, 0.0,
123456.789012345,
+ std::vector<vectorized::Field> test_values_in_range = {
+ vectorized::Field::create_field<TYPE_DOUBLE>(zonemap_min_v),
+ max,
+ pos_inf,
+
vectorized::Field::create_field<TYPE_DOUBLE>(-123456.789012345),
+ vectorized::Field::create_field<TYPE_DOUBLE>(-0.0),
+ vectorized::Field::create_field<TYPE_DOUBLE>(0.0),
+ vectorized::Field::create_field<TYPE_DOUBLE>(123456.789012345),
};
for (auto v : test_values_in_range) {
// test EQ
@@ -537,7 +563,8 @@ TEST_F(BlockColumnPredicateTest,
test_double_single_column_predicate) {
// test LT
// std::cout << "test double LT value: " << v << std::endl;
single_column_predicate_test_func<TYPE_DOUBLE, PredicateType::LT>(
- {min_field.get(), max_field.get()}, v, v != zonemap_min_v);
+ {min_field.get(), max_field.get()}, v,
+ v.template get<TYPE_DOUBLE>() != zonemap_min_v);
// test LE
// std::cout << "test double LE value: " << v << std::endl;
@@ -547,7 +574,8 @@ TEST_F(BlockColumnPredicateTest,
test_double_single_column_predicate) {
// test GT
// std::cout << "test double GT value: " << v << std::endl;
single_column_predicate_test_func<TYPE_DOUBLE, PredicateType::GT>(
- {min_field.get(), max_field.get()}, v, v != pos_inf);
+ {min_field.get(), max_field.get()}, v,
+ v.template get<TYPE_DOUBLE>() != pos_inf.template
get<TYPE_DOUBLE>());
// test GE
// std::cout << "test double GE value: " << v << std::endl;
@@ -557,7 +585,7 @@ TEST_F(BlockColumnPredicateTest,
test_double_single_column_predicate) {
// test values out of zonemap range
{
- double v = zonemap_min_v * 2;
+ auto v =
vectorized::Field::create_field<TYPE_DOUBLE>(zonemap_min_v * 2);
// test EQ
// std::cout << "test double EQ value: " << v << std::endl;
single_column_predicate_test_func<TYPE_DOUBLE, PredicateType::EQ>(
@@ -591,9 +619,9 @@ TEST_F(BlockColumnPredicateTest,
test_double_single_column_predicate) {
// test special range: [-Infinity, normal]
{
std::cout << "========test special range: [-Infinity, normal]\n";
- double zonemap_max_v = std::numeric_limits<float>::max();
- min_field->set_raw_value(&neg_inf, sizeof(neg_inf));
- max_field->set_raw_value(&zonemap_max_v, sizeof(zonemap_max_v));
+ double zonemap_max_v = std::numeric_limits<double>::max();
+ min_field->set_raw_value(&neg_inf.template get<TYPE_DOUBLE>(),
sizeof(double));
+ max_field->set_raw_value(&zonemap_max_v, sizeof(double));
// test NaN
single_column_predicate_test_func<TYPE_DOUBLE, PredicateType::EQ>(
@@ -637,8 +665,14 @@ TEST_F(BlockColumnPredicateTest,
test_double_single_column_predicate) {
single_column_predicate_test_func<TYPE_DOUBLE, PredicateType::LE>(
{min_field.get(), max_field.get()}, neg_inf, true);
- std::vector<double> test_values_in_range = {
- neg_inf, min, zonemap_max_v, -123456.789012345, -0.0, 0.0,
123456.789012345,
+ std::vector<vectorized::Field> test_values_in_range = {
+ neg_inf,
+ min,
+ vectorized::Field::create_field<TYPE_DOUBLE>(zonemap_max_v),
+
vectorized::Field::create_field<TYPE_DOUBLE>(-123456.789012345),
+ vectorized::Field::create_field<TYPE_DOUBLE>(-0.0),
+ vectorized::Field::create_field<TYPE_DOUBLE>(0.0),
+ vectorized::Field::create_field<TYPE_DOUBLE>(123456.789012345),
};
for (auto v : test_values_in_range) {
// test EQ
@@ -663,7 +697,8 @@ TEST_F(BlockColumnPredicateTest,
test_double_single_column_predicate) {
// test GT
// std::cout << "test double GT value: " << v << std::endl;
single_column_predicate_test_func<TYPE_DOUBLE, PredicateType::GT>(
- {min_field.get(), max_field.get()}, v, v != zonemap_max_v);
+ {min_field.get(), max_field.get()}, v,
+ v.template get<TYPE_DOUBLE>() != zonemap_max_v);
// test GE
// std::cout << "test double GE value: " << v << std::endl;
@@ -672,7 +707,7 @@ TEST_F(BlockColumnPredicateTest,
test_double_single_column_predicate) {
}
// test values out of zonemap range
{
- double v = zonemap_max_v * 2;
+ auto v =
vectorized::Field::create_field<TYPE_DOUBLE>(zonemap_max_v * 2);
// test EQ
// std::cout << "test double EQ value: " << v << std::endl;
single_column_predicate_test_func<TYPE_DOUBLE, PredicateType::EQ>(
@@ -706,9 +741,9 @@ TEST_F(BlockColumnPredicateTest,
test_double_single_column_predicate) {
// test special range: [normal, NaN]
{
std::cout << "========test special range: [normal, NaN]\n";
- double zonemap_min_v = std::numeric_limits<float>::lowest();
- min_field->set_raw_value(&zonemap_min_v, sizeof(zonemap_min_v));
- max_field->set_raw_value(&nan, sizeof(nan));
+ double zonemap_min_v = std::numeric_limits<double>::lowest();
+ min_field->set_raw_value(&zonemap_min_v, sizeof(double));
+ max_field->set_raw_value(&nan.template get<TYPE_DOUBLE>(),
sizeof(double));
// test NaN
single_column_predicate_test_func<TYPE_DOUBLE, PredicateType::EQ>(
@@ -752,8 +787,14 @@ TEST_F(BlockColumnPredicateTest,
test_double_single_column_predicate) {
single_column_predicate_test_func<TYPE_DOUBLE, PredicateType::LE>(
{min_field.get(), max_field.get()}, neg_inf, false);
- std::vector<double> test_values_in_range = {
- zonemap_min_v, max, pos_inf, -123456.789012345, -0.0, 0.0,
123456.789012345,
+ std::vector<vectorized::Field> test_values_in_range = {
+ vectorized::Field::create_field<TYPE_DOUBLE>(zonemap_min_v),
+ max,
+ pos_inf,
+
vectorized::Field::create_field<TYPE_DOUBLE>(-123456.789012345),
+ vectorized::Field::create_field<TYPE_DOUBLE>(-0.0),
+ vectorized::Field::create_field<TYPE_DOUBLE>(0.0),
+ vectorized::Field::create_field<TYPE_DOUBLE>(123456.789012345),
};
for (auto v : test_values_in_range) {
// test EQ
@@ -768,7 +809,8 @@ TEST_F(BlockColumnPredicateTest,
test_double_single_column_predicate) {
// test LT
// std::cout << "test double LT value: " << v << std::endl;
single_column_predicate_test_func<TYPE_DOUBLE, PredicateType::LT>(
- {min_field.get(), max_field.get()}, v, v != zonemap_min_v);
+ {min_field.get(), max_field.get()}, v,
+ v.template get<TYPE_DOUBLE>() != zonemap_min_v);
// test LE
// std::cout << "test double LE value: " << v << std::endl;
@@ -778,7 +820,8 @@ TEST_F(BlockColumnPredicateTest,
test_double_single_column_predicate) {
// test GT
// std::cout << "test double GT value: " << v << std::endl;
single_column_predicate_test_func<TYPE_DOUBLE, PredicateType::GT>(
- {min_field.get(), max_field.get()}, v, !std::isnan(v));
+ {min_field.get(), max_field.get()}, v,
+ !std::isnan(v.template get<TYPE_DOUBLE>()));
// test GE
// std::cout << "test double GE value: " << v << std::endl;
@@ -788,7 +831,7 @@ TEST_F(BlockColumnPredicateTest,
test_double_single_column_predicate) {
// test values out of zonemap range
{
- double v = zonemap_min_v * 2;
+ auto v =
vectorized::Field::create_field<TYPE_DOUBLE>(zonemap_min_v * 2);
// test EQ
// std::cout << "test double EQ value: " << v << std::endl;
single_column_predicate_test_func<TYPE_DOUBLE, PredicateType::EQ>(
@@ -822,8 +865,8 @@ TEST_F(BlockColumnPredicateTest,
test_double_single_column_predicate) {
// test special range: [-Infinity, +Infinity]
{
std::cout << "========test special range: [-Infinity, +Infinity]\n";
- min_field->set_raw_value(&neg_inf, sizeof(neg_inf));
- max_field->set_raw_value(&pos_inf, sizeof(pos_inf));
+ min_field->set_raw_value(&neg_inf.template get<TYPE_DOUBLE>(),
sizeof(double));
+ max_field->set_raw_value(&pos_inf.template get<TYPE_DOUBLE>(),
sizeof(double));
// test NaN
single_column_predicate_test_func<TYPE_DOUBLE, PredicateType::EQ>(
@@ -867,8 +910,13 @@ TEST_F(BlockColumnPredicateTest,
test_double_single_column_predicate) {
single_column_predicate_test_func<TYPE_DOUBLE, PredicateType::LE>(
{min_field.get(), max_field.get()}, neg_inf, true);
- std::vector<double> test_values_in_range = {
- min, max, -123456.789012345, -0.0, 0.0, 123456.789012345,
+ std::vector<vectorized::Field> test_values_in_range = {
+ min,
+ max,
+
vectorized::Field::create_field<TYPE_DOUBLE>(-123456.789012345),
+ vectorized::Field::create_field<TYPE_DOUBLE>(-0.0),
+ vectorized::Field::create_field<TYPE_DOUBLE>(0.0),
+ vectorized::Field::create_field<TYPE_DOUBLE>(123456.789012345),
};
for (auto v : test_values_in_range) {
// test EQ
@@ -904,8 +952,8 @@ TEST_F(BlockColumnPredicateTest,
test_double_single_column_predicate) {
// test special range: [-Infinity, NaN]
{
std::cout << "========test special range: [-Infinity, NaN]\n";
- min_field->set_raw_value(&neg_inf, sizeof(neg_inf));
- max_field->set_raw_value(&nan, sizeof(nan));
+ min_field->set_raw_value(&neg_inf.template get<TYPE_DOUBLE>(),
sizeof(double));
+ max_field->set_raw_value(&nan.template get<TYPE_DOUBLE>(),
sizeof(double));
// test NaN
single_column_predicate_test_func<TYPE_DOUBLE, PredicateType::EQ>(
@@ -949,8 +997,13 @@ TEST_F(BlockColumnPredicateTest,
test_double_single_column_predicate) {
single_column_predicate_test_func<TYPE_DOUBLE, PredicateType::LE>(
{min_field.get(), max_field.get()}, neg_inf, true);
- std::vector<double> test_values_in_range = {
- min, max, -123456.789012345, -0.0, 0.0, 123456.789012345,
+ std::vector<vectorized::Field> test_values_in_range = {
+ min,
+ max,
+
vectorized::Field::create_field<TYPE_DOUBLE>(-123456.789012345),
+ vectorized::Field::create_field<TYPE_DOUBLE>(-0.0),
+ vectorized::Field::create_field<TYPE_DOUBLE>(0.0),
+ vectorized::Field::create_field<TYPE_DOUBLE>(123456.789012345),
};
for (auto v : test_values_in_range) {
// std::cout << "test double EQ value: " << v << std::endl;
@@ -980,8 +1033,8 @@ TEST_F(BlockColumnPredicateTest,
test_double_single_column_predicate) {
// test special range: [-Infinity, -Infinity]
{
std::cout << "========test special range: [-Infinity, -Infinity]\n";
- min_field->set_raw_value(&neg_inf, sizeof(neg_inf));
- max_field->set_raw_value(&neg_inf, sizeof(neg_inf));
+ min_field->set_raw_value(&neg_inf.template get<TYPE_DOUBLE>(),
sizeof(double));
+ max_field->set_raw_value(&neg_inf.template get<TYPE_DOUBLE>(),
sizeof(double));
// test NaN
single_column_predicate_test_func<TYPE_DOUBLE, PredicateType::EQ>(
@@ -1025,8 +1078,13 @@ TEST_F(BlockColumnPredicateTest,
test_double_single_column_predicate) {
single_column_predicate_test_func<TYPE_DOUBLE, PredicateType::LE>(
{min_field.get(), max_field.get()}, neg_inf, true);
- std::vector<double> test_values_not_in_range = {
- min, max, -123456.789012345, -0.0, 0.0, 123456.789012345,
+ std::vector<vectorized::Field> test_values_not_in_range = {
+ min,
+ max,
+
vectorized::Field::create_field<TYPE_DOUBLE>(-123456.789012345),
+ vectorized::Field::create_field<TYPE_DOUBLE>(-0.0),
+ vectorized::Field::create_field<TYPE_DOUBLE>(0.0),
+ vectorized::Field::create_field<TYPE_DOUBLE>(123456.789012345),
};
for (auto v : test_values_not_in_range) {
// std::cout << "test double EQ value: " << v << std::endl;
@@ -1056,8 +1114,8 @@ TEST_F(BlockColumnPredicateTest,
test_double_single_column_predicate) {
// test special range: [+Infinity, +Infinity]
{
std::cout << "========test special range: [+Infinity, +Infinity]\n";
- min_field->set_raw_value(&pos_inf, sizeof(pos_inf));
- max_field->set_raw_value(&pos_inf, sizeof(pos_inf));
+ min_field->set_raw_value(&pos_inf.template get<TYPE_DOUBLE>(),
sizeof(double));
+ max_field->set_raw_value(&pos_inf.template get<TYPE_DOUBLE>(),
sizeof(double));
// test NaN
std::cout << "========test NaN\n";
@@ -1105,8 +1163,13 @@ TEST_F(BlockColumnPredicateTest,
test_double_single_column_predicate) {
{min_field.get(), max_field.get()}, neg_inf, false);
std::cout << "========test values not in range\n";
- std::vector<double> test_values_not_in_range = {
- min, max, -123456.789012345, -0.0, 0.0, 123456.789012345,
+ std::vector<vectorized::Field> test_values_not_in_range = {
+ min,
+ max,
+
vectorized::Field::create_field<TYPE_DOUBLE>(-123456.789012345),
+ vectorized::Field::create_field<TYPE_DOUBLE>(-0.0),
+ vectorized::Field::create_field<TYPE_DOUBLE>(0.0),
+ vectorized::Field::create_field<TYPE_DOUBLE>(123456.789012345),
};
for (auto v : test_values_not_in_range) {
// std::cout << "test double EQ value: " << v << std::endl;
@@ -1136,8 +1199,8 @@ TEST_F(BlockColumnPredicateTest,
test_double_single_column_predicate) {
// test special range: [NaN, NaN]
{
std::cout << "========test special range: [NaN, NaN]\n";
- min_field->set_raw_value(&nan, sizeof(nan));
- max_field->set_raw_value(&nan, sizeof(nan));
+ min_field->set_raw_value(&nan.template get<TYPE_DOUBLE>(),
sizeof(double));
+ max_field->set_raw_value(&nan.template get<TYPE_DOUBLE>(),
sizeof(double));
// test NaN
single_column_predicate_test_func<TYPE_DOUBLE, PredicateType::EQ>(
@@ -1181,8 +1244,13 @@ TEST_F(BlockColumnPredicateTest,
test_double_single_column_predicate) {
single_column_predicate_test_func<TYPE_DOUBLE, PredicateType::LE>(
{min_field.get(), max_field.get()}, neg_inf, false);
- std::vector<double> test_values_not_in_range = {
- min, max, -123456.789012345, -0.0, 0.0, 123456.789012345,
+ std::vector<vectorized::Field> test_values_not_in_range = {
+ min,
+ max,
+
vectorized::Field::create_field<TYPE_DOUBLE>(-123456.789012345),
+ vectorized::Field::create_field<TYPE_DOUBLE>(-0.0),
+ vectorized::Field::create_field<TYPE_DOUBLE>(0.0),
+ vectorized::Field::create_field<TYPE_DOUBLE>(123456.789012345),
};
for (auto v : test_values_not_in_range) {
// std::cout << "test double EQ value: " << v << std::endl;
@@ -1243,21 +1311,28 @@ TEST_F(BlockColumnPredicateTest,
test_timestamptz_zonemap_index) {
TimestampTzValue tz {};
EXPECT_TRUE(tz.from_string(StringRef {str}, &time_zone, params,
0));
single_column_predicate_test_func<TYPE_TIMESTAMPTZ,
PredicateType::EQ>(
- {min_field.get(), max_field.get()}, tz, true);
+ {min_field.get(), max_field.get()},
+ vectorized::Field::create_field<TYPE_TIMESTAMPTZ>(tz),
true);
single_column_predicate_test_func<TYPE_TIMESTAMPTZ,
PredicateType::NE>(
- {min_field.get(), max_field.get()}, tz, true);
+ {min_field.get(), max_field.get()},
+ vectorized::Field::create_field<TYPE_TIMESTAMPTZ>(tz),
true);
single_column_predicate_test_func<TYPE_TIMESTAMPTZ,
PredicateType::LT>(
- {min_field.get(), max_field.get()}, tz, tz !=
zonemap_min_v);
+ {min_field.get(), max_field.get()},
+ vectorized::Field::create_field<TYPE_TIMESTAMPTZ>(tz), tz
!= zonemap_min_v);
single_column_predicate_test_func<TYPE_TIMESTAMPTZ,
PredicateType::LE>(
- {min_field.get(), max_field.get()}, tz, true);
+ {min_field.get(), max_field.get()},
+ vectorized::Field::create_field<TYPE_TIMESTAMPTZ>(tz),
true);
single_column_predicate_test_func<TYPE_TIMESTAMPTZ,
PredicateType::GT>(
- {min_field.get(), max_field.get()}, tz, tz !=
zonemap_max_v);
+ {min_field.get(), max_field.get()},
+ vectorized::Field::create_field<TYPE_TIMESTAMPTZ>(tz), tz
!= zonemap_max_v);
single_column_predicate_test_func<TYPE_TIMESTAMPTZ,
PredicateType::GE>(
- {min_field.get(), max_field.get()}, tz, true);
+ {min_field.get(), max_field.get()},
+ vectorized::Field::create_field<TYPE_TIMESTAMPTZ>(tz),
true);
}
// test values out of zonemap range
{
- auto v = type_limit<TimestampTzValue>::min();
+ auto v = vectorized::Field::create_field<TYPE_TIMESTAMPTZ>(
+ type_limit<TimestampTzValue>::min());
single_column_predicate_test_func<TYPE_TIMESTAMPTZ,
PredicateType::EQ>(
{min_field.get(), max_field.get()}, v, false);
single_column_predicate_test_func<TYPE_TIMESTAMPTZ,
PredicateType::NE>(
@@ -1277,7 +1352,8 @@ TEST_F(BlockColumnPredicateTest,
test_timestamptz_zonemap_index) {
}
// test values out of zonemap range
{
- auto v = type_limit<TimestampTzValue>::max();
+ auto v = vectorized::Field::create_field<TYPE_TIMESTAMPTZ>(
+ type_limit<TimestampTzValue>::max());
single_column_predicate_test_func<TYPE_TIMESTAMPTZ,
PredicateType::EQ>(
{min_field.get(), max_field.get()}, v, false);
single_column_predicate_test_func<TYPE_TIMESTAMPTZ,
PredicateType::NE>(
@@ -1312,25 +1388,30 @@ TEST_F(BlockColumnPredicateTest,
test_timestamptz_zonemap_index) {
TimestampTzValue tz {};
EXPECT_TRUE(tz.from_string(StringRef {str}, &time_zone, params,
6));
single_column_predicate_test_func<TYPE_TIMESTAMPTZ,
PredicateType::EQ>(
- {min_field.get(), max_field.get()}, tz, true);
+ {min_field.get(), max_field.get()},
+ vectorized::Field::create_field<TYPE_TIMESTAMPTZ>(tz),
true);
single_column_predicate_test_func<TYPE_TIMESTAMPTZ,
PredicateType::NE>(
- {min_field.get(), max_field.get()}, tz, true);
+ {min_field.get(), max_field.get()},
+ vectorized::Field::create_field<TYPE_TIMESTAMPTZ>(tz),
true);
single_column_predicate_test_func<TYPE_TIMESTAMPTZ,
PredicateType::LT>(
- {min_field.get(), max_field.get()}, tz, tz !=
zonemap_min_v);
+ {min_field.get(), max_field.get()},
+ vectorized::Field::create_field<TYPE_TIMESTAMPTZ>(tz), tz
!= zonemap_min_v);
single_column_predicate_test_func<TYPE_TIMESTAMPTZ,
PredicateType::LE>(
- {min_field.get(), max_field.get()}, tz, true);
+ {min_field.get(), max_field.get()},
+ vectorized::Field::create_field<TYPE_TIMESTAMPTZ>(tz),
true);
single_column_predicate_test_func<TYPE_TIMESTAMPTZ,
PredicateType::GT>(
- {min_field.get(), max_field.get()}, tz, tz !=
zonemap_max_v);
+ {min_field.get(), max_field.get()},
+ vectorized::Field::create_field<TYPE_TIMESTAMPTZ>(tz), tz
!= zonemap_max_v);
single_column_predicate_test_func<TYPE_TIMESTAMPTZ,
PredicateType::GE>(
- {min_field.get(), max_field.get()}, tz, true);
+ {min_field.get(), max_field.get()},
+ vectorized::Field::create_field<TYPE_TIMESTAMPTZ>(tz),
true);
}
}
}
template <PrimitiveType T, PredicateType PT>
void single_column_predicate_test_func(const segment_v2::BloomFilter* bf,
- typename
PrimitiveTypeTraits<T>::CppType check_value,
- bool expect_match) {
+ vectorized::Field&& check_value, bool
expect_match) {
int col_idx = 0;
std::shared_ptr<ColumnPredicate> pred(
new ComparisonPredicateBase<T, PT>(col_idx, "", check_value));
@@ -1368,26 +1449,29 @@ TEST_F(BlockColumnPredicateTest,
test_timestamptz_bloom_filter) {
}
for (const auto& v : values) {
- single_column_predicate_test_func<TYPE_TIMESTAMPTZ,
PredicateType::EQ>(bf.get(), v, true);
+ single_column_predicate_test_func<TYPE_TIMESTAMPTZ, PredicateType::EQ>(
+ bf.get(),
vectorized::Field::create_field<TYPE_TIMESTAMPTZ>(v), true);
}
{
auto str = "0000-01-01 00:00:00";
TimestampTzValue tz {};
EXPECT_TRUE(tz.from_string(StringRef {str}, &time_zone, params, 0));
- single_column_predicate_test_func<TYPE_TIMESTAMPTZ,
PredicateType::EQ>(bf.get(), tz, false);
+ single_column_predicate_test_func<TYPE_TIMESTAMPTZ, PredicateType::EQ>(
+ bf.get(),
vectorized::Field::create_field<TYPE_TIMESTAMPTZ>(tz), false);
}
{
auto str = "9999-12-31 23:59:59.999999";
TimestampTzValue tz {};
EXPECT_TRUE(tz.from_string(StringRef {str}, &time_zone, params, 6));
- single_column_predicate_test_func<TYPE_TIMESTAMPTZ,
PredicateType::EQ>(bf.get(), tz, false);
+ single_column_predicate_test_func<TYPE_TIMESTAMPTZ, PredicateType::EQ>(
+ bf.get(),
vectorized::Field::create_field<TYPE_TIMESTAMPTZ>(tz), false);
}
}
TEST_F(BlockColumnPredicateTest, PARQUET_COMPARISON_PREDICATE) {
{ // INT
{// EQ
- int value = 5;
+ auto value = vectorized::Field::create_field<TYPE_INT>(5);
int col_idx = 0;
std::shared_ptr<ColumnPredicate> pred(
new ComparisonPredicateBase<TYPE_INT, PredicateType::EQ>(col_idx,
"", value));
@@ -1464,7 +1548,7 @@ TEST_F(BlockColumnPredicateTest,
PARQUET_COMPARISON_PREDICATE) {
}
{
// NE
- int value = 5;
+ auto value = vectorized::Field::create_field<TYPE_INT>(5);
int col_idx = 0;
std::shared_ptr<ColumnPredicate> pred(
new ComparisonPredicateBase<TYPE_INT, PredicateType::NE>(col_idx,
"", value));
@@ -1533,7 +1617,7 @@ TEST_F(BlockColumnPredicateTest,
PARQUET_COMPARISON_PREDICATE) {
}
{
// GE
- int value = 5;
+ auto value = vectorized::Field::create_field<TYPE_INT>(5);
int col_idx = 0;
std::shared_ptr<ColumnPredicate> pred(
new ComparisonPredicateBase<TYPE_INT, PredicateType::GE>(col_idx,
"", value));
@@ -1602,7 +1686,7 @@ TEST_F(BlockColumnPredicateTest,
PARQUET_COMPARISON_PREDICATE) {
}
{
// LE
- int value = 5;
+ auto value = vectorized::Field::create_field<TYPE_INT>(5);
int col_idx = 0;
std::shared_ptr<ColumnPredicate> pred(
new ComparisonPredicateBase<TYPE_INT, PredicateType::LE>(col_idx,
"", value));
@@ -1674,7 +1758,7 @@ TEST_F(BlockColumnPredicateTest,
PARQUET_COMPARISON_PREDICATE) {
// FLOAT
{
// EQ
- float value = 5.0;
+ auto value = vectorized::Field::create_field<TYPE_FLOAT>(5.0);
int col_idx = 0;
std::shared_ptr<ColumnPredicate> pred(
new ComparisonPredicateBase<TYPE_FLOAT,
PredicateType::EQ>(col_idx, "", value));
@@ -1768,7 +1852,7 @@ TEST_F(BlockColumnPredicateTest,
PARQUET_COMPARISON_PREDICATE) {
}
{
// NE
- float value = 5;
+ auto value = vectorized::Field::create_field<TYPE_FLOAT>(5.0);
int col_idx = 0;
std::shared_ptr<ColumnPredicate> pred(
new ComparisonPredicateBase<TYPE_FLOAT,
PredicateType::NE>(col_idx, "", value));
@@ -1837,7 +1921,7 @@ TEST_F(BlockColumnPredicateTest,
PARQUET_COMPARISON_PREDICATE) {
}
{
// GE
- float value = 5.0;
+ auto value = vectorized::Field::create_field<TYPE_FLOAT>(5.0);
int col_idx = 0;
std::shared_ptr<ColumnPredicate> pred(
new ComparisonPredicateBase<TYPE_FLOAT,
PredicateType::GE>(col_idx, "", value));
@@ -1906,7 +1990,7 @@ TEST_F(BlockColumnPredicateTest,
PARQUET_COMPARISON_PREDICATE) {
}
{
// LE
- float value = 5.0;
+ auto value = vectorized::Field::create_field<TYPE_FLOAT>(5.0);
int col_idx = 0;
std::shared_ptr<ColumnPredicate> pred(
new ComparisonPredicateBase<TYPE_FLOAT,
PredicateType::LE>(col_idx, "", value));
@@ -2075,7 +2159,7 @@ TEST_F(BlockColumnPredicateTest, PARQUET_IN_PREDICATE) {
}
TEST_F(BlockColumnPredicateTest, PARQUET_COMPARISON_PREDICATE_BLOOM_FILTER) {
- const int value = 42;
+ auto value = vectorized::Field::create_field<TYPE_INT>(42);
const int col_idx = 0;
std::shared_ptr<ColumnPredicate> pred(
new ComparisonPredicateBase<TYPE_INT, PredicateType::EQ>(col_idx,
"", value));
@@ -2103,8 +2187,8 @@ TEST_F(BlockColumnPredicateTest,
PARQUET_COMPARISON_PREDICATE_BLOOM_FILTER) {
current_stat->col_schema = parquet_field.get();
current_stat->is_all_null = false;
current_stat->has_null = false;
- current_stat->encoded_min_value = encode_value(value);
- current_stat->encoded_max_value = encode_value(value);
+ current_stat->encoded_min_value =
encode_value(value.template get<TYPE_INT>());
+ current_stat->encoded_max_value =
encode_value(value.template get<TYPE_INT>());
return true;
};
stat.get_stat_func = &get_stat_func;
@@ -2121,7 +2205,9 @@ TEST_F(BlockColumnPredicateTest,
PARQUET_COMPARISON_PREDICATE_BLOOM_FILTER) {
current_stat->bloom_filter.get());
Status st = bloom->init(256,
segment_v2::HashStrategyPB::XX_HASH_64);
EXPECT_TRUE(st.ok());
- bloom->add_bytes(reinterpret_cast<const
char*>(&value), sizeof(value));
+ bloom->add_bytes(
+ reinterpret_cast<const char*>(&value.template
get<TYPE_INT>()),
+ sizeof(value.template get<TYPE_INT>()));
}
return true;
};
@@ -2142,8 +2228,8 @@ TEST_F(BlockColumnPredicateTest,
PARQUET_COMPARISON_PREDICATE_BLOOM_FILTER) {
current_stat->col_schema = parquet_field.get();
current_stat->is_all_null = false;
current_stat->has_null = false;
- current_stat->encoded_min_value = encode_value(value);
- current_stat->encoded_max_value = encode_value(value);
+ current_stat->encoded_min_value =
encode_value(value.template get<TYPE_INT>());
+ current_stat->encoded_max_value =
encode_value(value.template get<TYPE_INT>());
return true;
};
stat.get_stat_func = &get_stat_func;
@@ -2160,7 +2246,7 @@ TEST_F(BlockColumnPredicateTest,
PARQUET_COMPARISON_PREDICATE_BLOOM_FILTER) {
current_stat->bloom_filter.get());
Status st = bloom->init(256,
segment_v2::HashStrategyPB::XX_HASH_64);
EXPECT_TRUE(st.ok());
- int other_value = value + 10;
+ int other_value = value.template get<TYPE_INT>() + 10;
bloom->add_bytes(reinterpret_cast<const
char*>(&other_value),
sizeof(other_value));
}
@@ -2183,8 +2269,8 @@ TEST_F(BlockColumnPredicateTest,
PARQUET_COMPARISON_PREDICATE_BLOOM_FILTER) {
current_stat->col_schema = parquet_field.get();
current_stat->is_all_null = false;
current_stat->has_null = false;
- current_stat->encoded_min_value = encode_value(value);
- current_stat->encoded_max_value = encode_value(value);
+ current_stat->encoded_min_value =
encode_value(value.template get<TYPE_INT>());
+ current_stat->encoded_max_value =
encode_value(value.template get<TYPE_INT>());
return true;
};
stat.get_stat_func = &get_stat_func;
@@ -2213,8 +2299,8 @@ TEST_F(BlockColumnPredicateTest,
PARQUET_COMPARISON_PREDICATE_BLOOM_FILTER) {
current_stat->col_schema = parquet_field.get();
current_stat->is_all_null = false;
current_stat->has_null = false;
- int min_value = value + 5;
- int max_value = value + 10;
+ int min_value = value.template get<TYPE_INT>() + 5;
+ int max_value = value.template get<TYPE_INT>() + 10;
current_stat->encoded_min_value = encode_value(min_value);
current_stat->encoded_max_value = encode_value(max_value);
return true;
@@ -2464,7 +2550,7 @@ TEST_F(BlockColumnPredicateTest, COMBINED_PREDICATE) {
std::unique_ptr<SingleColumnBlockPredicate> true_predicate;
int col_idx = 0;
- int value = 5;
+ auto value = vectorized::Field::create_field<TYPE_INT>(5);
std::shared_ptr<ColumnPredicate> pred(
new ComparisonPredicateBase<TYPE_INT,
PredicateType::EQ>(col_idx, "", value));
true_predicate = std::make_unique<SingleColumnBlockPredicate>(pred);
@@ -2509,7 +2595,7 @@ TEST_F(BlockColumnPredicateTest, COMBINED_PREDICATE) {
std::unique_ptr<SingleColumnBlockPredicate> true_predicate;
int col_idx = 0;
- int value = 5;
+ auto value = vectorized::Field::create_field<TYPE_INT>(5);
std::shared_ptr<ColumnPredicate> pred(
new ComparisonPredicateBase<TYPE_INT,
PredicateType::EQ>(col_idx, "", value));
true_predicate = std::make_unique<SingleColumnBlockPredicate>(pred);
@@ -2554,7 +2640,7 @@ TEST_F(BlockColumnPredicateTest, COMBINED_PREDICATE) {
std::unique_ptr<SingleColumnBlockPredicate> true_predicate;
int col_idx = 0;
- int value = 5;
+ auto value = vectorized::Field::create_field<TYPE_INT>(5);
std::shared_ptr<ColumnPredicate> pred(
new ComparisonPredicateBase<TYPE_INT,
PredicateType::EQ>(col_idx, "", value));
true_predicate = std::make_unique<SingleColumnBlockPredicate>(pred);
@@ -2599,7 +2685,7 @@ TEST_F(BlockColumnPredicateTest, COMBINED_PREDICATE) {
std::unique_ptr<SingleColumnBlockPredicate> false_predicate2;
int col_idx = 0;
- int value = 5;
+ auto value = vectorized::Field::create_field<TYPE_INT>(5);
std::shared_ptr<ColumnPredicate> pred(
new ComparisonPredicateBase<TYPE_INT,
PredicateType::NE>(col_idx, "", value));
false_predicate2 = std::make_unique<SingleColumnBlockPredicate>(pred);
@@ -2643,7 +2729,7 @@ TEST_F(BlockColumnPredicateTest, COMBINED_PREDICATE) {
OrBlockColumnPredicate or_block_column_pred;
int col_idx = 0;
- int value = 5;
+ auto value = vectorized::Field::create_field<TYPE_INT>(5);
std::unique_ptr<SingleColumnBlockPredicate> false_predicate;
std::shared_ptr<ColumnPredicate> pred2(
new ComparisonPredicateBase<TYPE_INT,
PredicateType::NE>(col_idx, "", value));
diff --git a/be/test/olap/date_bloom_filter_test.cpp
b/be/test/olap/date_bloom_filter_test.cpp
index b5539fff686..b95697365dd 100644
--- a/be/test/olap/date_bloom_filter_test.cpp
+++ b/be/test/olap/date_bloom_filter_test.cpp
@@ -180,7 +180,8 @@ TEST_F(DateBloomFilterTest, query_index_test) {
auto test = [&](const std::string& query_string, bool result) {
auto date = timestamp_from_date(query_string);
std::unique_ptr<ComparisonPredicateBase<TYPE_DATE,
PredicateType::EQ>> date_pred(
- new ComparisonPredicateBase<TYPE_DATE,
PredicateType::EQ>(0, "", date));
+ new ComparisonPredicateBase<TYPE_DATE, PredicateType::EQ>(
+ 0, "",
vectorized::Field::create_field<TYPE_DATE>(date)));
EXPECT_EQ(date_pred->evaluate_and(bf.get()), result);
};
test("2024-11-08", true);
@@ -202,7 +203,8 @@ TEST_F(DateBloomFilterTest, query_index_test) {
auto test = [&](const std::string& query_string, bool result) {
auto datetime = timestamp_from_datetime(query_string);
std::unique_ptr<ComparisonPredicateBase<TYPE_DATETIME,
PredicateType::EQ>> date_pred(
- new ComparisonPredicateBase<TYPE_DATETIME,
PredicateType::EQ>(0, "", datetime));
+ new ComparisonPredicateBase<TYPE_DATETIME,
PredicateType::EQ>(
+ 0, "",
vectorized::Field::create_field<TYPE_DATETIME>(datetime)));
EXPECT_EQ(date_pred->evaluate_and(bf.get()), result);
};
test("2024-11-08 09:00:00", true);
diff --git a/be/test/vec/exec/format/parquet/parquet_expr_test.cpp
b/be/test/vec/exec/format/parquet/parquet_expr_test.cpp
index c078401dc40..fb3d2754d7f 100644
--- a/be/test/vec/exec/format/parquet/parquet_expr_test.cpp
+++ b/be/test/vec/exec/format/parquet/parquet_expr_test.cpp
@@ -1053,19 +1053,19 @@ TEST_F(ParquetExprTest, test_expr_push_down_and) {
{
pred->add_column_predicate(SingleColumnBlockPredicate::create_unique(
ComparisonPredicateBase<TYPE_BIGINT,
PredicateType::LE>::create_shared(
- 2, "", 10000000002)));
+ 2, "",
Field::create_field<TYPE_BIGINT>(10000000002))));
}
{ // x > 100
pred->add_column_predicate(SingleColumnBlockPredicate::create_unique(
- ComparisonPredicateBase<TYPE_BIGINT,
PredicateType::GT>::create_shared(2, "",
-
100)));
+ ComparisonPredicateBase<TYPE_BIGINT,
PredicateType::GT>::create_shared(
+ 2, "", Field::create_field<TYPE_BIGINT>(100))));
}
{ // x >= 900
pred->add_column_predicate(SingleColumnBlockPredicate::create_unique(
- ComparisonPredicateBase<TYPE_BIGINT,
PredicateType::GE>::create_shared(2, "",
-
900)));
+ ComparisonPredicateBase<TYPE_BIGINT,
PredicateType::GE>::create_shared(
+ 2, "", Field::create_field<TYPE_BIGINT>(900))));
}
const std::function<bool(const FieldSchema*,
ParquetPredicate::ColumnStat*)>& get_stat_func =
@@ -1160,7 +1160,8 @@ TEST_F(ParquetExprTest, test_expr_push_down_or_string) {
TEST_F(ParquetExprTest, test_bloom_filter_skipped_when_range_miss) {
const int col_idx = 2;
const int64_t predicate_value = 10000000001;
- ComparisonPredicateBase<TYPE_BIGINT, PredicateType::EQ> eq_pred(col_idx,
"", predicate_value);
+ ComparisonPredicateBase<TYPE_BIGINT, PredicateType::EQ> eq_pred(
+ col_idx, "",
vectorized::Field::create_field<TYPE_BIGINT>(predicate_value));
ParquetPredicate::ColumnStat stat;
stat.ctz = &ctz;
@@ -1202,7 +1203,8 @@ TEST_F(ParquetExprTest,
test_bloom_filter_skipped_when_range_miss) {
TEST_F(ParquetExprTest, test_bloom_filter_rejects_value) {
const int col_idx = 2;
const int64_t predicate_value = 10000000001;
- ComparisonPredicateBase<TYPE_BIGINT, PredicateType::EQ> eq_pred(col_idx,
"", predicate_value);
+ ComparisonPredicateBase<TYPE_BIGINT, PredicateType::EQ> eq_pred(
+ col_idx, "",
vectorized::Field::create_field<TYPE_BIGINT>(predicate_value));
ParquetPredicate::ColumnStat stat;
stat.ctz = &ctz;
@@ -1253,7 +1255,8 @@ TEST_F(ParquetExprTest, test_bloom_filter_rejects_value) {
TEST_F(ParquetExprTest, test_bloom_filter_accepts_value) {
const int col_idx = 2;
const int64_t predicate_value = 10000000001;
- ComparisonPredicateBase<TYPE_BIGINT, PredicateType::EQ> eq_pred(col_idx,
"", predicate_value);
+ ComparisonPredicateBase<TYPE_BIGINT, PredicateType::EQ> eq_pred(
+ col_idx, "",
vectorized::Field::create_field<TYPE_BIGINT>(predicate_value));
ParquetPredicate::ColumnStat stat;
stat.ctz = &ctz;
@@ -1304,7 +1307,8 @@ TEST_F(ParquetExprTest, test_bloom_filter_accepts_value) {
TEST_F(ParquetExprTest,
test_bloom_filter_skipped_when_min_max_evicts_rowgroup) {
const int col_idx = 2;
const int64_t predicate_value = 10000000001;
- ComparisonPredicateBase<TYPE_BIGINT, PredicateType::EQ> eq_pred(col_idx,
"", predicate_value);
+ ComparisonPredicateBase<TYPE_BIGINT, PredicateType::EQ> eq_pred(
+ col_idx, "",
vectorized::Field::create_field<TYPE_BIGINT>(predicate_value));
ParquetPredicate::ColumnStat stat;
stat.ctz = &ctz;
@@ -1347,7 +1351,8 @@ TEST_F(ParquetExprTest,
test_bloom_filter_skipped_when_min_max_evicts_rowgroup)
TEST_F(ParquetExprTest, test_bloom_filter_loader_called_when_min_max_allows) {
const int col_idx = 2;
const int64_t predicate_value = 10000000001;
- ComparisonPredicateBase<TYPE_BIGINT, PredicateType::EQ> eq_pred(col_idx,
"", predicate_value);
+ ComparisonPredicateBase<TYPE_BIGINT, PredicateType::EQ> eq_pred(
+ col_idx, "",
vectorized::Field::create_field<TYPE_BIGINT>(predicate_value));
ParquetPredicate::ColumnStat stat;
stat.ctz = &ctz;
@@ -1398,7 +1403,8 @@ TEST_F(ParquetExprTest,
test_bloom_filter_loader_called_when_min_max_allows) {
TEST_F(ParquetExprTest,
test_bloom_filter_loader_not_called_when_missing_metadata) {
const int col_idx = 2;
const int64_t predicate_value = 10000000001;
- ComparisonPredicateBase<TYPE_BIGINT, PredicateType::EQ> eq_pred(col_idx,
"", predicate_value);
+ ComparisonPredicateBase<TYPE_BIGINT, PredicateType::EQ> eq_pred(
+ col_idx, "",
vectorized::Field::create_field<TYPE_BIGINT>(predicate_value));
ParquetPredicate::ColumnStat stat;
stat.ctz = &ctz;
@@ -1440,7 +1446,8 @@ TEST_F(ParquetExprTest,
test_bloom_filter_loader_not_called_when_missing_metadat
TEST_F(ParquetExprTest, test_bloom_filter_loader_resets_on_failure) {
const int col_idx = 2;
const int64_t predicate_value = 10000000001;
- ComparisonPredicateBase<TYPE_BIGINT, PredicateType::EQ> eq_pred(col_idx,
"", predicate_value);
+ ComparisonPredicateBase<TYPE_BIGINT, PredicateType::EQ> eq_pred(
+ col_idx, "",
vectorized::Field::create_field<TYPE_BIGINT>(predicate_value));
ParquetPredicate::ColumnStat stat;
stat.ctz = &ctz;
@@ -1487,7 +1494,8 @@ TEST_F(ParquetExprTest,
test_bloom_filter_loader_resets_on_failure) {
TEST_F(ParquetExprTest, test_bloom_filter_not_supported_type) {
const int col_idx = 6; // bool column
const bool predicate_value = true;
- ComparisonPredicateBase<TYPE_BOOLEAN, PredicateType::EQ> eq_pred(col_idx,
"", predicate_value);
+ ComparisonPredicateBase<TYPE_BOOLEAN, PredicateType::EQ> eq_pred(
+ col_idx, "",
vectorized::Field::create_field<TYPE_BOOLEAN>(predicate_value));
ParquetPredicate::ColumnStat stat;
stat.ctz = &ctz;
@@ -1527,7 +1535,8 @@ TEST_F(ParquetExprTest,
test_bloom_filter_not_supported_type) {
TEST_F(ParquetExprTest, test_bloom_filter_min_max_overlap_but_no_loader) {
const int col_idx = 2;
const int64_t predicate_value = 10000000001;
- ComparisonPredicateBase<TYPE_BIGINT, PredicateType::EQ> eq_pred(col_idx,
"", predicate_value);
+ ComparisonPredicateBase<TYPE_BIGINT, PredicateType::EQ> eq_pred(
+ col_idx, "",
vectorized::Field::create_field<TYPE_BIGINT>(predicate_value));
ParquetPredicate::ColumnStat stat;
stat.ctz = &ctz;
@@ -1664,7 +1673,8 @@ TEST_F(ParquetExprTest,
test_in_list_predicate_no_loader_on_range_miss) {
TEST_F(ParquetExprTest, test_bloom_filter_reused_after_first_load) {
const int col_idx = 2;
const int64_t predicate_value = 10000000001;
- ComparisonPredicateBase<TYPE_BIGINT, PredicateType::EQ> eq_pred(col_idx,
"", predicate_value);
+ ComparisonPredicateBase<TYPE_BIGINT, PredicateType::EQ> eq_pred(
+ col_idx, "",
vectorized::Field::create_field<TYPE_BIGINT>(predicate_value));
ParquetPredicate::ColumnStat stat;
stat.ctz = &ctz;
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
