This is an automated email from the ASF dual-hosted git repository.
yiguolei pushed a commit to branch branch-4.0
in repository https://gitbox.apache.org/repos/asf/doris.git
The following commit(s) were added to refs/heads/branch-4.0 by this push:
new 58502521a09 branch-4.0: [chore](code)Remove unnecessary accurate code
and reduce template parameters #56909 (#56940)
58502521a09 is described below
commit 58502521a0984b6374ef2271188d708ce1a75fe5
Author: github-actions[bot]
<41898282+github-actions[bot]@users.noreply.github.com>
AuthorDate: Wed Oct 15 12:38:00 2025 +0800
branch-4.0: [chore](code)Remove unnecessary accurate code and reduce
template parameters #56909 (#56940)
Cherry-picked from #56909
Co-authored-by: Mryange <[email protected]>
---
be/src/vec/core/accurate_comparison.h | 303 +++------------------
be/src/vec/core/decimal_comparison.h | 7 +-
be/src/vec/functions/functions_comparison.h | 82 +++---
be/src/vec/functions/least_greast.cpp | 37 ++-
be/test/vec/core/accurate_comparison_test.cpp | 63 +----
.../data/correctness/test_compare_float.out | 8 -
.../suites/correctness/test_compare_float.groovy | 2 +-
7 files changed, 107 insertions(+), 395 deletions(-)
diff --git a/be/src/vec/core/accurate_comparison.h
b/be/src/vec/core/accurate_comparison.h
index 0d5fd45efec..a074e2abfb6 100644
--- a/be/src/vec/core/accurate_comparison.h
+++ b/be/src/vec/core/accurate_comparison.h
@@ -20,330 +20,109 @@
#pragma once
-#include <cmath>
-#include <limits>
-
#include "common/compare.h"
#include "runtime/primitive_type.h"
-#include "util/binary_cast.hpp"
-#include "vec/common/nan_utils.h"
#include "vec/common/string_ref.h"
-#include "vec/common/uint128.h"
-#include "vec/core/decomposed_float.h"
-#include "vec/core/extended_types.h"
#include "vec/core/types.h"
-#include "vec/runtime/vdatetime_value.h"
-/** Perceptually-correct number comparisons.
- * Example: Int8(-1) != UInt8(255)
-*/
-
-namespace accurate {
-
-/** Cases:
- 1) Safe conversion (in case of default C++ operators)
- a) int vs any int
- b) uint vs any uint
- c) float vs any float
- 2) int vs uint
- a) sizeof(int) <= sizeof(uint). Accurate comparison with MAX_INT
thresholds
- b) sizeof(int) > sizeof(uint). Casting to int
- 3) integral_type vs floating_type
- a) sizeof(integral_type) <= 4. Comparison via casting arguments to
Float64
- b) sizeof(integral_type) == 8. Accurate comparison. Consider 3 sets of
intervals:
- 1) interval between adjacent floats less or equal 1
- 2) interval between adjacent floats greater then 2
- 3) float is outside [MIN_INT64; MAX_INT64]
-*/
-
-// Case 1. Is pair of floats or pair of ints or pair of uints
-template <typename A, typename B>
-constexpr bool is_safe_conversion =
- (std::is_floating_point_v<A> && std::is_floating_point_v<B>) ||
- (IsIntegralV<A> && IsIntegralV<B> && !(IsSignedV<A> ^ IsSignedV<B>)) ||
- (std::is_same_v<A, doris::vectorized::Int128> &&
- std::is_same_v<B, doris::vectorized::Int128>) ||
- (IsIntegralV<A> && std::is_same_v<B, doris::vectorized::Int128>) ||
- (std::is_same_v<A, doris::vectorized::Int128> && IsIntegralV<B>);
-template <typename A, typename B>
-using bool_if_safe_conversion = std::enable_if_t<is_safe_conversion<A, B>,
bool>;
-template <typename A, typename B>
-using bool_if_not_safe_conversion = std::enable_if_t<!is_safe_conversion<A,
B>, bool>;
-
-/* Final realizations */
-
-template <typename A, typename B>
-bool lessOp(A a, B b) {
- if constexpr (std::is_same_v<A, B>) {
- return a < b;
- }
-
- /// float vs float
- if constexpr (std::is_floating_point_v<A> && std::is_floating_point_v<B>) {
- return a < b;
- }
-
- /// anything vs NaN
- if (is_nan(a) || is_nan(b)) {
- return false;
- }
-
- /// int vs int
- if constexpr (IsIntegralV<A> && IsIntegralV<B>) {
- /// same signedness
- if constexpr (IsSignedV<A> == IsSignedV<B>) {
- return a < b;
- }
-
- /// different signedness
-
- if constexpr (IsSignedV<A> && !IsSignedV<B>) {
- return a < 0 || static_cast<std::make_unsigned_t<A>>(a) < b;
- }
-
- if constexpr (!IsSignedV<A> && IsSignedV<B>) {
- return b >= 0 && a < static_cast<std::make_unsigned_t<B>>(b);
- }
- }
-
- /// int vs float
- if constexpr (IsIntegralV<A> && std::is_floating_point_v<B>) {
- if constexpr (sizeof(A) <= 4) {
- return static_cast<double>(a) < static_cast<double>(b);
- }
-
- return DecomposedFloat<B>(b).greater(a);
- }
-
- if constexpr (std::is_floating_point_v<A> && IsIntegralV<B>) {
- if constexpr (sizeof(B) <= 4) {
- return static_cast<double>(a) < static_cast<double>(b);
- }
-
- return DecomposedFloat<A>(a).less(b);
- }
-
- static_assert(IsIntegralV<A> || std::is_floating_point_v<A>);
- static_assert(IsIntegralV<B> || std::is_floating_point_v<B>);
- __builtin_unreachable();
-}
-
-template <typename A, typename B>
-bool greaterOp(A a, B b) {
- return lessOp(b, a);
-}
-
-template <typename A, typename B>
-inline bool_if_not_safe_conversion<A, B> greaterOrEqualsOp(A a, B b) {
- if (is_nan(a) || is_nan(b)) {
- return false;
- }
-
- return !lessOp(a, b);
-}
-
-template <typename A, typename B>
-inline bool_if_safe_conversion<A, B> greaterOrEqualsOp(A a, B b) {
- return a >= b;
-}
-
-template <typename A, typename B>
-inline bool_if_not_safe_conversion<A, B> lessOrEqualsOp(A a, B b) {
- if (is_nan(a) || is_nan(b)) {
- return false;
- }
-
- return !lessOp(b, a);
-}
-
-template <typename A, typename B>
-inline bool_if_safe_conversion<A, B> lessOrEqualsOp(A a, B b) {
- return a <= b;
-}
-
-template <typename A, typename B>
-bool equalsOp(A a, B b) {
- if constexpr (std::is_same_v<A, B>) {
- return a == b;
- }
-
- /// float vs float
- if constexpr (std::is_floating_point_v<A> && std::is_floating_point_v<B>) {
- return a == b;
- }
-
- /// anything vs NaN
- if (is_nan(a) || is_nan(b)) {
- return false;
- }
-
- /// int vs int
- if constexpr (IsIntegralV<A> && IsIntegralV<B>) {
- /// same signedness
- if constexpr (IsSignedV<A> == IsSignedV<B>) {
- return a == b;
- }
-
- /// different signedness
-
- if constexpr (IsSignedV<A> && !IsSignedV<B>) {
- return a >= 0 && static_cast<std::make_unsigned_t<A>>(a) == b;
- }
-
- if constexpr (!IsSignedV<A> && IsSignedV<B>) {
- return b >= 0 && a == static_cast<std::make_unsigned_t<B>>(b);
- }
- }
-
- /// int vs float
- if constexpr (IsIntegralV<A> && std::is_floating_point_v<B>) {
- if constexpr (sizeof(A) <= 4) {
- return static_cast<double>(a) == static_cast<double>(b);
- }
-
- return DecomposedFloat<B>(b).equals(a);
- }
-
- if constexpr (std::is_floating_point_v<A> && IsIntegralV<B>) {
- if constexpr (sizeof(B) <= 4) {
- return static_cast<double>(a) == static_cast<double>(b);
- }
-
- return DecomposedFloat<A>(a).equals(b);
- }
-
- /// e.g comparing UUID with integer.
- return false;
-}
-
-template <typename A, typename B>
-bool notEqualsOp(A a, B b) {
- return !equalsOp(a, b);
-}
-} // namespace accurate
-
namespace doris::vectorized {
-template <PrimitiveType A, PrimitiveType B>
+template <PrimitiveType PT>
+using CompareType =
+ std::conditional_t<PT == TYPE_BOOLEAN, typename
PrimitiveTypeTraits<PT>::ColumnItemType,
+ typename PrimitiveTypeTraits<PT>::CppNativeType>;
+
+template <PrimitiveType PT>
struct EqualsOp {
/// An operation that gives the same result, if arguments are passed in
reverse order.
- using SymmetricOp = EqualsOp<B, A>;
- using NativeTypeA =
- std::conditional_t<A == TYPE_BOOLEAN, typename
PrimitiveTypeTraits<A>::ColumnItemType,
- typename PrimitiveTypeTraits<A>::CppNativeType>;
- using NativeTypeB =
- std::conditional_t<B == TYPE_BOOLEAN, typename
PrimitiveTypeTraits<B>::ColumnItemType,
- typename PrimitiveTypeTraits<B>::CppNativeType>;
- static UInt8 apply(NativeTypeA a, NativeTypeB b) { return
Compare::equal(a, b); }
+ using SymmetricOp = EqualsOp<PT>;
+ using NativeType = CompareType<PT>;
+
+ static UInt8 apply(NativeType a, NativeType b) { return Compare::equal(a,
b); }
};
template <>
-struct EqualsOp<TYPE_DECIMALV2, TYPE_DECIMALV2> {
+struct EqualsOp<TYPE_DECIMALV2> {
static UInt8 apply(const Int128& a, const Int128& b) { return a == b; }
};
template <>
-struct EqualsOp<TYPE_STRING, TYPE_STRING> {
+struct EqualsOp<TYPE_STRING> {
static UInt8 apply(const StringRef& a, const StringRef& b) { return a ==
b; }
};
-template <PrimitiveType A, PrimitiveType B>
+template <PrimitiveType PT>
struct NotEqualsOp {
- using SymmetricOp = NotEqualsOp<B, A>;
- using NativeTypeA =
- std::conditional_t<A == TYPE_BOOLEAN, typename
PrimitiveTypeTraits<A>::ColumnItemType,
- typename PrimitiveTypeTraits<A>::CppNativeType>;
- using NativeTypeB =
- std::conditional_t<B == TYPE_BOOLEAN, typename
PrimitiveTypeTraits<B>::ColumnItemType,
- typename PrimitiveTypeTraits<B>::CppNativeType>;
- static UInt8 apply(NativeTypeA a, NativeTypeB b) { return
Compare::not_equal(a, b); }
+ using SymmetricOp = NotEqualsOp<PT>;
+ using NativeType = CompareType<PT>;
+ static UInt8 apply(NativeType a, NativeType b) { return
Compare::not_equal(a, b); }
};
template <>
-struct NotEqualsOp<TYPE_DECIMALV2, TYPE_DECIMALV2> {
+struct NotEqualsOp<TYPE_DECIMALV2> {
static UInt8 apply(const DecimalV2Value& a, const DecimalV2Value& b) {
return a != b; }
};
-template <PrimitiveType A, PrimitiveType B>
+template <PrimitiveType PT>
struct GreaterOp;
-template <PrimitiveType A, PrimitiveType B>
+template <PrimitiveType PT>
struct LessOp {
- using SymmetricOp = GreaterOp<B, A>;
- using NativeTypeA =
- std::conditional_t<A == TYPE_BOOLEAN, typename
PrimitiveTypeTraits<A>::ColumnItemType,
- typename PrimitiveTypeTraits<A>::CppNativeType>;
- using NativeTypeB =
- std::conditional_t<B == TYPE_BOOLEAN, typename
PrimitiveTypeTraits<B>::ColumnItemType,
- typename PrimitiveTypeTraits<B>::CppNativeType>;
- static UInt8 apply(NativeTypeA a, NativeTypeB b) { return Compare::less(a,
b); }
+ using SymmetricOp = GreaterOp<PT>;
+ using NativeType = CompareType<PT>;
+ static UInt8 apply(NativeType a, NativeType b) { return Compare::less(a,
b); }
};
template <>
-struct LessOp<TYPE_DECIMALV2, TYPE_DECIMALV2> {
+struct LessOp<TYPE_DECIMALV2> {
static UInt8 apply(Int128 a, Int128 b) { return a < b; }
};
template <>
-struct LessOp<TYPE_STRING, TYPE_STRING> {
+struct LessOp<TYPE_STRING> {
static UInt8 apply(StringRef a, StringRef b) { return a < b; }
};
-template <PrimitiveType A, PrimitiveType B>
+template <PrimitiveType PT>
struct GreaterOp {
- using SymmetricOp = LessOp<B, A>;
- using NativeTypeA =
- std::conditional_t<A == TYPE_BOOLEAN, typename
PrimitiveTypeTraits<A>::ColumnItemType,
- typename PrimitiveTypeTraits<A>::CppNativeType>;
- using NativeTypeB =
- std::conditional_t<B == TYPE_BOOLEAN, typename
PrimitiveTypeTraits<B>::ColumnItemType,
- typename PrimitiveTypeTraits<B>::CppNativeType>;
- static UInt8 apply(NativeTypeA a, NativeTypeB b) { return
Compare::greater(a, b); }
+ using SymmetricOp = LessOp<PT>;
+ using NativeType = CompareType<PT>;
+ static UInt8 apply(NativeType a, NativeType b) { return
Compare::greater(a, b); }
};
template <>
-struct GreaterOp<TYPE_DECIMALV2, TYPE_DECIMALV2> {
+struct GreaterOp<TYPE_DECIMALV2> {
static UInt8 apply(Int128 a, Int128 b) { return a > b; }
};
template <>
-struct GreaterOp<TYPE_STRING, TYPE_STRING> {
+struct GreaterOp<TYPE_STRING> {
static UInt8 apply(StringRef a, StringRef b) { return a > b; }
};
-template <PrimitiveType A, PrimitiveType B>
+template <PrimitiveType PT>
struct GreaterOrEqualsOp;
-template <PrimitiveType A, PrimitiveType B>
+template <PrimitiveType PT>
struct LessOrEqualsOp {
- using SymmetricOp = GreaterOrEqualsOp<B, A>;
- using NativeTypeA =
- std::conditional_t<A == TYPE_BOOLEAN, typename
PrimitiveTypeTraits<A>::ColumnItemType,
- typename PrimitiveTypeTraits<A>::CppNativeType>;
- using NativeTypeB =
- std::conditional_t<B == TYPE_BOOLEAN, typename
PrimitiveTypeTraits<B>::ColumnItemType,
- typename PrimitiveTypeTraits<B>::CppNativeType>;
- static UInt8 apply(NativeTypeA a, NativeTypeB b) { return
Compare::less_equal(a, b); }
+ using SymmetricOp = GreaterOrEqualsOp<PT>;
+ using NativeType = CompareType<PT>;
+ static UInt8 apply(NativeType a, NativeType b) { return
Compare::less_equal(a, b); }
};
template <>
-struct LessOrEqualsOp<TYPE_DECIMALV2, TYPE_DECIMALV2> {
+struct LessOrEqualsOp<TYPE_DECIMALV2> {
static UInt8 apply(DecimalV2Value a, DecimalV2Value b) { return a <= b; }
};
-template <PrimitiveType A, PrimitiveType B>
+template <PrimitiveType PT>
struct GreaterOrEqualsOp {
- using SymmetricOp = LessOrEqualsOp<B, A>;
- using NativeTypeA =
- std::conditional_t<A == TYPE_BOOLEAN, typename
PrimitiveTypeTraits<A>::ColumnItemType,
- typename PrimitiveTypeTraits<A>::CppNativeType>;
- using NativeTypeB =
- std::conditional_t<B == TYPE_BOOLEAN, typename
PrimitiveTypeTraits<B>::ColumnItemType,
- typename PrimitiveTypeTraits<B>::CppNativeType>;
- static UInt8 apply(NativeTypeA a, NativeTypeB b) { return
Compare::greater_equal(a, b); }
+ using SymmetricOp = LessOrEqualsOp<PT>;
+ using NativeType = CompareType<PT>;
+ static UInt8 apply(NativeType a, NativeType b) { return
Compare::greater_equal(a, b); }
};
template <>
-struct GreaterOrEqualsOp<TYPE_DECIMALV2, TYPE_DECIMALV2> {
+struct GreaterOrEqualsOp<TYPE_DECIMALV2> {
static UInt8 apply(DecimalV2Value a, DecimalV2Value b) { return a >= b; }
};
diff --git a/be/src/vec/core/decimal_comparison.h
b/be/src/vec/core/decimal_comparison.h
index 6ba4bb6530f..8483f8fe0ef 100644
--- a/be/src/vec/core/decimal_comparison.h
+++ b/be/src/vec/core/decimal_comparison.h
@@ -71,14 +71,13 @@ struct DecCompareInt {
};
///
-template <PrimitiveType A, PrimitiveType B,
- template <PrimitiveType, PrimitiveType> typename Operation, bool
_check_overflow = true,
- bool _actual = is_decimal(A) || is_decimal(B)>
+template <PrimitiveType A, PrimitiveType B, template <PrimitiveType> typename
Operation,
+ bool _check_overflow = true, bool _actual = is_decimal(A) ||
is_decimal(B)>
class DecimalComparison {
public:
static constexpr PrimitiveType CompareIntPType = DecCompareInt<A, B>::Type;
using CompareInt = typename
PrimitiveTypeTraits<CompareIntPType>::CppNativeType;
- using Op = Operation<CompareIntPType, CompareIntPType>;
+ using Op = Operation<CompareIntPType>;
using ColVecA = typename PrimitiveTypeTraits<A>::ColumnType;
using ColVecB = typename PrimitiveTypeTraits<B>::ColumnType;
using ArrayA = typename ColVecA::Container;
diff --git a/be/src/vec/functions/functions_comparison.h
b/be/src/vec/functions/functions_comparison.h
index 70e51ab98a4..da740f59211 100644
--- a/be/src/vec/functions/functions_comparison.h
+++ b/be/src/vec/functions/functions_comparison.h
@@ -238,11 +238,11 @@ struct StringEqualsImpl {
}
};
-template <PrimitiveType A, PrimitiveType B>
-struct StringComparisonImpl<EqualsOp<A, B>> : StringEqualsImpl<true> {};
+template <PrimitiveType PT>
+struct StringComparisonImpl<EqualsOp<PT>> : StringEqualsImpl<true> {};
-template <PrimitiveType A, PrimitiveType B>
-struct StringComparisonImpl<NotEqualsOp<A, B>> : StringEqualsImpl<false> {};
+template <PrimitiveType PT>
+struct StringComparisonImpl<NotEqualsOp<PT>> : StringEqualsImpl<false> {};
struct NameEquals {
static constexpr auto name = "eq";
@@ -263,7 +263,7 @@ struct NameGreaterOrEquals {
static constexpr auto name = "ge";
};
-template <template <PrimitiveType, PrimitiveType> class Op, typename Name>
+template <template <PrimitiveType> class Op, typename Name>
class FunctionComparison : public IFunction {
public:
static constexpr auto name = Name::name;
@@ -281,6 +281,8 @@ private:
const auto* col_left = assert_cast<const
ColumnVector<PT>*>(col_left_untype.get());
const auto* col_right = assert_cast<const
ColumnVector<PT>*>(col_right_untyped.get());
+ DCHECK(!(left_is_const && right_is_const));
+
if (!left_is_const && !right_is_const) {
auto col_res = ColumnUInt8::create();
@@ -288,8 +290,8 @@ private:
vec_res.resize(col_left->get_data().size());
NumComparisonImpl<typename PrimitiveTypeTraits<PT>::ColumnItemType,
typename PrimitiveTypeTraits<PT>::ColumnItemType,
- Op<PT, PT>>::vector_vector(col_left->get_data(),
-
col_right->get_data(), vec_res);
+ Op<PT>>::vector_vector(col_left->get_data(),
col_right->get_data(),
+ vec_res);
block.replace_by_position(result, std::move(col_res));
} else if (!left_is_const && right_is_const) {
@@ -299,8 +301,8 @@ private:
vec_res.resize(col_left->size());
NumComparisonImpl<typename PrimitiveTypeTraits<PT>::ColumnItemType,
typename PrimitiveTypeTraits<PT>::ColumnItemType,
- Op<PT,
PT>>::vector_constant(col_left->get_data(),
-
col_right->get_element(0), vec_res);
+ Op<PT>>::vector_constant(col_left->get_data(),
+
col_right->get_element(0), vec_res);
block.replace_by_position(result, std::move(col_res));
} else if (left_is_const && !right_is_const) {
@@ -310,20 +312,10 @@ private:
vec_res.resize(col_right->size());
NumComparisonImpl<typename PrimitiveTypeTraits<PT>::ColumnItemType,
typename PrimitiveTypeTraits<PT>::ColumnItemType,
- Op<PT,
PT>>::constant_vector(col_left->get_element(0),
-
col_right->get_data(), vec_res);
+
Op<PT>>::constant_vector(col_left->get_element(0),
+ col_right->get_data(),
vec_res);
block.replace_by_position(result, std::move(col_res));
- } else {
- UInt8 res = 0;
- NumComparisonImpl<typename PrimitiveTypeTraits<PT>::ColumnItemType,
- typename PrimitiveTypeTraits<PT>::ColumnItemType,
- Op<PT,
PT>>::constant_constant(col_left->get_element(0),
-
col_right->get_element(0), res);
-
- block.replace_by_position(
- result,
DataTypeUInt8().create_column_const(col_left->size(),
-
to_field<TYPE_BOOLEAN>(res)));
}
return Status::OK();
}
@@ -359,12 +351,7 @@ private:
return Status::NotSupported("Illegal columns {}, {} of argument of
function {}",
c0->get_name(), c1->get_name(), name);
}
-
- if (c0_const && c1_const) {
- execute_generic_identical_types(block, result, c0, c1);
- return Status::OK();
- }
-
+ DCHECK(!(c0_const && c1_const));
const ColumnString::Chars* c0_const_chars = nullptr;
const ColumnString::Chars* c1_const_chars = nullptr;
ColumnString::Offset c0_const_size = 0;
@@ -396,7 +383,7 @@ private:
}
}
- using StringImpl = StringComparisonImpl<Op<TYPE_INT, TYPE_INT>>;
+ using StringImpl = StringComparisonImpl<Op<TYPE_INT>>;
auto c_res = ColumnUInt8::create();
ColumnUInt8::Container& vec_res = c_res->get_data();
@@ -426,26 +413,21 @@ private:
bool c0_const = is_column_const(*c0);
bool c1_const = is_column_const(*c1);
- if (c0_const && c1_const) {
- UInt8 res = 0;
- GenericComparisonImpl<Op<TYPE_INT,
TYPE_INT>>::constant_constant(*c0, *c1, res);
- block.replace_by_position(result,
DataTypeUInt8().create_column_const(
- c0->size(),
to_field<TYPE_BOOLEAN>(res)));
- } else {
- auto c_res = ColumnUInt8::create();
- ColumnUInt8::Container& vec_res = c_res->get_data();
- vec_res.resize(c0->size());
-
- if (c0_const) {
- GenericComparisonImpl<Op<TYPE_INT,
TYPE_INT>>::constant_vector(*c0, *c1, vec_res);
- } else if (c1_const) {
- GenericComparisonImpl<Op<TYPE_INT,
TYPE_INT>>::vector_constant(*c0, *c1, vec_res);
- } else {
- GenericComparisonImpl<Op<TYPE_INT,
TYPE_INT>>::vector_vector(*c0, *c1, vec_res);
- }
+ DCHECK(!(c0_const && c1_const));
+
+ auto c_res = ColumnUInt8::create();
+ ColumnUInt8::Container& vec_res = c_res->get_data();
+ vec_res.resize(c0->size());
- block.replace_by_position(result, std::move(c_res));
+ if (c0_const) {
+ GenericComparisonImpl<Op<TYPE_INT>>::constant_vector(*c0, *c1,
vec_res);
+ } else if (c1_const) {
+ GenericComparisonImpl<Op<TYPE_INT>>::vector_constant(*c0, *c1,
vec_res);
+ } else {
+ GenericComparisonImpl<Op<TYPE_INT>>::vector_vector(*c0, *c1,
vec_res);
}
+
+ block.replace_by_position(result, std::move(c_res));
}
Status execute_generic(Block& block, uint32_t result, const
ColumnWithTypeAndName& c0,
@@ -557,11 +539,9 @@ public:
col_left_untyped == col_right_untyped) {
/// Always true: =, <=, >=
// TODO: Return const column in the future. But seems so far to
do. We need a unified approach for passing const column.
- if constexpr (std::is_same_v<Op<TYPE_INT, TYPE_INT>,
EqualsOp<TYPE_INT, TYPE_INT>> ||
- std::is_same_v<Op<TYPE_INT, TYPE_INT>,
- LessOrEqualsOp<TYPE_INT, TYPE_INT>> ||
- std::is_same_v<Op<TYPE_INT, TYPE_INT>,
- GreaterOrEqualsOp<TYPE_INT,
TYPE_INT>>) {
+ if constexpr (std::is_same_v<Op<TYPE_INT>, EqualsOp<TYPE_INT>> ||
+ std::is_same_v<Op<TYPE_INT>,
LessOrEqualsOp<TYPE_INT>> ||
+ std::is_same_v<Op<TYPE_INT>,
GreaterOrEqualsOp<TYPE_INT>>) {
block.get_by_position(result).column =
DataTypeUInt8()
.create_column_const(input_rows_count,
diff --git a/be/src/vec/functions/least_greast.cpp
b/be/src/vec/functions/least_greast.cpp
index dfd5ff7a7a6..660a5bf2c9d 100644
--- a/be/src/vec/functions/least_greast.cpp
+++ b/be/src/vec/functions/least_greast.cpp
@@ -49,7 +49,7 @@ class DecimalV2Value;
namespace doris::vectorized {
-template <template <PrimitiveType, PrimitiveType> class Op, typename Impl>
+template <template <PrimitiveType> class Op, typename Impl>
struct CompareMultiImpl {
static constexpr auto name = Impl::name;
@@ -83,8 +83,7 @@ struct CompareMultiImpl {
for (int cmp_col = 1; cmp_col < arguments.size(); ++cmp_col) {
auto temp_data = assert_cast<const
ColumnString&>(*cols[cmp_col])
.get_data_at(index_check_const(i,
col_const[cmp_col]));
- str_data = Op<TYPE_STRING, TYPE_STRING>::apply(temp_data,
str_data) ? temp_data
-
: str_data;
+ str_data = Op<TYPE_STRING>::apply(temp_data, str_data) ?
temp_data : str_data;
}
column_res.insert_data(str_data.data, str_data.size);
}
@@ -311,8 +310,8 @@ private:
if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
for (size_t i = 0; i < input_rows_count; ++i) {
result_raw_data[i] =
- Op<TYPE_DECIMALV2, TYPE_DECIMALV2>::apply(
- column_raw_data[index_check_const(i,
ArgConst)], result_raw_data[i])
+
Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
+ result_raw_data[i])
? column_raw_data[index_check_const(i,
ArgConst)]
: result_raw_data[i];
}
@@ -321,17 +320,17 @@ private:
std::is_same_v<ColumnType, ColumnDecimal128V3> ||
std::is_same_v<ColumnType, ColumnDecimal256>) {
for (size_t i = 0; i < input_rows_count; ++i) {
- result_raw_data[i] = Op<PType, PType>::apply(
-
column_raw_data[index_check_const(i, ArgConst)].value,
- result_raw_data[i].value)
- ?
column_raw_data[index_check_const(i, ArgConst)]
- : result_raw_data[i];
+ result_raw_data[i] =
+ Op<PType>::apply(column_raw_data[index_check_const(i,
ArgConst)].value,
+ result_raw_data[i].value)
+ ? column_raw_data[index_check_const(i,
ArgConst)]
+ : result_raw_data[i];
}
} else {
for (size_t i = 0; i < input_rows_count; ++i) {
result_raw_data[i] =
- Op<PType,
PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
- result_raw_data[i])
+ Op<PType>::apply(column_raw_data[index_check_const(i,
ArgConst)],
+ result_raw_data[i])
? column_raw_data[index_check_const(i,
ArgConst)]
: result_raw_data[i];
}
@@ -374,7 +373,7 @@ struct FunctionFieldImpl {
auto [column, is_const] =
unpack_if_const(argument_columns[col]);
const auto& temp_data = assert_cast<const
ColumnString&>(*column).get_data_at(
index_check_const(row, is_const));
- if (EqualsOp<TYPE_STRING, TYPE_STRING>::apply(temp_data,
str_data)) {
+ if (EqualsOp<TYPE_STRING>::apply(temp_data, str_data)) {
res_data[row] = col;
break;
}
@@ -516,22 +515,20 @@ private:
assert_cast<const
ColumnType&>(*argument_column_raw).get_data().data()[0];
if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
for (size_t i = 0; i < input_rows_count; ++i) {
- res_data[i] |= (!res_data[i] *
- (EqualsOp<TYPE_DECIMALV2,
TYPE_DECIMALV2>::apply(first_raw_data[i],
-
arg_data)) *
- col);
+ res_data[i] |=
+ (!res_data[i] *
+ (EqualsOp<TYPE_DECIMALV2>::apply(first_raw_data[i],
arg_data)) * col);
}
} else if constexpr (is_decimal(PType)) {
for (size_t i = 0; i < input_rows_count; ++i) {
res_data[i] |=
(!res_data[i] *
- (EqualsOp<PType,
PType>::apply(first_raw_data[i].value, arg_data.value)) *
- col);
+ (EqualsOp<PType>::apply(first_raw_data[i].value,
arg_data.value)) * col);
}
} else {
for (size_t i = 0; i < input_rows_count; ++i) {
res_data[i] |= (!res_data[i] *
- (EqualsOp<PType,
PType>::apply(first_raw_data[i], arg_data)) * col);
+ (EqualsOp<PType>::apply(first_raw_data[i],
arg_data)) * col);
}
}
}
diff --git a/be/test/vec/core/accurate_comparison_test.cpp
b/be/test/vec/core/accurate_comparison_test.cpp
index 967596bc5c9..a59f2007b1f 100644
--- a/be/test/vec/core/accurate_comparison_test.cpp
+++ b/be/test/vec/core/accurate_comparison_test.cpp
@@ -17,58 +17,23 @@
#include "vec/core/accurate_comparison.h"
-#include <gtest/gtest-message.h>
-#include <gtest/gtest-test-part.h>
-
-#include <string>
-
-#include "gtest/gtest_pred_impl.h"
-#include "runtime/primitive_type.h"
+#include <gtest/gtest.h>
namespace doris::vectorized {
TEST(VAccurateComparison, TestsOP) {
- ASSERT_TRUE(accurate::equalsOp(static_cast<Float32>(123),
static_cast<UInt64>(123)));
- ASSERT_TRUE(accurate::lessOp(static_cast<Float32>(123),
static_cast<UInt64>(124)));
- ASSERT_TRUE(accurate::lessOp(static_cast<Float32>(-1),
static_cast<UInt64>(1)));
- ASSERT_TRUE(accurate::lessOp(static_cast<Int64>(-1),
static_cast<UInt64>(1)));
- ASSERT_TRUE(!accurate::equalsOp(static_cast<Int64>(-1),
static_cast<UInt64>(-1)));
- ASSERT_TRUE(accurate::equalsOp(-0., 0));
- ASSERT_TRUE(accurate::lessOp(-0., 1));
- ASSERT_TRUE(accurate::lessOp(-0.5, 1));
- ASSERT_TRUE(accurate::lessOp(0.5, 1));
- ASSERT_TRUE(accurate::equalsOp(1.0, 1));
- ASSERT_TRUE(accurate::greaterOp(1.1, 1));
- ASSERT_TRUE(accurate::greaterOp(11.1, 1));
- ASSERT_TRUE(accurate::greaterOp(11.1, 11));
- ASSERT_TRUE(accurate::lessOp(-11.1, 11));
- ASSERT_TRUE(accurate::lessOp(-11.1, -11));
- ASSERT_TRUE(accurate::lessOp(-1.1, -1));
- ASSERT_TRUE(accurate::greaterOp(-1.1, -2));
- ASSERT_TRUE(accurate::greaterOp(1000., 100));
- ASSERT_TRUE(accurate::greaterOp(-100., -1000));
- ASSERT_TRUE(accurate::lessOp(100., 1000));
- ASSERT_TRUE(accurate::lessOp(-1000., -100));
-
- ASSERT_TRUE(accurate::lessOp(-std::numeric_limits<Float64>::infinity(),
0));
- ASSERT_TRUE(accurate::lessOp(-std::numeric_limits<Float64>::infinity(),
1000));
- ASSERT_TRUE(accurate::lessOp(-std::numeric_limits<Float64>::infinity(),
-1000));
- ASSERT_TRUE(accurate::greaterOp(std::numeric_limits<Float64>::infinity(),
0));
- ASSERT_TRUE(accurate::greaterOp(std::numeric_limits<Float64>::infinity(),
1000));
- ASSERT_TRUE(accurate::greaterOp(std::numeric_limits<Float64>::infinity(),
-1000));
-
- ASSERT_TRUE(accurate::lessOp(1, 1e100));
- ASSERT_TRUE(accurate::lessOp(-1, 1e100));
- ASSERT_TRUE(accurate::lessOp(-1e100, 1));
- ASSERT_TRUE(accurate::lessOp(-1e100, -1));
-
- ASSERT_TRUE(accurate::equalsOp(static_cast<UInt64>(9223372036854775808ULL),
-
static_cast<Float64>(9223372036854775808ULL)));
- ASSERT_TRUE(accurate::equalsOp(static_cast<UInt64>(9223372036854775808ULL),
-
static_cast<Float32>(9223372036854775808ULL)));
- ASSERT_TRUE(accurate::lessOp(static_cast<UInt8>(255), 300));
- ASSERT_TRUE(accurate::lessOp(static_cast<UInt8>(255),
static_cast<Int16>(300)));
- ASSERT_TRUE(accurate::notEqualsOp(static_cast<UInt8>(255), 44));
- ASSERT_TRUE(accurate::notEqualsOp(static_cast<UInt8>(255),
static_cast<Int16>(44)));
+ EXPECT_TRUE((EqualsOp<TYPE_INT>::apply(1, 1)));
+ EXPECT_FALSE((EqualsOp<TYPE_INT>::apply(1, 2)));
+ EXPECT_TRUE((NotEqualsOp<TYPE_INT>::apply(1, 2)));
+ EXPECT_FALSE((NotEqualsOp<TYPE_INT>::apply(1, 1)));
+ EXPECT_TRUE((LessOp<TYPE_INT>::apply(1, 2)));
+ EXPECT_FALSE((LessOp<TYPE_INT>::apply(2, 1)));
+ EXPECT_TRUE((GreaterOp<TYPE_INT>::apply(2, 1)));
+ EXPECT_FALSE((GreaterOp<TYPE_INT>::apply(1, 2)));
+ EXPECT_TRUE((LessOrEqualsOp<TYPE_INT>::apply(1, 2)));
+ EXPECT_TRUE((LessOrEqualsOp<TYPE_INT>::apply(1, 1)));
+ EXPECT_FALSE((LessOrEqualsOp<TYPE_INT>::apply(2, 1)));
+ EXPECT_TRUE((GreaterOrEqualsOp<TYPE_INT>::apply(2, 1)));
+ EXPECT_TRUE((GreaterOrEqualsOp<TYPE_INT>::apply(1, 1)));
}
} // namespace doris::vectorized
diff --git a/regression-test/data/correctness/test_compare_float.out
b/regression-test/data/correctness/test_compare_float.out
index 78948c17b4d..9cab3a3e06f 100644
--- a/regression-test/data/correctness/test_compare_float.out
+++ b/regression-test/data/correctness/test_compare_float.out
@@ -5,7 +5,6 @@
3 114514.0
4 Infinity
5 -Infinity
-6 -0.0
7 0.0
8 NaN
9 NaN
@@ -13,7 +12,6 @@
-- !sql1 --
5 -Infinity
2 -123.0
-6 -0.0
7 0.0
1 123.0
3 114514.0
@@ -24,7 +22,6 @@
-- !sql2 --
-Infinity true
-123.0 true
--0.0 true
0.0 true
123.0 true
114514.0 true
@@ -35,7 +32,6 @@ NaN false
-- !sql3 --
-Infinity true
-123.0 true
--0.0 true
0.0 true
123.0 true
114514.0 true
@@ -46,7 +42,6 @@ NaN true
-- !sql4 --
-Infinity false
-123.0 false
--0.0 false
0.0 false
123.0 false
114514.0 false
@@ -57,7 +52,6 @@ NaN false
-- !sql5 --
-Infinity false
-123.0 false
--0.0 false
0.0 false
123.0 false
114514.0 false
@@ -68,7 +62,6 @@ NaN true
-- !sql6 --
-Infinity false
-123.0 false
--0.0 false
0.0 false
123.0 false
114514.0 false
@@ -79,7 +72,6 @@ NaN true
-- !sql7 --
-Infinity true
-123.0 true
--0.0 true
0.0 true
123.0 true
114514.0 true
diff --git a/regression-test/suites/correctness/test_compare_float.groovy
b/regression-test/suites/correctness/test_compare_float.groovy
index 3df3b6aa05f..86d2fc6f88c 100644
--- a/regression-test/suites/correctness/test_compare_float.groovy
+++ b/regression-test/suites/correctness/test_compare_float.groovy
@@ -37,7 +37,7 @@ suite("test_compare_float") {
sql """
- insert into sort_float
values(1,'123'),(2,'-123'),(3,'114514'),(4,'+inf'),(5,'-inf'),(6,'-0'),(7,'+0'),(8,'Nan'),(9,'Nan');
+ insert into sort_float
values(1,'123'),(2,'-123'),(3,'114514'),(4,'+inf'),(5,'-inf'),(7,'+0'),(8,'Nan'),(9,'Nan');
"""
qt_sql """
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
