mirror of
https://github.com/ClickHouse/ClickHouse.git
synced 2024-11-22 07:31:57 +00:00
211 lines
7.3 KiB
C++
211 lines
7.3 KiB
C++
#pragma once
|
|
|
|
#include <type_traits>
|
|
|
|
#include <Core/Types.h>
|
|
#include <Common/UInt128.h>
|
|
|
|
|
|
namespace DB
|
|
{
|
|
|
|
/** Allows get the result type of the functions +, -, *, /, %, intDiv (integer division).
|
|
* The rules are different from those used in C++.
|
|
*/
|
|
|
|
namespace NumberTraits
|
|
{
|
|
|
|
struct Error {};
|
|
|
|
constexpr size_t max(size_t x, size_t y)
|
|
{
|
|
return x > y ? x : y;
|
|
}
|
|
|
|
constexpr size_t min(size_t x, size_t y)
|
|
{
|
|
return x < y ? x : y;
|
|
}
|
|
|
|
constexpr size_t nextSize(size_t size)
|
|
{
|
|
return min(size * 2, 8);
|
|
}
|
|
|
|
template <bool is_signed, bool is_floating, size_t size>
|
|
struct Construct
|
|
{
|
|
using Type = Error;
|
|
};
|
|
|
|
template <> struct Construct<false, false, 1> { using Type = UInt8; };
|
|
template <> struct Construct<false, false, 2> { using Type = UInt16; };
|
|
template <> struct Construct<false, false, 4> { using Type = UInt32; };
|
|
template <> struct Construct<false, false, 8> { using Type = UInt64; };
|
|
template <> struct Construct<false, true, 1> { using Type = Float32; };
|
|
template <> struct Construct<false, true, 2> { using Type = Float32; };
|
|
template <> struct Construct<false, true, 4> { using Type = Float32; };
|
|
template <> struct Construct<false, true, 8> { using Type = Float64; };
|
|
template <> struct Construct<true, false, 1> { using Type = Int8; };
|
|
template <> struct Construct<true, false, 2> { using Type = Int16; };
|
|
template <> struct Construct<true, false, 4> { using Type = Int32; };
|
|
template <> struct Construct<true, false, 8> { using Type = Int64; };
|
|
template <> struct Construct<true, true, 1> { using Type = Float32; };
|
|
template <> struct Construct<true, true, 2> { using Type = Float32; };
|
|
template <> struct Construct<true, true, 4> { using Type = Float32; };
|
|
template <> struct Construct<true, true, 8> { using Type = Float64; };
|
|
|
|
|
|
/** The result of addition or multiplication is calculated according to the following rules:
|
|
* - if one of the arguments is floating-point, the result is a floating point, otherwise - the whole;
|
|
* - if one of the arguments is signed, the result is signed, otherwise it is unsigned;
|
|
* - the result contains more bits (not only meaningful) than the maximum in the arguments
|
|
* (for example, UInt8 + Int32 = Int64).
|
|
*/
|
|
template <typename A, typename B> struct ResultOfAdditionMultiplication
|
|
{
|
|
using Type = typename Construct<
|
|
is_signed_v<A> || is_signed_v<B>,
|
|
std::is_floating_point_v<A> || std::is_floating_point_v<B>,
|
|
nextSize(max(sizeof(A), sizeof(B)))>::Type;
|
|
};
|
|
|
|
template <typename A, typename B> struct ResultOfSubtraction
|
|
{
|
|
using Type = typename Construct<
|
|
true,
|
|
std::is_floating_point_v<A> || std::is_floating_point_v<B>,
|
|
nextSize(max(sizeof(A), sizeof(B)))>::Type;
|
|
};
|
|
|
|
/** When dividing, you always get a floating-point number.
|
|
*/
|
|
template <typename A, typename B> struct ResultOfFloatingPointDivision
|
|
{
|
|
using Type = Float64;
|
|
};
|
|
|
|
/** For integer division, we get a number with the same number of bits as in divisible.
|
|
*/
|
|
template <typename A, typename B> struct ResultOfIntegerDivision
|
|
{
|
|
using Type = typename Construct<
|
|
is_signed_v<A> || is_signed_v<B>,
|
|
false,
|
|
sizeof(A)>::Type;
|
|
};
|
|
|
|
/** Division with remainder you get a number with the same number of bits as in divisor.
|
|
*/
|
|
template <typename A, typename B> struct ResultOfModulo
|
|
{
|
|
using Type = typename Construct<
|
|
is_signed_v<A> || is_signed_v<B>,
|
|
false,
|
|
sizeof(B)>::Type;
|
|
};
|
|
|
|
template <typename A> struct ResultOfNegate
|
|
{
|
|
using Type = typename Construct<
|
|
true,
|
|
std::is_floating_point_v<A>,
|
|
is_signed_v<A> ? sizeof(A) : nextSize(sizeof(A))>::Type;
|
|
};
|
|
|
|
template <typename A> struct ResultOfAbs
|
|
{
|
|
using Type = typename Construct<
|
|
false,
|
|
std::is_floating_point_v<A>,
|
|
sizeof(A)>::Type;
|
|
};
|
|
|
|
/** For bitwise operations, an integer is obtained with number of bits is equal to the maximum of the arguments.
|
|
*/
|
|
template <typename A, typename B> struct ResultOfBit
|
|
{
|
|
using Type = typename Construct<
|
|
is_signed_v<A> || is_signed_v<B>,
|
|
false,
|
|
std::is_floating_point_v<A> || std::is_floating_point_v<B> ? 8 : max(sizeof(A), sizeof(B))>::Type;
|
|
};
|
|
|
|
template <typename A> struct ResultOfBitNot
|
|
{
|
|
using Type = typename Construct<
|
|
is_signed_v<A>,
|
|
false,
|
|
sizeof(A)>::Type;
|
|
};
|
|
|
|
|
|
/** Type casting for `if` function:
|
|
* UInt<x>, UInt<y> -> UInt<max(x,y)>
|
|
* Int<x>, Int<y> -> Int<max(x,y)>
|
|
* Float<x>, Float<y> -> Float<max(x, y)>
|
|
* UInt<x>, Int<y> -> Int<max(x*2, y)>
|
|
* Float<x>, [U]Int<y> -> Float<max(x, y*2)>
|
|
* Decimal<x>, Decimal<y> -> Decimal<max(x,y)>
|
|
* UUID, UUID -> UUID
|
|
* UInt64 , Int<x> -> Error
|
|
* Float<x>, [U]Int64 -> Error
|
|
*/
|
|
template <typename A, typename B>
|
|
struct ResultOfIf
|
|
{
|
|
static constexpr bool has_float = std::is_floating_point_v<A> || std::is_floating_point_v<B>;
|
|
static constexpr bool has_integer = is_integral_v<A> || is_integral_v<B>;
|
|
static constexpr bool has_signed = is_signed_v<A> || is_signed_v<B>;
|
|
static constexpr bool has_unsigned = !is_signed_v<A> || !is_signed_v<B>;
|
|
|
|
static constexpr size_t max_size_of_unsigned_integer = max(is_signed_v<A> ? 0 : sizeof(A), is_signed_v<B> ? 0 : sizeof(B));
|
|
static constexpr size_t max_size_of_signed_integer = max(is_signed_v<A> ? sizeof(A) : 0, is_signed_v<B> ? sizeof(B) : 0);
|
|
static constexpr size_t max_size_of_integer = max(is_integral_v<A> ? sizeof(A) : 0, is_integral_v<B> ? sizeof(B) : 0);
|
|
static constexpr size_t max_size_of_float = max(std::is_floating_point_v<A> ? sizeof(A) : 0, std::is_floating_point_v<B> ? sizeof(B) : 0);
|
|
|
|
using ConstructedType = typename Construct<has_signed, has_float,
|
|
((has_float && has_integer && max_size_of_integer >= max_size_of_float)
|
|
|| (has_signed && has_unsigned && max_size_of_unsigned_integer >= max_size_of_signed_integer))
|
|
? max(sizeof(A), sizeof(B)) * 2
|
|
: max(sizeof(A), sizeof(B))>::Type;
|
|
|
|
using ConstructedWithUUID = std::conditional_t<std::is_same_v<A, UInt128> && std::is_same_v<B, UInt128>, A, ConstructedType>;
|
|
|
|
using Type = std::conditional_t<!IsDecimalNumber<A> && !IsDecimalNumber<B>, ConstructedWithUUID,
|
|
std::conditional_t<IsDecimalNumber<A> && IsDecimalNumber<B>, std::conditional_t<(sizeof(A) > sizeof(B)), A, B>, Error>>;
|
|
};
|
|
|
|
/** Before applying operator `%` and bitwise operations, operands are casted to whole numbers. */
|
|
template <typename A> struct ToInteger
|
|
{
|
|
using Type = typename Construct<
|
|
is_signed_v<A>,
|
|
false,
|
|
std::is_floating_point_v<A> ? 8 : sizeof(A)>::Type;
|
|
};
|
|
|
|
|
|
// CLICKHOUSE-29. The same depth, different signs
|
|
// NOTE: This case is applied for 64-bit integers only (for backward compatibility), but could be used for any-bit integers
|
|
template <typename A, typename B>
|
|
constexpr bool LeastGreatestSpecialCase =
|
|
is_integral_v<A> && is_integral_v<B>
|
|
&& (8 == sizeof(A) && sizeof(A) == sizeof(B))
|
|
&& (is_signed_v<A> ^ is_signed_v<B>);
|
|
|
|
template <typename A, typename B>
|
|
using ResultOfLeast = std::conditional_t<LeastGreatestSpecialCase<A, B>,
|
|
typename Construct<true, false, sizeof(A)>::Type,
|
|
typename ResultOfIf<A, B>::Type>;
|
|
|
|
template <typename A, typename B>
|
|
using ResultOfGreatest = std::conditional_t<LeastGreatestSpecialCase<A, B>,
|
|
typename Construct<false, false, sizeof(A)>::Type,
|
|
typename ResultOfIf<A, B>::Type>;
|
|
|
|
}
|
|
|
|
}
|