thevar1able/ClickHouse
1
0
Fork 0
mirror of https://github.com/ClickHouse/ClickHouse.git synced 2024-11-29 11:02:08 +00:00
Code Issues Packages Projects Releases Wiki Activity

Simplified customizing add/substract-Interval functions for DateTime64

Browse Source
This commit is contained in:
Vasily Nemkov 2019-10-10 16:49:40 +03:00
parent 7afff3d661
commit fb4dbf94e9
9 changed files with 102 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

141
dbms/src/Functions/FunctionDateOrDateTimeAddInterval.h
View File

@ -22,24 +22,25 @@ namespace ErrorCodes
extern const int ILLEGAL_COLUMN; extern const int ILLEGAL_COLUMN;
} }
// TODO(vnemkov): in order to be overloadable for specific implementation, make this a base class /// AddOnDateTime64DefaultImpl provides default implementation of add-X functionality for DateTime64.
///
/// Default implementation is not to change fractional part, but only modify whole part as if it was DateTime.
/// That means large whole values (for scale less than 9) might not fit into UInt32-range,
/// and hence default implementation will produce incorrect results.
template <typename T> template <typename T>
struct AddOnDateTime64Mixin : public T struct AddOnDateTime64DefaultImpl
{ {
/*explicit*/ AddOnDateTime64Mixin(UInt32 scale_ = 0) /*explicit*/ AddOnDateTime64DefaultImpl(UInt32 scale_ = 0)
: scale_multiplier(decimalScaleMultiplier<DateTime64::NativeType>(scale_)), : scale_multiplier(decimalScaleMultiplier<DateTime64::NativeType>(scale_)),
fractional_divider(decimalFractionalDivider<DateTime64>(scale_)) fractional_divider(decimalFractionalDivider<DateTime64>(scale_))
{} {}
using T::execute; // Default implementation for add/sub on DateTime64: do math on whole part (the same way as for DateTime), leave fractional as it is.
// Default implementation for add/sub on DateTime64: do math on whole part, leave fractional as it is.
inline DateTime64 execute(const DateTime64 & t, Int64 delta, const DateLUTImpl & time_zone) const inline DateTime64 execute(const DateTime64 & t, Int64 delta, const DateLUTImpl & time_zone) const
{ {
const auto components = decimalSplitWithScaleMultiplier(t, scale_multiplier); const auto components = decimalSplitWithScaleMultiplier(t, scale_multiplier);
// const auto components = decimalSplitWithScaleMultiplier(t, scale); // const auto components = decimalSplitWithScaleMultiplier(t, scale);
// TODO (vnemkov): choose proper overload: UInt64 if available, UInt32 otherwise. const auto whole = static_cast<const T*>(this)->execute(static_cast<UInt32>(components.whole), delta, time_zone);
const auto whole = T::execute(static_cast<UInt32>(components.whole), delta, time_zone);
return decimalFromComponentsWithMultipliers<DateTime64>(static_cast<DateTime64::NativeType>(whole), components.fractional, scale_multiplier, fractional_divider); return decimalFromComponentsWithMultipliers<DateTime64>(static_cast<DateTime64::NativeType>(whole), components.fractional, scale_multiplier, fractional_divider);
// return decimalFromComponents<DateTime64>(static_cast<DateTime64::NativeType>(whole), components.fractional, scale); // return decimalFromComponents<DateTime64>(static_cast<DateTime64::NativeType>(whole), components.fractional, scale);
@ -50,8 +51,22 @@ struct AddOnDateTime64Mixin : public T
}; };
struct AddSecondsImpl /// Type of first argument of 'execute' function overload defines what INPUT DataType it is used for.
/// Return type defines what is the OUTPUT (return) type of the CH function.
/// Corresponding types:
/// - UInt16 => DataTypeDate
/// - UInt32 => DataTypeDateTime
/// - DateTime64 => DataTypeDateTime64
/// Please note that INPUT and OUTPUT types may differ, e.g.:
/// - 'AddSecondsImpl::execute(UInt32, ...) -> UInt32' is available to the ClickHouse users as 'addSeconds(DateTime, ...) -> DateTime'
/// - 'AddSecondsImpl::execute(UInt16, ...) -> UInt32' is available to the ClickHouse users as 'addSeconds(Date, ...) -> DateTime'
struct AddSecondsImpl : public AddOnDateTime64DefaultImpl<AddSecondsImpl>
{ {
using Base = AddOnDateTime64DefaultImpl<AddSecondsImpl>;
using Base::Base;
using Base::execute;
static constexpr auto name = "addSeconds"; static constexpr auto name = "addSeconds";
static inline UInt32 execute(UInt32 t, Int64 delta, const DateLUTImpl &) static inline UInt32 execute(UInt32 t, Int64 delta, const DateLUTImpl &)
@ -65,8 +80,12 @@ struct AddSecondsImpl
} }
}; };
struct AddMinutesImpl struct AddMinutesImpl : public AddOnDateTime64DefaultImpl<AddMinutesImpl>
{ {
using Base = AddOnDateTime64DefaultImpl<AddMinutesImpl>;
using Base::Base;
using Base::execute;
static constexpr auto name = "addMinutes"; static constexpr auto name = "addMinutes";
static inline UInt32 execute(UInt32 t, Int64 delta, const DateLUTImpl &) static inline UInt32 execute(UInt32 t, Int64 delta, const DateLUTImpl &)
@ -80,8 +99,12 @@ struct AddMinutesImpl
} }
}; };
struct AddHoursImpl struct AddHoursImpl : public AddOnDateTime64DefaultImpl<AddHoursImpl>
{ {
using Base = AddOnDateTime64DefaultImpl<AddHoursImpl>;
using Base::Base;
using Base::execute;
static constexpr auto name = "addHours"; static constexpr auto name = "addHours";
static inline UInt32 execute(UInt32 t, Int64 delta, const DateLUTImpl &) static inline UInt32 execute(UInt32 t, Int64 delta, const DateLUTImpl &)
@ -95,8 +118,12 @@ struct AddHoursImpl
} }
}; };
struct AddDaysImpl struct AddDaysImpl : public AddOnDateTime64DefaultImpl<AddDaysImpl>
{ {
using Base = AddOnDateTime64DefaultImpl<AddDaysImpl>;
using Base::Base;
using Base::execute;
static constexpr auto name = "addDays"; static constexpr auto name = "addDays";
// static inline UInt32 execute(UInt64 t, Int64 delta, const DateLUTImpl & time_zone) // static inline UInt32 execute(UInt64 t, Int64 delta, const DateLUTImpl & time_zone)
@ -116,8 +143,12 @@ struct AddDaysImpl
} }
}; };
struct AddWeeksImpl struct AddWeeksImpl : public AddOnDateTime64DefaultImpl<AddWeeksImpl>
{ {
using Base = AddOnDateTime64DefaultImpl<AddWeeksImpl>;
using Base::Base;
using Base::execute;
static constexpr auto name = "addWeeks"; static constexpr auto name = "addWeeks";
static inline UInt32 execute(UInt32 t, Int64 delta, const DateLUTImpl & time_zone) static inline UInt32 execute(UInt32 t, Int64 delta, const DateLUTImpl & time_zone)
@ -131,8 +162,12 @@ struct AddWeeksImpl
} }
}; };
struct AddMonthsImpl struct AddMonthsImpl : public AddOnDateTime64DefaultImpl<AddMonthsImpl>
{ {
using Base = AddOnDateTime64DefaultImpl<AddMonthsImpl>;
using Base::Base;
using Base::execute;
static constexpr auto name = "addMonths"; static constexpr auto name = "addMonths";
static inline UInt32 execute(UInt32 t, Int64 delta, const DateLUTImpl & time_zone) static inline UInt32 execute(UInt32 t, Int64 delta, const DateLUTImpl & time_zone)
@ -146,8 +181,12 @@ struct AddMonthsImpl
} }
}; };
struct AddQuartersImpl struct AddQuartersImpl : public AddOnDateTime64DefaultImpl<AddQuartersImpl>
{ {
using Base = AddOnDateTime64DefaultImpl<AddQuartersImpl>;
using Base::Base;
using Base::execute;
static constexpr auto name = "addQuarters"; static constexpr auto name = "addQuarters";
static inline UInt32 execute(UInt32 t, Int64 delta, const DateLUTImpl & time_zone) static inline UInt32 execute(UInt32 t, Int64 delta, const DateLUTImpl & time_zone)
@ -161,8 +200,12 @@ struct AddQuartersImpl
} }
}; };
struct AddYearsImpl struct AddYearsImpl : public AddOnDateTime64DefaultImpl<AddYearsImpl>
{ {
using Base = AddOnDateTime64DefaultImpl<AddYearsImpl>;
using Base::Base;
using Base::execute;
static constexpr auto name = "addYears"; static constexpr auto name = "addYears";
static inline UInt32 execute(UInt32 t, Int64 delta, const DateLUTImpl & time_zone) static inline UInt32 execute(UInt32 t, Int64 delta, const DateLUTImpl & time_zone)
@ -176,28 +219,27 @@ struct AddYearsImpl
} }
}; };
template <typename Transform> template <typename Transform>
struct SubtractIntervalImpl struct SubtractIntervalImpl : public Transform
{ {
template <typename T> using Transform::Transform;
static
inline decltype(Transform::execute(T{}, Int64{}, DateLUTImpl{""})) // to preserve return type of Transfor::execute and allow promoting/denoting types.
execute(T t, Int64 delta, const DateLUTImpl & time_zone)
{
template <typename T>
inline decltype(std::declval<Transform>().execute(T{}, Int64{}, DateLUTImpl{""})) // to preserve return type of Transfor::execute and allow promoting/denoting types.
execute(T t, Int64 delta, const DateLUTImpl & time_zone) const
{
return Transform::execute(t, -delta, time_zone); return Transform::execute(t, -delta, time_zone);
} }
}; };
struct SubtractSecondsImpl : AddOnDateTime64Mixin<SubtractIntervalImpl<AddSecondsImpl>> { static constexpr auto name = "subtractSeconds"; }; struct SubtractSecondsImpl : SubtractIntervalImpl<AddSecondsImpl> { static constexpr auto name = "subtractSeconds"; };
struct SubtractMinutesImpl : AddOnDateTime64Mixin<SubtractIntervalImpl<AddMinutesImpl>> { static constexpr auto name = "subtractMinutes"; }; struct SubtractMinutesImpl : SubtractIntervalImpl<AddMinutesImpl> { static constexpr auto name = "subtractMinutes"; };
struct SubtractHoursImpl : AddOnDateTime64Mixin<SubtractIntervalImpl<AddHoursImpl>> { static constexpr auto name = "subtractHours"; }; struct SubtractHoursImpl : SubtractIntervalImpl<AddHoursImpl> { static constexpr auto name = "subtractHours"; };
struct SubtractDaysImpl : AddOnDateTime64Mixin<SubtractIntervalImpl<AddDaysImpl>> { static constexpr auto name = "subtractDays"; }; struct SubtractDaysImpl : SubtractIntervalImpl<AddDaysImpl> { static constexpr auto name = "subtractDays"; };
struct SubtractWeeksImpl : AddOnDateTime64Mixin<SubtractIntervalImpl<AddWeeksImpl>> { static constexpr auto name = "subtractWeeks"; }; struct SubtractWeeksImpl : SubtractIntervalImpl<AddWeeksImpl> { static constexpr auto name = "subtractWeeks"; };
struct SubtractMonthsImpl : AddOnDateTime64Mixin<SubtractIntervalImpl<AddMonthsImpl>> { static constexpr auto name = "subtractMonths"; }; struct SubtractMonthsImpl : SubtractIntervalImpl<AddMonthsImpl> { static constexpr auto name = "subtractMonths"; };
struct SubtractQuartersImpl : AddOnDateTime64Mixin<SubtractIntervalImpl<AddQuartersImpl>> { static constexpr auto name = "subtractQuarters"; }; struct SubtractQuartersImpl : SubtractIntervalImpl<AddQuartersImpl> { static constexpr auto name = "subtractQuarters"; };
struct SubtractYearsImpl : AddOnDateTime64Mixin<SubtractIntervalImpl<AddYearsImpl>> { static constexpr auto name = "subtractYears"; }; struct SubtractYearsImpl : SubtractIntervalImpl<AddYearsImpl> { static constexpr auto name = "subtractYears"; };
template <typename Transform> template <typename Transform>
@ -210,7 +252,7 @@ struct Adder
{} {}
template <typename FromVectorType, typename ToVectorType> template <typename FromVectorType, typename ToVectorType>
void vector_vector(const FromVectorType & vec_from, ToVectorType & vec_to, const IColumn & delta, const DateLUTImpl & time_zone) void vector_vector(const FromVectorType & vec_from, ToVectorType & vec_to, const IColumn & delta, const DateLUTImpl & time_zone) const
{ {
size_t size = vec_from.size(); size_t size = vec_from.size();
vec_to.resize(size); vec_to.resize(size);
@ -220,7 +262,7 @@ struct Adder
} }
template <typename FromVectorType, typename ToVectorType> template <typename FromVectorType, typename ToVectorType>
void vector_constant(const FromVectorType & vec_from, ToVectorType & vec_to, Int64 delta, const DateLUTImpl & time_zone) void vector_constant(const FromVectorType & vec_from, ToVectorType & vec_to, Int64 delta, const DateLUTImpl & time_zone) const
{ {
size_t size = vec_from.size(); size_t size = vec_from.size();
vec_to.resize(size); vec_to.resize(size);
@ -230,7 +272,7 @@ struct Adder
} }
template <typename FromType, typename ToVectorType> template <typename FromType, typename ToVectorType>
void constant_vector(const FromType & from, ToVectorType & vec_to, const IColumn & delta, const DateLUTImpl & time_zone) void constant_vector(const FromType & from, ToVectorType & vec_to, const IColumn & delta, const DateLUTImpl & time_zone) const
{ {
size_t size = delta.size(); size_t size = delta.size();
vec_to.resize(size); vec_to.resize(size);
@ -283,6 +325,16 @@ struct DateTimeAddIntervalImpl
} }
}; };
namespace date_and_time_type_details
{
// Compile-time mapping of value (DataType::FieldType) types to corresponding DataType
template <typename FieldType> struct ResultDataTypeMap {};
template <> struct ResultDataTypeMap<UInt16> { using ResultDataType = DataTypeDate; };
template <> struct ResultDataTypeMap<Int16> { using ResultDataType = DataTypeDate; };
template <> struct ResultDataTypeMap<UInt32> { using ResultDataType = DataTypeDateTime; };
template <> struct ResultDataTypeMap<Int32> { using ResultDataType = DataTypeDateTime; };
template <> struct ResultDataTypeMap<DateTime64> { using ResultDataType = DataTypeDateTime64; };
}
template <typename Transform> template <typename Transform>
class FunctionDateOrDateTimeAddInterval : public IFunction class FunctionDateOrDateTimeAddInterval : public IFunction
@ -332,11 +384,11 @@ public:
switch (arguments[0].type->getTypeId()) switch (arguments[0].type->getTypeId())
{ {
case TypeIndex::Date: case TypeIndex::Date:
return resolveReturnType<typename DataTypeDate::FieldType>(arguments); return resolveReturnType<DataTypeDate>(arguments);
case TypeIndex::DateTime: case TypeIndex::DateTime:
return resolveReturnType<typename DataTypeDateTime::FieldType>(arguments); return resolveReturnType<DataTypeDateTime>(arguments);
case TypeIndex::DateTime64: case TypeIndex::DateTime64:
return resolveReturnType<typename DataTypeDateTime64::FieldType>(arguments); return resolveReturnType<DataTypeDateTime64>(arguments);
default: default:
{ {
// TODO (vnemkov): quick and dirty way to check, remove before merging. // TODO (vnemkov): quick and dirty way to check, remove before merging.
@ -352,23 +404,16 @@ public:
template <typename FieldType> template <typename FieldType>
using TransformExecuteReturnType = decltype(std::declval<Transform>().execute(FieldType(), 0, std::declval<DateLUTImpl>())); using TransformExecuteReturnType = decltype(std::declval<Transform>().execute(FieldType(), 0, std::declval<DateLUTImpl>()));
template <typename FieldType> struct ResultDataTypeMap {};
template <> struct ResultDataTypeMap<UInt16> { using ResultDataType = DataTypeDate; };
template <> struct ResultDataTypeMap<Int16> { using ResultDataType = DataTypeDate; };
template <> struct ResultDataTypeMap<UInt32> { using ResultDataType = DataTypeDateTime; };
template <> struct ResultDataTypeMap<Int32> { using ResultDataType = DataTypeDateTime; };
template <> struct ResultDataTypeMap<DateTime64> { using ResultDataType = DataTypeDateTime64; };
// Deduces result DataType from argument data type, based on return type of Transform{}.execute(from, UInt64, DateLUTImpl). // Deduces result DataType from argument data type, based on return type of Transform{}.execute(from, UInt64, DateLUTImpl).
// e.g. for Transform-type that has execute()-overload with 'UInt16' input and 'UInt32' return, // e.g. for Transform-type that has execute()-overload with 'UInt16' input and 'UInt32' return,
// argument type is expected to be 'Date', and result type is deduced to be 'DateTime'. // argument type is expected to be 'Date', and result type is deduced to be 'DateTime'.
template <typename FromFieldType> template <typename FromFieldType>
using TransformResultDataType = typename ResultDataTypeMap<TransformExecuteReturnType<FromFieldType>>::ResultDataType; using TransformResultDataType = typename date_and_time_type_details::ResultDataTypeMap<TransformExecuteReturnType<FromFieldType>>::ResultDataType;
template <typename FieldType> template <typename FromDataType>
DataTypePtr resolveReturnType(const ColumnsWithTypeAndName & arguments) const DataTypePtr resolveReturnType(const ColumnsWithTypeAndName & arguments) const
{ {
using ResultDataType = TransformResultDataType<FieldType>; using ResultDataType = TransformResultDataType<typename FromDataType::FieldType>;
if constexpr (std::is_same_v<ResultDataType, DataTypeDate>) if constexpr (std::is_same_v<ResultDataType, DataTypeDate>)
return std::make_shared<DataTypeDate>(); return std::make_shared<DataTypeDate>();
@ -378,6 +423,8 @@ public:
} }
else if constexpr (std::is_same_v<ResultDataType, DataTypeDateTime64>) else if constexpr (std::is_same_v<ResultDataType, DataTypeDateTime64>)
{ {
// TODO (vnemkov): what if there is an overload of Transform::execute() that returns DateTime64 from DateTime or Date ?
// Shall we use the default scale or one from optional argument ?
const auto & datetime64_type = assert_cast<const DataTypeDateTime64 &>(*arguments[0].type); const auto & datetime64_type = assert_cast<const DataTypeDateTime64 &>(*arguments[0].type);
return std::make_shared<DataTypeDateTime64>(datetime64_type.getScale(), extractTimeZoneNameFromFunctionArguments(arguments, 2, 0)); return std::make_shared<DataTypeDateTime64>(datetime64_type.getScale(), extractTimeZoneNameFromFunctionArguments(arguments, 2, 0));
} }

2
dbms/src/Functions/addDays.cpp
View File

@ -6,7 +6,7 @@
namespace DB namespace DB
{ {
using FunctionAddDays = FunctionDateOrDateTimeAddInterval<AddOnDateTime64Mixin<AddDaysImpl>>; using FunctionAddDays = FunctionDateOrDateTimeAddInterval<AddDaysImpl>;
void registerFunctionAddDays(FunctionFactory & factory) void registerFunctionAddDays(FunctionFactory & factory)
{ {

2
dbms/src/Functions/addHours.cpp
View File

@ -6,7 +6,7 @@
namespace DB namespace DB
{ {
using FunctionAddHours = FunctionDateOrDateTimeAddInterval<AddOnDateTime64Mixin<AddHoursImpl>>; using FunctionAddHours = FunctionDateOrDateTimeAddInterval<AddHoursImpl>;
void registerFunctionAddHours(FunctionFactory & factory) void registerFunctionAddHours(FunctionFactory & factory)
{ {

2
dbms/src/Functions/addMinutes.cpp
View File

@ -6,7 +6,7 @@
namespace DB namespace DB
{ {
using FunctionAddMinutes = FunctionDateOrDateTimeAddInterval<AddOnDateTime64Mixin<AddMinutesImpl>>; using FunctionAddMinutes = FunctionDateOrDateTimeAddInterval<AddMinutesImpl>;
void registerFunctionAddMinutes(FunctionFactory & factory) void registerFunctionAddMinutes(FunctionFactory & factory)
{ {

2
dbms/src/Functions/addMonths.cpp
View File

@ -6,7 +6,7 @@
namespace DB namespace DB
{ {
using FunctionAddMonths = FunctionDateOrDateTimeAddInterval<AddOnDateTime64Mixin<AddMonthsImpl>>; using FunctionAddMonths = FunctionDateOrDateTimeAddInterval<AddMonthsImpl>;
void registerFunctionAddMonths(FunctionFactory & factory) void registerFunctionAddMonths(FunctionFactory & factory)
{ {

2
dbms/src/Functions/addQuarters.cpp
View File

@ -6,7 +6,7 @@
namespace DB namespace DB
{ {
using FunctionAddQuarters = FunctionDateOrDateTimeAddInterval<AddOnDateTime64Mixin<AddQuartersImpl>>; using FunctionAddQuarters = FunctionDateOrDateTimeAddInterval<AddQuartersImpl>;
void registerFunctionAddQuarters(FunctionFactory & factory) void registerFunctionAddQuarters(FunctionFactory & factory)
{ {

2
dbms/src/Functions/addSeconds.cpp
View File

@ -6,7 +6,7 @@
namespace DB namespace DB
{ {
using FunctionAddSeconds = FunctionDateOrDateTimeAddInterval<AddOnDateTime64Mixin<AddSecondsImpl>>; using FunctionAddSeconds = FunctionDateOrDateTimeAddInterval<AddSecondsImpl>;
void registerFunctionAddSeconds(FunctionFactory & factory) void registerFunctionAddSeconds(FunctionFactory & factory)
{ {

2
dbms/src/Functions/addWeeks.cpp
View File

@ -6,7 +6,7 @@
namespace DB namespace DB
{ {
using FunctionAddWeeks = FunctionDateOrDateTimeAddInterval<AddOnDateTime64Mixin<AddWeeksImpl>>; using FunctionAddWeeks = FunctionDateOrDateTimeAddInterval<AddWeeksImpl>;
void registerFunctionAddWeeks(FunctionFactory & factory) void registerFunctionAddWeeks(FunctionFactory & factory)
{ {

2
dbms/src/Functions/addYears.cpp
View File

@ -6,7 +6,7 @@
namespace DB namespace DB
{ {
using FunctionAddYears = FunctionDateOrDateTimeAddInterval<AddOnDateTime64Mixin<AddYearsImpl>>; using FunctionAddYears = FunctionDateOrDateTimeAddInterval<AddYearsImpl>;
void registerFunctionAddYears(FunctionFactory & factory) void registerFunctionAddYears(FunctionFactory & factory)
{ {