diff --git a/docs/en/sql-reference/functions/date-time-functions.md b/docs/en/sql-reference/functions/date-time-functions.md
index cc8469e82ef..0a7be3142ee 100644
--- a/docs/en/sql-reference/functions/date-time-functions.md
+++ b/docs/en/sql-reference/functions/date-time-functions.md
@@ -725,6 +725,42 @@ SELECT toDate('2016-12-27') AS date, toYearWeek(date) AS yearWeek0, toYearWeek(d
 └────────────┴───────────┴───────────┴───────────┴───────────────┘
 ```
 
+## toDaysSinceYearZero
+
+Returns for a given date, the number of days passed since [1 January 0000](https://en.wikipedia.org/wiki/Year_zero) in the [proleptic Gregorian calendar defined by ISO 8601](https://en.wikipedia.org/wiki/Gregorian_calendar#Proleptic_Gregorian_calendar). The calculation is the same as in MySQL's [`TO_DAYS()`](https://dev.mysql.com/doc/refman/8.0/en/date-and-time-functions.html#function_to-days) function.
+
+**Syntax**
+
+``` sql
+toDaysSinceYearZero(date)
+```
+
+Aliases: `TO_DAYS`
+
+**Arguments**
+
+- `date` — The date to calculate the number of days passed since year zero from. [Date](../../sql-reference/data-types/date.md) or [Date32](../../sql-reference/data-types/date32.md).
+
+**Returned value**
+
+The number of days passed since date 0000-01-01.
+
+Type: [UInt32](../../sql-reference/data-types/int-uint.md).
+
+**Example**
+
+``` sql
+SELECT toDaysSinceYearZero(toDate('2023-09-08'));
+```
+
+Result:
+
+``` text
+┌─toDaysSinceYearZero(toDate('2023-09-08')))─┐
+│                                     713569 │
+└────────────────────────────────────────────┘
+```
+
 ## age
 
 Returns the `unit` component of the difference between `startdate` and `enddate`. The difference is calculated using a precision of 1 microsecond.
diff --git a/src/Functions/DateTimeTransforms.h b/src/Functions/DateTimeTransforms.h
index a1c880f6956..a351d7fdf30 100644
--- a/src/Functions/DateTimeTransforms.h
+++ b/src/Functions/DateTimeTransforms.h
@@ -49,37 +49,37 @@ namespace ErrorCodes
 /// This factor transformation will say that the function is monotone everywhere.
 struct ZeroTransform
 {
-    static inline UInt16 execute(Int64, const DateLUTImpl &) { return 0; }
-    static inline UInt16 execute(UInt32, const DateLUTImpl &) { return 0; }
-    static inline UInt16 execute(Int32, const DateLUTImpl &) { return 0; }
-    static inline UInt16 execute(UInt16, const DateLUTImpl &) { return 0; }
+    static UInt16 execute(Int64, const DateLUTImpl &) { return 0; }
+    static UInt16 execute(UInt32, const DateLUTImpl &) { return 0; }
+    static UInt16 execute(Int32, const DateLUTImpl &) { return 0; }
+    static UInt16 execute(UInt16, const DateLUTImpl &) { return 0; }
 };
 
 struct ToDateImpl
 {
     static constexpr auto name = "toDate";
 
-    static inline UInt16 execute(const DecimalUtils::DecimalComponents<DateTime64> & t, const DateLUTImpl & time_zone)
+    static UInt16 execute(const DecimalUtils::DecimalComponents<DateTime64> & t, const DateLUTImpl & time_zone)
     {
         return static_cast<UInt16>(time_zone.toDayNum(t.whole));
     }
-    static inline UInt16 execute(Int64 t, const DateLUTImpl & time_zone)
+    static UInt16 execute(Int64 t, const DateLUTImpl & time_zone)
     {
         return UInt16(time_zone.toDayNum(t));
     }
-    static inline UInt16 execute(UInt32 t, const DateLUTImpl & time_zone)
+    static UInt16 execute(UInt32 t, const DateLUTImpl & time_zone)
     {
         return UInt16(time_zone.toDayNum(t));
     }
-    static inline UInt16 execute(Int32, const DateLUTImpl &)
+    static UInt16 execute(Int32, const DateLUTImpl &)
     {
         throwDateIsNotSupported(name);
     }
-    static inline UInt16 execute(UInt16 d, const DateLUTImpl &)
+    static UInt16 execute(UInt16 d, const DateLUTImpl &)
     {
         return d;
     }
-    static inline DecimalUtils::DecimalComponents<DateTime64> executeExtendedResult(const DecimalUtils::DecimalComponents<DateTime64> & t, const DateLUTImpl & time_zone)
+    static DecimalUtils::DecimalComponents<DateTime64> executeExtendedResult(const DecimalUtils::DecimalComponents<DateTime64> & t, const DateLUTImpl & time_zone)
     {
         return {time_zone.toDayNum(t.whole), 0};
     }
@@ -91,20 +91,20 @@ struct ToDate32Impl
 {
     static constexpr auto name = "toDate32";
 
-    static inline Int32 execute(Int64 t, const DateLUTImpl & time_zone)
+    static Int32 execute(Int64 t, const DateLUTImpl & time_zone)
     {
         return Int32(time_zone.toDayNum(t));
     }
-    static inline Int32 execute(UInt32 t, const DateLUTImpl & time_zone)
+    static Int32 execute(UInt32 t, const DateLUTImpl & time_zone)
     {
         /// Don't saturate.
         return Int32(time_zone.toDayNum<Int64>(t));
     }
-    static inline Int32 execute(Int32 d, const DateLUTImpl &)
+    static Int32 execute(Int32 d, const DateLUTImpl &)
     {
         return d;
     }
-    static inline Int32 execute(UInt16 d, const DateLUTImpl &)
+    static Int32 execute(UInt16 d, const DateLUTImpl &)
     {
         return d;
     }
@@ -116,27 +116,27 @@ struct ToStartOfDayImpl
 {
     static constexpr auto name = "toStartOfDay";
 
-    static inline UInt32 execute(const DecimalUtils::DecimalComponents<DateTime64> & t, const DateLUTImpl & time_zone)
+    static UInt32 execute(const DecimalUtils::DecimalComponents<DateTime64> & t, const DateLUTImpl & time_zone)
     {
         return static_cast<UInt32>(time_zone.toDate(static_cast<time_t>(t.whole)));
     }
-    static inline UInt32 execute(UInt32 t, const DateLUTImpl & time_zone)
+    static UInt32 execute(UInt32 t, const DateLUTImpl & time_zone)
     {
         return static_cast<UInt32>(time_zone.toDate(t));
     }
-    static inline UInt32 execute(Int32 d, const DateLUTImpl & time_zone)
+    static UInt32 execute(Int32 d, const DateLUTImpl & time_zone)
     {
         return static_cast<UInt32>(time_zone.toDate(ExtendedDayNum(d)));
     }
-    static inline UInt32 execute(UInt16 d, const DateLUTImpl & time_zone)
+    static UInt32 execute(UInt16 d, const DateLUTImpl & time_zone)
     {
         return static_cast<UInt32>(time_zone.toDate(DayNum(d)));
     }
-    static inline DecimalUtils::DecimalComponents<DateTime64> executeExtendedResult(const DecimalUtils::DecimalComponents<DateTime64> & t, const DateLUTImpl & time_zone)
+    static DecimalUtils::DecimalComponents<DateTime64> executeExtendedResult(const DecimalUtils::DecimalComponents<DateTime64> & t, const DateLUTImpl & time_zone)
     {
         return {time_zone.toDate(t.whole), 0};
     }
-    static inline Int64 executeExtendedResult(Int32 d, const DateLUTImpl & time_zone)
+    static Int64 executeExtendedResult(Int32 d, const DateLUTImpl & time_zone)
     {
         return time_zone.fromDayNum(ExtendedDayNum(d)) * DecimalUtils::scaleMultiplier<DateTime64>(DataTypeDateTime64::default_scale);
     }
@@ -148,29 +148,29 @@ struct ToMondayImpl
 {
     static constexpr auto name = "toMonday";
 
-    static inline UInt16 execute(Int64 t, const DateLUTImpl & time_zone)
+    static UInt16 execute(Int64 t, const DateLUTImpl & time_zone)
     {
         //return time_zone.toFirstDayNumOfWeek(time_zone.toDayNum(t));
         return time_zone.toFirstDayNumOfWeek(t);
     }
-    static inline UInt16 execute(UInt32 t, const DateLUTImpl & time_zone)
+    static UInt16 execute(UInt32 t, const DateLUTImpl & time_zone)
     {
         //return time_zone.toFirstDayNumOfWeek(time_zone.toDayNum(t));
         return time_zone.toFirstDayNumOfWeek(t);
     }
-    static inline UInt16 execute(Int32 d, const DateLUTImpl & time_zone)
+    static UInt16 execute(Int32 d, const DateLUTImpl & time_zone)
     {
         return time_zone.toFirstDayNumOfWeek(ExtendedDayNum(d));
     }
-    static inline UInt16 execute(UInt16 d, const DateLUTImpl & time_zone)
+    static UInt16 execute(UInt16 d, const DateLUTImpl & time_zone)
     {
         return time_zone.toFirstDayNumOfWeek(DayNum(d));
     }
-    static inline Int64 executeExtendedResult(Int64 t, const DateLUTImpl & time_zone)
+    static Int64 executeExtendedResult(Int64 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toFirstDayNumOfWeek(time_zone.toDayNum(t));
     }
-    static inline Int32 executeExtendedResult(Int32 d, const DateLUTImpl & time_zone)
+    static Int32 executeExtendedResult(Int32 d, const DateLUTImpl & time_zone)
     {
         return time_zone.toFirstDayNumOfWeek(ExtendedDayNum(d));
     }
@@ -181,27 +181,27 @@ struct ToStartOfMonthImpl
 {
     static constexpr auto name = "toStartOfMonth";
 
-    static inline UInt16 execute(Int64 t, const DateLUTImpl & time_zone)
+    static UInt16 execute(Int64 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toFirstDayNumOfMonth(time_zone.toDayNum(t));
     }
-    static inline UInt16 execute(UInt32 t, const DateLUTImpl & time_zone)
+    static UInt16 execute(UInt32 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toFirstDayNumOfMonth(time_zone.toDayNum(t));
     }
-    static inline UInt16 execute(Int32 d, const DateLUTImpl & time_zone)
+    static UInt16 execute(Int32 d, const DateLUTImpl & time_zone)
     {
         return time_zone.toFirstDayNumOfMonth(ExtendedDayNum(d));
     }
-    static inline UInt16 execute(UInt16 d, const DateLUTImpl & time_zone)
+    static UInt16 execute(UInt16 d, const DateLUTImpl & time_zone)
     {
         return time_zone.toFirstDayNumOfMonth(DayNum(d));
     }
-    static inline Int64 executeExtendedResult(Int64 t, const DateLUTImpl & time_zone)
+    static Int64 executeExtendedResult(Int64 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toFirstDayNumOfMonth(time_zone.toDayNum(t));
     }
-    static inline Int32 executeExtendedResult(Int32 d, const DateLUTImpl & time_zone)
+    static Int32 executeExtendedResult(Int32 d, const DateLUTImpl & time_zone)
     {
         return time_zone.toFirstDayNumOfMonth(ExtendedDayNum(d));
     }
@@ -213,27 +213,27 @@ struct ToLastDayOfMonthImpl
 {
     static constexpr auto name = "toLastDayOfMonth";
 
-    static inline UInt16 execute(Int64 t, const DateLUTImpl & time_zone)
+    static UInt16 execute(Int64 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toLastDayNumOfMonth(time_zone.toDayNum(t));
     }
-    static inline UInt16 execute(UInt32 t, const DateLUTImpl & time_zone)
+    static UInt16 execute(UInt32 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toLastDayNumOfMonth(time_zone.toDayNum(t));
     }
-    static inline UInt16 execute(Int32 d, const DateLUTImpl & time_zone)
+    static UInt16 execute(Int32 d, const DateLUTImpl & time_zone)
     {
         return time_zone.toLastDayNumOfMonth(ExtendedDayNum(d));
     }
-    static inline UInt16 execute(UInt16 d, const DateLUTImpl & time_zone)
+    static UInt16 execute(UInt16 d, const DateLUTImpl & time_zone)
     {
         return time_zone.toLastDayNumOfMonth(DayNum(d));
     }
-    static inline Int64 executeExtendedResult(Int64 t, const DateLUTImpl & time_zone)
+    static Int64 executeExtendedResult(Int64 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toLastDayNumOfMonth(time_zone.toDayNum(t));
     }
-    static inline Int32 executeExtendedResult(Int32 d, const DateLUTImpl & time_zone)
+    static Int32 executeExtendedResult(Int32 d, const DateLUTImpl & time_zone)
     {
         return time_zone.toLastDayNumOfMonth(ExtendedDayNum(d));
     }
@@ -244,27 +244,27 @@ struct ToStartOfQuarterImpl
 {
     static constexpr auto name = "toStartOfQuarter";
 
-    static inline UInt16 execute(Int64 t, const DateLUTImpl & time_zone)
+    static UInt16 execute(Int64 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toFirstDayNumOfQuarter(time_zone.toDayNum(t));
     }
-    static inline UInt16 execute(UInt32 t, const DateLUTImpl & time_zone)
+    static UInt16 execute(UInt32 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toFirstDayNumOfQuarter(time_zone.toDayNum(t));
     }
-    static inline UInt16 execute(Int32 d, const DateLUTImpl & time_zone)
+    static UInt16 execute(Int32 d, const DateLUTImpl & time_zone)
     {
         return time_zone.toFirstDayNumOfQuarter(ExtendedDayNum(d));
     }
-    static inline UInt16 execute(UInt16 d, const DateLUTImpl & time_zone)
+    static UInt16 execute(UInt16 d, const DateLUTImpl & time_zone)
     {
         return time_zone.toFirstDayNumOfQuarter(DayNum(d));
     }
-    static inline Int64 executeExtendedResult(Int64 t, const DateLUTImpl & time_zone)
+    static Int64 executeExtendedResult(Int64 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toFirstDayNumOfQuarter(time_zone.toDayNum(t));
     }
-    static inline Int32 executeExtendedResult(Int32 d, const DateLUTImpl & time_zone)
+    static Int32 executeExtendedResult(Int32 d, const DateLUTImpl & time_zone)
     {
         return time_zone.toFirstDayNumOfQuarter(ExtendedDayNum(d));
     }
@@ -275,27 +275,27 @@ struct ToStartOfYearImpl
 {
     static constexpr auto name = "toStartOfYear";
 
-    static inline UInt16 execute(Int64 t, const DateLUTImpl & time_zone)
+    static UInt16 execute(Int64 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toFirstDayNumOfYear(time_zone.toDayNum(t));
     }
-    static inline UInt16 execute(UInt32 t, const DateLUTImpl & time_zone)
+    static UInt16 execute(UInt32 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toFirstDayNumOfYear(time_zone.toDayNum(t));
     }
-    static inline UInt16 execute(Int32 d, const DateLUTImpl & time_zone)
+    static UInt16 execute(Int32 d, const DateLUTImpl & time_zone)
     {
         return time_zone.toFirstDayNumOfYear(ExtendedDayNum(d));
     }
-    static inline UInt16 execute(UInt16 d, const DateLUTImpl & time_zone)
+    static UInt16 execute(UInt16 d, const DateLUTImpl & time_zone)
     {
         return time_zone.toFirstDayNumOfYear(DayNum(d));
     }
-    static inline Int64 executeExtendedResult(Int64 t, const DateLUTImpl & time_zone)
+    static Int64 executeExtendedResult(Int64 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toFirstDayNumOfYear(time_zone.toDayNum(t));
     }
-    static inline Int32 executeExtendedResult(Int32 d, const DateLUTImpl & time_zone)
+    static Int32 executeExtendedResult(Int32 d, const DateLUTImpl & time_zone)
     {
         return time_zone.toFirstDayNumOfYear(ExtendedDayNum(d));
     }
@@ -313,19 +313,19 @@ struct ToTimeImpl
     {
         return static_cast<UInt32>(time_zone.toTime(t.whole) + 86400);
     }
-    static inline UInt32 execute(UInt32 t, const DateLUTImpl & time_zone)
+    static UInt32 execute(UInt32 t, const DateLUTImpl & time_zone)
     {
         return static_cast<UInt32>(time_zone.toTime(t) + 86400);
     }
-    static inline UInt32 execute(Int32, const DateLUTImpl &)
+    static UInt32 execute(Int32, const DateLUTImpl &)
     {
-        throwDateTimeIsNotSupported(name);
+        throwDateIsNotSupported(name);
     }
-    static inline UInt32 execute(UInt16, const DateLUTImpl &)
+    static UInt32 execute(UInt16, const DateLUTImpl &)
     {
-        throwDateTimeIsNotSupported(name);
+        throwDateIsNotSupported(name);
     }
-    static inline constexpr bool hasPreimage() { return false; }
+    static constexpr bool hasPreimage() { return false; }
 
     using FactorTransform = ToDateImpl;
 };
@@ -334,27 +334,27 @@ struct ToStartOfMinuteImpl
 {
     static constexpr auto name = "toStartOfMinute";
 
-    static inline UInt32 execute(const DecimalUtils::DecimalComponents<DateTime64> & t, const DateLUTImpl & time_zone)
+    static UInt32 execute(const DecimalUtils::DecimalComponents<DateTime64> & t, const DateLUTImpl & time_zone)
     {
         return static_cast<UInt32>(time_zone.toStartOfMinute(t.whole));
     }
-    static inline UInt32 execute(UInt32 t, const DateLUTImpl & time_zone)
+    static UInt32 execute(UInt32 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toStartOfMinute(t);
     }
-    static inline UInt32 execute(Int32, const DateLUTImpl &)
+    static UInt32 execute(Int32, const DateLUTImpl &)
     {
-        throwDateTimeIsNotSupported(name);
+        throwDateIsNotSupported(name);
     }
-    static inline UInt32 execute(UInt16, const DateLUTImpl &)
+    static UInt32 execute(UInt16, const DateLUTImpl &)
     {
-        throwDateTimeIsNotSupported(name);
+        throwDateIsNotSupported(name);
     }
-    static inline DecimalUtils::DecimalComponents<DateTime64> executeExtendedResult(const DecimalUtils::DecimalComponents<DateTime64> & t, const DateLUTImpl & time_zone)
+    static DecimalUtils::DecimalComponents<DateTime64> executeExtendedResult(const DecimalUtils::DecimalComponents<DateTime64> & t, const DateLUTImpl & time_zone)
     {
         return {time_zone.toStartOfMinute(t.whole), 0};
     }
-    static inline Int64 executeExtendedResult(Int32, const DateLUTImpl &)
+    static Int64 executeExtendedResult(Int32, const DateLUTImpl &)
     {
         throwDate32IsNotSupported(name);
     }
@@ -369,7 +369,7 @@ struct ToStartOfSecondImpl
 {
     static constexpr auto name = "toStartOfSecond";
 
-    static inline DateTime64 execute(const DateTime64 & datetime64, Int64 scale_multiplier, const DateLUTImpl &)
+    static DateTime64 execute(const DateTime64 & datetime64, Int64 scale_multiplier, const DateLUTImpl &)
     {
         auto fractional_with_sign = DecimalUtils::getFractionalPartWithScaleMultiplier<DateTime64, true>(datetime64, scale_multiplier);
 
@@ -385,19 +385,19 @@ struct ToStartOfSecondImpl
         return datetime64 - fractional_with_sign;
     }
 
-    static inline UInt32 execute(UInt32, const DateLUTImpl &)
+    static UInt32 execute(UInt32, const DateLUTImpl &)
     {
         throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "Illegal type DateTime of argument for function {}", name);
     }
-    static inline UInt32 execute(Int32, const DateLUTImpl &)
+    static UInt32 execute(Int32, const DateLUTImpl &)
     {
-        throwDateTimeIsNotSupported(name);
+        throwDateIsNotSupported(name);
     }
-    static inline UInt32 execute(UInt16, const DateLUTImpl &)
+    static UInt32 execute(UInt16, const DateLUTImpl &)
     {
-        throwDateTimeIsNotSupported(name);
+        throwDateIsNotSupported(name);
     }
-    static inline constexpr bool hasPreimage() { return false; }
+    static constexpr bool hasPreimage() { return false; }
 
     using FactorTransform = ZeroTransform;
 };
@@ -406,7 +406,7 @@ struct ToStartOfMillisecondImpl
 {
     static constexpr auto name = "toStartOfMillisecond";
 
-    static inline DateTime64 execute(const DateTime64 & datetime64, Int64 scale_multiplier, const DateLUTImpl &)
+    static DateTime64 execute(const DateTime64 & datetime64, Int64 scale_multiplier, const DateLUTImpl &)
     {
         // given that scale is 6, scale_multiplier is 1000000
         // for DateTime64 value of 123.456789:
@@ -433,19 +433,19 @@ struct ToStartOfMillisecondImpl
         }
     }
 
-    static inline UInt32 execute(UInt32, const DateLUTImpl &)
+    static UInt32 execute(UInt32, const DateLUTImpl &)
     {
         throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "Illegal type DateTime of argument for function {}", name);
     }
-    static inline UInt32 execute(Int32, const DateLUTImpl &)
+    static UInt32 execute(Int32, const DateLUTImpl &)
     {
-        throwDateTimeIsNotSupported(name);
+        throwDateIsNotSupported(name);
     }
-    static inline UInt32 execute(UInt16, const DateLUTImpl &)
+    static UInt32 execute(UInt16, const DateLUTImpl &)
     {
-        throwDateTimeIsNotSupported(name);
+        throwDateIsNotSupported(name);
     }
-    static inline constexpr bool hasPreimage() { return false; }
+    static constexpr bool hasPreimage() { return false; }
 
     using FactorTransform = ZeroTransform;
 };
@@ -454,7 +454,7 @@ struct ToStartOfMicrosecondImpl
 {
     static constexpr auto name = "toStartOfMicrosecond";
 
-    static inline DateTime64 execute(const DateTime64 & datetime64, Int64 scale_multiplier, const DateLUTImpl &)
+    static DateTime64 execute(const DateTime64 & datetime64, Int64 scale_multiplier, const DateLUTImpl &)
     {
         // @see ToStartOfMillisecondImpl
 
@@ -477,19 +477,19 @@ struct ToStartOfMicrosecondImpl
         }
     }
 
-    static inline UInt32 execute(UInt32, const DateLUTImpl &)
+    static UInt32 execute(UInt32, const DateLUTImpl &)
     {
         throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "Illegal type DateTime of argument for function {}", name);
     }
-    static inline UInt32 execute(Int32, const DateLUTImpl &)
+    static UInt32 execute(Int32, const DateLUTImpl &)
     {
-        throwDateTimeIsNotSupported(name);
+        throwDateIsNotSupported(name);
     }
-    static inline UInt32 execute(UInt16, const DateLUTImpl &)
+    static UInt32 execute(UInt16, const DateLUTImpl &)
     {
-        throwDateTimeIsNotSupported(name);
+        throwDateIsNotSupported(name);
     }
-    static inline constexpr bool hasPreimage() { return false; }
+    static constexpr bool hasPreimage() { return false; }
 
     using FactorTransform = ZeroTransform;
 };
@@ -498,7 +498,7 @@ struct ToStartOfNanosecondImpl
 {
     static constexpr auto name = "toStartOfNanosecond";
 
-    static inline DateTime64 execute(const DateTime64 & datetime64, Int64 scale_multiplier, const DateLUTImpl &)
+    static DateTime64 execute(const DateTime64 & datetime64, Int64 scale_multiplier, const DateLUTImpl &)
     {
         // @see ToStartOfMillisecondImpl
         if (scale_multiplier == 1000000000)
@@ -515,19 +515,19 @@ struct ToStartOfNanosecondImpl
         }
     }
 
-    static inline UInt32 execute(UInt32, const DateLUTImpl &)
+    static UInt32 execute(UInt32, const DateLUTImpl &)
     {
         throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "Illegal type DateTime of argument for function {}", name);
     }
-    static inline UInt32 execute(Int32, const DateLUTImpl &)
+    static UInt32 execute(Int32, const DateLUTImpl &)
     {
-        throwDateTimeIsNotSupported(name);
+        throwDateIsNotSupported(name);
     }
-    static inline UInt32 execute(UInt16, const DateLUTImpl &)
+    static UInt32 execute(UInt16, const DateLUTImpl &)
     {
-        throwDateTimeIsNotSupported(name);
+        throwDateIsNotSupported(name);
     }
-    static inline constexpr bool hasPreimage() { return false; }
+    static constexpr bool hasPreimage() { return false; }
 
     using FactorTransform = ZeroTransform;
 };
@@ -536,27 +536,27 @@ struct ToStartOfFiveMinutesImpl
 {
     static constexpr auto name = "toStartOfFiveMinutes";
 
-    static inline UInt32 execute(const DecimalUtils::DecimalComponents<DateTime64> & t, const DateLUTImpl & time_zone)
+    static UInt32 execute(const DecimalUtils::DecimalComponents<DateTime64> & t, const DateLUTImpl & time_zone)
     {
         return static_cast<UInt32>(time_zone.toStartOfFiveMinutes(t.whole));
     }
-    static inline UInt32 execute(UInt32 t, const DateLUTImpl & time_zone)
+    static UInt32 execute(UInt32 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toStartOfFiveMinutes(t);
     }
-    static inline UInt32 execute(Int32, const DateLUTImpl &)
+    static UInt32 execute(Int32, const DateLUTImpl &)
     {
-        throwDateTimeIsNotSupported(name);
+        throwDateIsNotSupported(name);
     }
-    static inline UInt32 execute(UInt16, const DateLUTImpl &)
+    static UInt32 execute(UInt16, const DateLUTImpl &)
     {
-        throwDateTimeIsNotSupported(name);
+        throwDateIsNotSupported(name);
     }
-    static inline DecimalUtils::DecimalComponents<DateTime64> executeExtendedResult(const DecimalUtils::DecimalComponents<DateTime64> & t, const DateLUTImpl & time_zone)
+    static DecimalUtils::DecimalComponents<DateTime64> executeExtendedResult(const DecimalUtils::DecimalComponents<DateTime64> & t, const DateLUTImpl & time_zone)
     {
         return {time_zone.toStartOfFiveMinutes(t.whole), 0};
     }
-    static inline Int64 executeExtendedResult(Int32, const DateLUTImpl &)
+    static Int64 executeExtendedResult(Int32, const DateLUTImpl &)
     {
         throwDate32IsNotSupported(name);
     }
@@ -568,27 +568,27 @@ struct ToStartOfTenMinutesImpl
 {
     static constexpr auto name = "toStartOfTenMinutes";
 
-    static inline UInt32 execute(const DecimalUtils::DecimalComponents<DateTime64> & t, const DateLUTImpl & time_zone)
+    static UInt32 execute(const DecimalUtils::DecimalComponents<DateTime64> & t, const DateLUTImpl & time_zone)
     {
         return static_cast<UInt32>(time_zone.toStartOfTenMinutes(t.whole));
     }
-    static inline UInt32 execute(UInt32 t, const DateLUTImpl & time_zone)
+    static UInt32 execute(UInt32 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toStartOfTenMinutes(t);
     }
-    static inline UInt32 execute(Int32, const DateLUTImpl &)
+    static UInt32 execute(Int32, const DateLUTImpl &)
     {
-        throwDateTimeIsNotSupported(name);
+        throwDateIsNotSupported(name);
     }
-    static inline UInt32 execute(UInt16, const DateLUTImpl &)
+    static UInt32 execute(UInt16, const DateLUTImpl &)
     {
-        throwDateTimeIsNotSupported(name);
+        throwDateIsNotSupported(name);
     }
-    static inline DecimalUtils::DecimalComponents<DateTime64> executeExtendedResult(const DecimalUtils::DecimalComponents<DateTime64> & t, const DateLUTImpl & time_zone)
+    static DecimalUtils::DecimalComponents<DateTime64> executeExtendedResult(const DecimalUtils::DecimalComponents<DateTime64> & t, const DateLUTImpl & time_zone)
     {
         return {time_zone.toStartOfTenMinutes(t.whole), 0};
     }
-    static inline Int64 executeExtendedResult(Int32, const DateLUTImpl &)
+    static Int64 executeExtendedResult(Int32, const DateLUTImpl &)
     {
         throwDate32IsNotSupported(name);
     }
@@ -600,27 +600,27 @@ struct ToStartOfFifteenMinutesImpl
 {
     static constexpr auto name = "toStartOfFifteenMinutes";
 
-    static inline UInt32 execute(const DecimalUtils::DecimalComponents<DateTime64> & t, const DateLUTImpl & time_zone)
+    static UInt32 execute(const DecimalUtils::DecimalComponents<DateTime64> & t, const DateLUTImpl & time_zone)
     {
         return static_cast<UInt32>(time_zone.toStartOfFifteenMinutes(t.whole));
     }
-    static inline UInt32 execute(UInt32 t, const DateLUTImpl & time_zone)
+    static UInt32 execute(UInt32 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toStartOfFifteenMinutes(t);
     }
-    static inline UInt32 execute(Int32, const DateLUTImpl &)
+    static UInt32 execute(Int32, const DateLUTImpl &)
     {
-        throwDateTimeIsNotSupported(name);
+        throwDateIsNotSupported(name);
     }
-    static inline UInt32 execute(UInt16, const DateLUTImpl &)
+    static UInt32 execute(UInt16, const DateLUTImpl &)
     {
-        throwDateTimeIsNotSupported(name);
+        throwDateIsNotSupported(name);
     }
-    static inline DecimalUtils::DecimalComponents<DateTime64> executeExtendedResult(const DecimalUtils::DecimalComponents<DateTime64> & t, const DateLUTImpl & time_zone)
+    static DecimalUtils::DecimalComponents<DateTime64> executeExtendedResult(const DecimalUtils::DecimalComponents<DateTime64> & t, const DateLUTImpl & time_zone)
     {
         return {time_zone.toStartOfFifteenMinutes(t.whole), 0};
     }
-    static inline Int64 executeExtendedResult(Int32, const DateLUTImpl &)
+    static Int64 executeExtendedResult(Int32, const DateLUTImpl &)
     {
         throwDate32IsNotSupported(name);
     }
@@ -633,34 +633,34 @@ struct TimeSlotImpl
 {
     static constexpr auto name = "timeSlot";
 
-    static inline UInt32 execute(const DecimalUtils::DecimalComponents<DateTime64> & t, const DateLUTImpl &)
+    static UInt32 execute(const DecimalUtils::DecimalComponents<DateTime64> & t, const DateLUTImpl &)
     {
         return static_cast<UInt32>(t.whole / 1800 * 1800);
     }
 
-    static inline UInt32 execute(UInt32 t, const DateLUTImpl &)
+    static UInt32 execute(UInt32 t, const DateLUTImpl &)
     {
         return t / 1800 * 1800;
     }
 
-    static inline UInt32 execute(Int32, const DateLUTImpl &)
+    static UInt32 execute(Int32, const DateLUTImpl &)
     {
-        throwDateTimeIsNotSupported(name);
+        throwDateIsNotSupported(name);
     }
 
-    static inline UInt32 execute(UInt16, const DateLUTImpl &)
+    static UInt32 execute(UInt16, const DateLUTImpl &)
     {
-        throwDateTimeIsNotSupported(name);
+        throwDateIsNotSupported(name);
     }
 
-    static inline DecimalUtils::DecimalComponents<DateTime64>  executeExtendedResult(const DecimalUtils::DecimalComponents<DateTime64> & t, const DateLUTImpl &)
+    static DecimalUtils::DecimalComponents<DateTime64>  executeExtendedResult(const DecimalUtils::DecimalComponents<DateTime64> & t, const DateLUTImpl &)
     {
         if (likely(t.whole >= 0))
             return {t.whole / 1800 * 1800, 0};
         return {(t.whole + 1 - 1800) / 1800 * 1800, 0};
     }
 
-    static inline Int64 executeExtendedResult(Int32, const DateLUTImpl &)
+    static Int64 executeExtendedResult(Int32, const DateLUTImpl &)
     {
         throwDate32IsNotSupported(name);
     }
@@ -672,32 +672,32 @@ struct ToStartOfHourImpl
 {
     static constexpr auto name = "toStartOfHour";
 
-    static inline UInt32 execute(const DecimalUtils::DecimalComponents<DateTime64> & t, const DateLUTImpl & time_zone)
+    static UInt32 execute(const DecimalUtils::DecimalComponents<DateTime64> & t, const DateLUTImpl & time_zone)
     {
         return static_cast<UInt32>(time_zone.toStartOfHour(t.whole));
     }
 
-    static inline UInt32 execute(UInt32 t, const DateLUTImpl & time_zone)
+    static UInt32 execute(UInt32 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toStartOfHour(t);
     }
 
-    static inline UInt32 execute(Int32, const DateLUTImpl &)
+    static UInt32 execute(Int32, const DateLUTImpl &)
     {
-        throwDateTimeIsNotSupported(name);
+        throwDateIsNotSupported(name);
     }
 
-    static inline UInt32 execute(UInt16, const DateLUTImpl &)
+    static UInt32 execute(UInt16, const DateLUTImpl &)
     {
-        throwDateTimeIsNotSupported(name);
+        throwDateIsNotSupported(name);
     }
 
-    static inline DecimalUtils::DecimalComponents<DateTime64> executeExtendedResult(const DecimalUtils::DecimalComponents<DateTime64> & t, const DateLUTImpl & time_zone)
+    static DecimalUtils::DecimalComponents<DateTime64> executeExtendedResult(const DecimalUtils::DecimalComponents<DateTime64> & t, const DateLUTImpl & time_zone)
     {
         return {time_zone.toStartOfHour(t.whole), 0};
     }
 
-    static inline Int64 executeExtendedResult(Int32, const DateLUTImpl &)
+    static Int64 executeExtendedResult(Int32, const DateLUTImpl &)
     {
         throwDate32IsNotSupported(name);
     }
@@ -709,26 +709,26 @@ struct ToYearImpl
 {
     static constexpr auto name = "toYear";
 
-    static inline UInt16 execute(Int64 t, const DateLUTImpl & time_zone)
+    static UInt16 execute(Int64 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toYear(t);
     }
-    static inline UInt16 execute(UInt32 t, const DateLUTImpl & time_zone)
+    static UInt16 execute(UInt32 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toYear(t);
     }
-    static inline UInt16 execute(Int32 d, const DateLUTImpl & time_zone)
+    static UInt16 execute(Int32 d, const DateLUTImpl & time_zone)
     {
         return time_zone.toYear(ExtendedDayNum(d));
     }
-    static inline UInt16 execute(UInt16 d, const DateLUTImpl & time_zone)
+    static UInt16 execute(UInt16 d, const DateLUTImpl & time_zone)
     {
         return time_zone.toYear(DayNum(d));
     }
 
-    static inline constexpr bool hasPreimage() { return true; }
+    static constexpr bool hasPreimage() { return true; }
 
-    static inline RangeOrNull getPreimage(const IDataType & type, const Field & point)
+    static RangeOrNull getPreimage(const IDataType & type, const Field & point)
     {
         if (point.getType() != Field::Types::UInt64) return std::nullopt;
 
@@ -757,19 +757,19 @@ struct ToWeekYearImpl
 
     static constexpr Int8 week_mode = 3;
 
-    static inline UInt16 execute(Int64 t, const DateLUTImpl & time_zone)
+    static UInt16 execute(Int64 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toYearWeek(t, week_mode).first;
     }
-    static inline UInt16 execute(UInt32 t, const DateLUTImpl & time_zone)
+    static UInt16 execute(UInt32 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toYearWeek(t, week_mode).first;
     }
-    static inline UInt16 execute(Int32 d, const DateLUTImpl & time_zone)
+    static UInt16 execute(Int32 d, const DateLUTImpl & time_zone)
     {
         return time_zone.toYearWeek(ExtendedDayNum(d), week_mode).first;
     }
-    static inline UInt16 execute(UInt16 d, const DateLUTImpl & time_zone)
+    static UInt16 execute(UInt16 d, const DateLUTImpl & time_zone)
     {
         return time_zone.toYearWeek(DayNum(d), week_mode).first;
     }
@@ -781,19 +781,19 @@ struct ToWeekOfWeekYearImpl
 {
     static constexpr auto name = "toWeekOfWeekYear";
 
-    static inline UInt16 execute(Int64 t, const DateLUTImpl & time_zone)
+    static UInt16 execute(Int64 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toISOWeek(t);
     }
-    static inline UInt16 execute(UInt32 t, const DateLUTImpl & time_zone)
+    static UInt16 execute(UInt32 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toISOWeek(t);
     }
-    static inline UInt16 execute(Int32 d, const DateLUTImpl & time_zone)
+    static UInt16 execute(Int32 d, const DateLUTImpl & time_zone)
     {
         return time_zone.toISOWeek(ExtendedDayNum(d));
     }
-    static inline UInt16 execute(UInt16 d, const DateLUTImpl & time_zone)
+    static UInt16 execute(UInt16 d, const DateLUTImpl & time_zone)
     {
         return time_zone.toISOWeek(DayNum(d));
     }
@@ -805,23 +805,23 @@ struct ToQuarterImpl
 {
     static constexpr auto name = "toQuarter";
 
-    static inline UInt8 execute(Int64 t, const DateLUTImpl & time_zone)
+    static UInt8 execute(Int64 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toQuarter(t);
     }
-    static inline UInt8 execute(UInt32 t, const DateLUTImpl & time_zone)
+    static UInt8 execute(UInt32 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toQuarter(t);
     }
-    static inline UInt8 execute(Int32 d, const DateLUTImpl & time_zone)
+    static UInt8 execute(Int32 d, const DateLUTImpl & time_zone)
     {
         return time_zone.toQuarter(ExtendedDayNum(d));
     }
-    static inline UInt8 execute(UInt16 d, const DateLUTImpl & time_zone)
+    static UInt8 execute(UInt16 d, const DateLUTImpl & time_zone)
     {
         return time_zone.toQuarter(DayNum(d));
     }
-    static inline constexpr bool hasPreimage() { return false; }
+    static constexpr bool hasPreimage() { return false; }
 
     using FactorTransform = ToStartOfYearImpl;
 };
@@ -830,23 +830,23 @@ struct ToMonthImpl
 {
     static constexpr auto name = "toMonth";
 
-    static inline UInt8 execute(Int64 t, const DateLUTImpl & time_zone)
+    static UInt8 execute(Int64 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toMonth(t);
     }
-    static inline UInt8 execute(UInt32 t, const DateLUTImpl & time_zone)
+    static UInt8 execute(UInt32 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toMonth(t);
     }
-    static inline UInt8 execute(Int32 d, const DateLUTImpl & time_zone)
+    static UInt8 execute(Int32 d, const DateLUTImpl & time_zone)
     {
         return time_zone.toMonth(ExtendedDayNum(d));
     }
-    static inline UInt8 execute(UInt16 d, const DateLUTImpl & time_zone)
+    static UInt8 execute(UInt16 d, const DateLUTImpl & time_zone)
     {
         return time_zone.toMonth(DayNum(d));
     }
-    static inline constexpr bool hasPreimage() { return false; }
+    static constexpr bool hasPreimage() { return false; }
 
     using FactorTransform = ToStartOfYearImpl;
 };
@@ -855,24 +855,24 @@ struct ToDayOfMonthImpl
 {
     static constexpr auto name = "toDayOfMonth";
 
-    static inline UInt8 execute(Int64 t, const DateLUTImpl & time_zone)
+    static UInt8 execute(Int64 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toDayOfMonth(t);
     }
-    static inline UInt8 execute(UInt32 t, const DateLUTImpl & time_zone)
+    static UInt8 execute(UInt32 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toDayOfMonth(t);
     }
-    static inline UInt8 execute(Int32 d, const DateLUTImpl & time_zone)
+    static UInt8 execute(Int32 d, const DateLUTImpl & time_zone)
     {
         return time_zone.toDayOfMonth(ExtendedDayNum(d));
     }
-    static inline UInt8 execute(UInt16 d, const DateLUTImpl & time_zone)
+    static UInt8 execute(UInt16 d, const DateLUTImpl & time_zone)
     {
         return time_zone.toDayOfMonth(DayNum(d));
     }
 
-    static inline constexpr bool hasPreimage() { return false; }
+    static constexpr bool hasPreimage() { return false; }
     using FactorTransform = ToStartOfMonthImpl;
 };
 
@@ -880,19 +880,19 @@ struct ToDayOfWeekImpl
 {
     static constexpr auto name = "toDayOfWeek";
 
-    static inline UInt8 execute(Int64 t, UInt8 mode, const DateLUTImpl & time_zone)
+    static UInt8 execute(Int64 t, UInt8 mode, const DateLUTImpl & time_zone)
     {
         return time_zone.toDayOfWeek(t, mode);
     }
-    static inline UInt8 execute(UInt32 t, UInt8 mode, const DateLUTImpl & time_zone)
+    static UInt8 execute(UInt32 t, UInt8 mode, const DateLUTImpl & time_zone)
     {
         return time_zone.toDayOfWeek(t, mode);
     }
-    static inline UInt8 execute(Int32 d, UInt8 mode, const DateLUTImpl & time_zone)
+    static UInt8 execute(Int32 d, UInt8 mode, const DateLUTImpl & time_zone)
     {
         return time_zone.toDayOfWeek(ExtendedDayNum(d), mode);
     }
-    static inline UInt8 execute(UInt16 d, UInt8 mode, const DateLUTImpl & time_zone)
+    static UInt8 execute(UInt16 d, UInt8 mode, const DateLUTImpl & time_zone)
     {
         return time_zone.toDayOfWeek(DayNum(d), mode);
     }
@@ -904,48 +904,79 @@ struct ToDayOfYearImpl
 {
     static constexpr auto name = "toDayOfYear";
 
-    static inline UInt16 execute(Int64 t, const DateLUTImpl & time_zone)
+    static UInt16 execute(Int64 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toDayOfYear(t);
     }
-    static inline UInt16 execute(UInt32 t, const DateLUTImpl & time_zone)
+    static UInt16 execute(UInt32 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toDayOfYear(t);
     }
-    static inline UInt16 execute(Int32 d, const DateLUTImpl & time_zone)
+    static UInt16 execute(Int32 d, const DateLUTImpl & time_zone)
     {
         return time_zone.toDayOfYear(ExtendedDayNum(d));
     }
-    static inline UInt16 execute(UInt16 d, const DateLUTImpl & time_zone)
+    static UInt16 execute(UInt16 d, const DateLUTImpl & time_zone)
     {
         return time_zone.toDayOfYear(DayNum(d));
     }
-    static inline constexpr bool hasPreimage() { return false; }
+    static constexpr bool hasPreimage() { return false; }
 
     using FactorTransform = ToStartOfYearImpl;
 };
 
+struct ToDaysSinceYearZeroImpl
+{
+private:
+    /// Constant calculated from MySQL's TO_DAYS() implementation.
+    /// https://github.com/mysql/mysql-server/blob/ea1efa9822d81044b726aab20c857d5e1b7e046a/mysys/my_time.cc#L1042
+    static constexpr auto DAYS_BETWEEN_YEARS_0_AND_1900 = 693'961; /// 01 January, each
+
+public:
+    static constexpr auto name = "toDaysSinceYearZero";
+
+    static UInt32 execute(Int64, const DateLUTImpl &)
+    {
+        throwDateTimeIsNotSupported(name);
+    }
+    static UInt32 execute(UInt32, const DateLUTImpl &)
+    {
+        throwDateTimeIsNotSupported(name);
+    }
+    static UInt32 execute(Int32 d, const DateLUTImpl &)
+    {
+        return DAYS_BETWEEN_YEARS_0_AND_1900 + d;
+    }
+    static UInt32 execute(UInt16 d, const DateLUTImpl &)
+    {
+        return DAYS_BETWEEN_YEARS_0_AND_1900 + d;
+    }
+    static constexpr bool hasPreimage() { return false; }
+
+    using FactorTransform = ZeroTransform;
+};
+
 struct ToHourImpl
 {
     static constexpr auto name = "toHour";
 
-    static inline UInt8 execute(Int64 t, const DateLUTImpl & time_zone)
+    static UInt8 execute(Int64 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toHour(t);
     }
-    static inline UInt8 execute(UInt32 t, const DateLUTImpl & time_zone)
+    static UInt8 execute(UInt32 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toHour(t);
     }
-    static inline UInt8 execute(Int32, const DateLUTImpl &)
+    static UInt8 execute(Int32, const DateLUTImpl &)
     {
-        throwDateTimeIsNotSupported(name);
+        throwDateIsNotSupported(name);
     }
-    static inline UInt8 execute(UInt16, const DateLUTImpl &)
+    static UInt8 execute(UInt16, const DateLUTImpl &)
     {
-        throwDateTimeIsNotSupported(name);
+        throwDateIsNotSupported(name);
     }
-    static inline constexpr bool hasPreimage() { return false; }
+    static constexpr bool hasPreimage() { return false; }
 
     using FactorTransform = ToDateImpl;
 };
@@ -954,27 +985,27 @@ struct TimezoneOffsetImpl
 {
     static constexpr auto name = "timezoneOffset";
 
-    static inline time_t execute(Int64 t, const DateLUTImpl & time_zone)
+    static time_t execute(Int64 t, const DateLUTImpl & time_zone)
     {
         return time_zone.timezoneOffset(t);
     }
 
-    static inline time_t execute(UInt32 t, const DateLUTImpl & time_zone)
+    static time_t execute(UInt32 t, const DateLUTImpl & time_zone)
     {
         return time_zone.timezoneOffset(t);
     }
 
-    static inline time_t execute(Int32, const DateLUTImpl &)
+    static time_t execute(Int32, const DateLUTImpl &)
     {
-        throwDateTimeIsNotSupported(name);
+        throwDateIsNotSupported(name);
     }
 
-    static inline time_t execute(UInt16, const DateLUTImpl &)
+    static time_t execute(UInt16, const DateLUTImpl &)
     {
-        throwDateTimeIsNotSupported(name);
+        throwDateIsNotSupported(name);
     }
 
-    static inline constexpr bool hasPreimage() { return false; }
+    static constexpr bool hasPreimage() { return false; }
     using FactorTransform = ToTimeImpl;
 };
 
@@ -982,23 +1013,23 @@ struct ToMinuteImpl
 {
     static constexpr auto name = "toMinute";
 
-    static inline UInt8 execute(Int64 t, const DateLUTImpl & time_zone)
+    static UInt8 execute(Int64 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toMinute(t);
     }
-    static inline UInt8 execute(UInt32 t, const DateLUTImpl & time_zone)
+    static UInt8 execute(UInt32 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toMinute(t);
     }
-    static inline UInt8 execute(Int32, const DateLUTImpl &)
+    static UInt8 execute(Int32, const DateLUTImpl &)
     {
-        throwDateTimeIsNotSupported(name);
+        throwDateIsNotSupported(name);
     }
-    static inline UInt8 execute(UInt16, const DateLUTImpl &)
+    static UInt8 execute(UInt16, const DateLUTImpl &)
     {
-        throwDateTimeIsNotSupported(name);
+        throwDateIsNotSupported(name);
     }
-    static inline constexpr bool hasPreimage() { return false; }
+    static constexpr bool hasPreimage() { return false; }
 
     using FactorTransform = ToStartOfHourImpl;
 };
@@ -1007,23 +1038,23 @@ struct ToSecondImpl
 {
     static constexpr auto name = "toSecond";
 
-    static inline UInt8 execute(Int64 t, const DateLUTImpl & time_zone)
+    static UInt8 execute(Int64 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toSecond(t);
     }
-    static inline UInt8 execute(UInt32 t, const DateLUTImpl & time_zone)
+    static UInt8 execute(UInt32 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toSecond(t);
     }
-    static inline UInt8 execute(Int32, const DateLUTImpl &)
+    static UInt8 execute(Int32, const DateLUTImpl &)
     {
-        throwDateTimeIsNotSupported(name);
+        throwDateIsNotSupported(name);
     }
-    static inline UInt8 execute(UInt16, const DateLUTImpl &)
+    static UInt8 execute(UInt16, const DateLUTImpl &)
     {
-        throwDateTimeIsNotSupported(name);
+        throwDateIsNotSupported(name);
     }
-    static inline constexpr bool hasPreimage() { return false; }
+    static constexpr bool hasPreimage() { return false; }
 
     using FactorTransform = ToStartOfMinuteImpl;
 };
@@ -1032,23 +1063,23 @@ struct ToISOYearImpl
 {
     static constexpr auto name = "toISOYear";
 
-    static inline UInt16 execute(Int64 t, const DateLUTImpl & time_zone)
+    static UInt16 execute(Int64 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toISOYear(time_zone.toDayNum(t));
     }
-    static inline UInt16 execute(UInt32 t, const DateLUTImpl & time_zone)
+    static UInt16 execute(UInt32 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toISOYear(time_zone.toDayNum(t));
     }
-    static inline UInt16 execute(Int32 d, const DateLUTImpl & time_zone)
+    static UInt16 execute(Int32 d, const DateLUTImpl & time_zone)
     {
         return time_zone.toISOYear(ExtendedDayNum(d));
     }
-    static inline UInt16 execute(UInt16 d, const DateLUTImpl & time_zone)
+    static UInt16 execute(UInt16 d, const DateLUTImpl & time_zone)
     {
         return time_zone.toISOYear(DayNum(d));
     }
-    static inline constexpr bool hasPreimage() { return false; }
+    static constexpr bool hasPreimage() { return false; }
 
     using FactorTransform = ZeroTransform;
 };
@@ -1057,27 +1088,27 @@ struct ToStartOfISOYearImpl
 {
     static constexpr auto name = "toStartOfISOYear";
 
-    static inline UInt16 execute(Int64 t, const DateLUTImpl & time_zone)
+    static UInt16 execute(Int64 t, const DateLUTImpl & time_zone)
     {
         return t < 0 ? 0 : time_zone.toFirstDayNumOfISOYear(ExtendedDayNum(std::min(Int32(time_zone.toDayNum(t)), Int32(DATE_LUT_MAX_DAY_NUM))));
     }
-    static inline UInt16 execute(UInt32 t, const DateLUTImpl & time_zone)
+    static UInt16 execute(UInt32 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toFirstDayNumOfISOYear(time_zone.toDayNum(t));
     }
-    static inline UInt16 execute(Int32 d, const DateLUTImpl & time_zone)
+    static UInt16 execute(Int32 d, const DateLUTImpl & time_zone)
     {
         return d < 0 ? 0 : time_zone.toFirstDayNumOfISOYear(ExtendedDayNum(std::min(d, Int32(DATE_LUT_MAX_DAY_NUM))));
     }
-    static inline UInt16 execute(UInt16 d, const DateLUTImpl & time_zone)
+    static UInt16 execute(UInt16 d, const DateLUTImpl & time_zone)
     {
         return time_zone.toFirstDayNumOfISOYear(DayNum(d));
     }
-    static inline Int64 executeExtendedResult(Int64 t, const DateLUTImpl & time_zone)
+    static Int64 executeExtendedResult(Int64 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toFirstDayNumOfISOYear(time_zone.toDayNum(t));
     }
-    static inline Int32 executeExtendedResult(Int32 d, const DateLUTImpl & time_zone)
+    static Int32 executeExtendedResult(Int32 d, const DateLUTImpl & time_zone)
     {
         return time_zone.toFirstDayNumOfISOYear(ExtendedDayNum(d));
     }
@@ -1089,23 +1120,23 @@ struct ToISOWeekImpl
 {
     static constexpr auto name = "toISOWeek";
 
-    static inline UInt8 execute(Int64 t, const DateLUTImpl & time_zone)
+    static UInt8 execute(Int64 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toISOWeek(time_zone.toDayNum(t));
     }
-    static inline UInt8 execute(UInt32 t, const DateLUTImpl & time_zone)
+    static UInt8 execute(UInt32 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toISOWeek(time_zone.toDayNum(t));
     }
-    static inline UInt8 execute(Int32 d, const DateLUTImpl & time_zone)
+    static UInt8 execute(Int32 d, const DateLUTImpl & time_zone)
     {
         return time_zone.toISOWeek(ExtendedDayNum(d));
     }
-    static inline UInt8 execute(UInt16 d, const DateLUTImpl & time_zone)
+    static UInt8 execute(UInt16 d, const DateLUTImpl & time_zone)
     {
         return time_zone.toISOWeek(DayNum(d));
     }
-    static inline constexpr bool hasPreimage() { return false; }
+    static constexpr bool hasPreimage() { return false; }
 
     using FactorTransform = ToISOYearImpl;
 };
@@ -1126,29 +1157,29 @@ struct ToRelativeYearNumImpl
 {
     static constexpr auto name = "toRelativeYearNum";
 
-    static inline auto execute(Int64 t, const DateLUTImpl & time_zone)
+    static auto execute(Int64 t, const DateLUTImpl & time_zone)
     {
         if constexpr (precision_ == ResultPrecision::Extended)
             return static_cast<Int16>(time_zone.toYear(t));
         else
             return static_cast<UInt16>(time_zone.toYear(t));
     }
-    static inline UInt16 execute(UInt32 t, const DateLUTImpl & time_zone)
+    static UInt16 execute(UInt32 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toYear(static_cast<time_t>(t));
     }
-    static inline auto execute(Int32 d, const DateLUTImpl & time_zone)
+    static auto execute(Int32 d, const DateLUTImpl & time_zone)
     {
         if constexpr (precision_ == ResultPrecision::Extended)
             return static_cast<Int16>(time_zone.toYear(ExtendedDayNum(d)));
         else
             return static_cast<UInt16>(time_zone.toYear(ExtendedDayNum(d)));
     }
-    static inline UInt16 execute(UInt16 d, const DateLUTImpl & time_zone)
+    static UInt16 execute(UInt16 d, const DateLUTImpl & time_zone)
     {
         return time_zone.toYear(DayNum(d));
     }
-    static inline constexpr bool hasPreimage() { return false; }
+    static constexpr bool hasPreimage() { return false; }
 
     using FactorTransform = ZeroTransform;
 };
@@ -1158,29 +1189,29 @@ struct ToRelativeQuarterNumImpl
 {
     static constexpr auto name = "toRelativeQuarterNum";
 
-    static inline auto execute(Int64 t, const DateLUTImpl & time_zone)
+    static auto execute(Int64 t, const DateLUTImpl & time_zone)
     {
         if constexpr (precision_ == ResultPrecision::Extended)
             return static_cast<Int32>(time_zone.toRelativeQuarterNum(t));
         else
             return static_cast<UInt16>(time_zone.toRelativeQuarterNum(t));
     }
-    static inline UInt16 execute(UInt32 t, const DateLUTImpl & time_zone)
+    static UInt16 execute(UInt32 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toRelativeQuarterNum(static_cast<time_t>(t));
     }
-    static inline auto execute(Int32 d, const DateLUTImpl & time_zone)
+    static auto execute(Int32 d, const DateLUTImpl & time_zone)
     {
         if constexpr (precision_ == ResultPrecision::Extended)
             return static_cast<Int32>(time_zone.toRelativeQuarterNum(ExtendedDayNum(d)));
         else
             return static_cast<UInt16>(time_zone.toRelativeQuarterNum(ExtendedDayNum(d)));
     }
-    static inline UInt16 execute(UInt16 d, const DateLUTImpl & time_zone)
+    static UInt16 execute(UInt16 d, const DateLUTImpl & time_zone)
     {
         return time_zone.toRelativeQuarterNum(DayNum(d));
     }
-    static inline constexpr bool hasPreimage() { return false; }
+    static constexpr bool hasPreimage() { return false; }
 
     using FactorTransform = ZeroTransform;
 };
@@ -1190,29 +1221,29 @@ struct ToRelativeMonthNumImpl
 {
     static constexpr auto name = "toRelativeMonthNum";
 
-    static inline auto execute(Int64 t, const DateLUTImpl & time_zone)
+    static auto execute(Int64 t, const DateLUTImpl & time_zone)
     {
         if constexpr (precision_ == ResultPrecision::Extended)
             return static_cast<Int32>(time_zone.toRelativeMonthNum(t));
         else
             return static_cast<UInt16>(time_zone.toRelativeMonthNum(t));
     }
-    static inline UInt16 execute(UInt32 t, const DateLUTImpl & time_zone)
+    static UInt16 execute(UInt32 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toRelativeMonthNum(static_cast<time_t>(t));
     }
-    static inline auto execute(Int32 d, const DateLUTImpl & time_zone)
+    static auto execute(Int32 d, const DateLUTImpl & time_zone)
     {
         if constexpr (precision_ == ResultPrecision::Extended)
             return static_cast<Int32>(time_zone.toRelativeMonthNum(ExtendedDayNum(d)));
         else
             return static_cast<UInt16>(time_zone.toRelativeMonthNum(ExtendedDayNum(d)));
     }
-    static inline UInt16 execute(UInt16 d, const DateLUTImpl & time_zone)
+    static UInt16 execute(UInt16 d, const DateLUTImpl & time_zone)
     {
         return time_zone.toRelativeMonthNum(DayNum(d));
     }
-    static inline constexpr bool hasPreimage() { return false; }
+    static constexpr bool hasPreimage() { return false; }
 
     using FactorTransform = ZeroTransform;
 };
@@ -1222,29 +1253,29 @@ struct ToRelativeWeekNumImpl
 {
     static constexpr auto name = "toRelativeWeekNum";
 
-    static inline auto execute(Int64 t, const DateLUTImpl & time_zone)
+    static auto execute(Int64 t, const DateLUTImpl & time_zone)
     {
         if constexpr (precision_ == ResultPrecision::Extended)
             return static_cast<Int32>(time_zone.toRelativeWeekNum(t));
         else
             return static_cast<UInt16>(time_zone.toRelativeWeekNum(t));
     }
-    static inline UInt16 execute(UInt32 t, const DateLUTImpl & time_zone)
+    static UInt16 execute(UInt32 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toRelativeWeekNum(static_cast<time_t>(t));
     }
-    static inline auto execute(Int32 d, const DateLUTImpl & time_zone)
+    static auto execute(Int32 d, const DateLUTImpl & time_zone)
     {
         if constexpr (precision_ == ResultPrecision::Extended)
             return static_cast<Int32>(time_zone.toRelativeWeekNum(ExtendedDayNum(d)));
         else
             return static_cast<UInt16>(time_zone.toRelativeWeekNum(ExtendedDayNum(d)));
     }
-    static inline UInt16 execute(UInt16 d, const DateLUTImpl & time_zone)
+    static UInt16 execute(UInt16 d, const DateLUTImpl & time_zone)
     {
         return time_zone.toRelativeWeekNum(DayNum(d));
     }
-    static inline constexpr bool hasPreimage() { return false; }
+    static constexpr bool hasPreimage() { return false; }
 
     using FactorTransform = ZeroTransform;
 };
@@ -1254,29 +1285,29 @@ struct ToRelativeDayNumImpl
 {
     static constexpr auto name = "toRelativeDayNum";
 
-    static inline auto execute(Int64 t, const DateLUTImpl & time_zone)
+    static auto execute(Int64 t, const DateLUTImpl & time_zone)
     {
         if constexpr (precision_ == ResultPrecision::Extended)
             return static_cast<Int64>(time_zone.toDayNum(t));
         else
             return static_cast<UInt16>(time_zone.toDayNum(t));
     }
-    static inline UInt16 execute(UInt32 t, const DateLUTImpl & time_zone)
+    static UInt16 execute(UInt32 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toDayNum(static_cast<time_t>(t));
     }
-    static inline auto execute(Int32 d, const DateLUTImpl &)
+    static auto execute(Int32 d, const DateLUTImpl &)
     {
         if constexpr (precision_ == ResultPrecision::Extended)
             return static_cast<Int32>(static_cast<ExtendedDayNum>(d));
         else
             return static_cast<UInt16>(static_cast<ExtendedDayNum>(d));
     }
-    static inline UInt16 execute(UInt16 d, const DateLUTImpl &)
+    static UInt16 execute(UInt16 d, const DateLUTImpl &)
     {
         return static_cast<DayNum>(d);
     }
-    static inline constexpr bool hasPreimage() { return false; }
+    static constexpr bool hasPreimage() { return false; }
 
     using FactorTransform = ZeroTransform;
 };
@@ -1286,35 +1317,35 @@ struct ToRelativeHourNumImpl
 {
     static constexpr auto name = "toRelativeHourNum";
 
-    static inline auto execute(Int64 t, const DateLUTImpl & time_zone)
+    static auto execute(Int64 t, const DateLUTImpl & time_zone)
     {
         if constexpr (precision_ == ResultPrecision::Extended)
             return static_cast<Int64>(time_zone.toStableRelativeHourNum(t));
         else
             return static_cast<UInt32>(time_zone.toRelativeHourNum(t));
     }
-    static inline UInt32 execute(UInt32 t, const DateLUTImpl & time_zone)
+    static UInt32 execute(UInt32 t, const DateLUTImpl & time_zone)
     {
         if constexpr (precision_ == ResultPrecision::Extended)
             return static_cast<UInt32>(time_zone.toStableRelativeHourNum(static_cast<DateLUTImpl::Time>(t)));
         else
             return static_cast<UInt32>(time_zone.toRelativeHourNum(static_cast<DateLUTImpl::Time>(t)));
     }
-    static inline auto execute(Int32 d, const DateLUTImpl & time_zone)
+    static auto execute(Int32 d, const DateLUTImpl & time_zone)
     {
         if constexpr (precision_ == ResultPrecision::Extended)
             return static_cast<Int64>(time_zone.toStableRelativeHourNum(ExtendedDayNum(d)));
         else
             return static_cast<UInt32>(time_zone.toRelativeHourNum(ExtendedDayNum(d)));
     }
-    static inline UInt32 execute(UInt16 d, const DateLUTImpl & time_zone)
+    static UInt32 execute(UInt16 d, const DateLUTImpl & time_zone)
     {
         if constexpr (precision_ == ResultPrecision::Extended)
             return static_cast<UInt32>(time_zone.toStableRelativeHourNum(DayNum(d)));
         else
             return static_cast<UInt32>(time_zone.toRelativeHourNum(DayNum(d)));
     }
-    static inline constexpr bool hasPreimage() { return false; }
+    static constexpr bool hasPreimage() { return false; }
 
     using FactorTransform = ZeroTransform;
 };
@@ -1324,29 +1355,29 @@ struct ToRelativeMinuteNumImpl
 {
     static constexpr auto name = "toRelativeMinuteNum";
 
-    static inline auto execute(Int64 t, const DateLUTImpl & time_zone)
+    static auto execute(Int64 t, const DateLUTImpl & time_zone)
     {
         if constexpr (precision_ == ResultPrecision::Extended)
             return static_cast<Int64>(time_zone.toRelativeMinuteNum(t));
         else
             return static_cast<UInt32>(time_zone.toRelativeMinuteNum(t));
     }
-    static inline UInt32 execute(UInt32 t, const DateLUTImpl & time_zone)
+    static UInt32 execute(UInt32 t, const DateLUTImpl & time_zone)
     {
         return static_cast<UInt32>(time_zone.toRelativeMinuteNum(static_cast<DateLUTImpl::Time>(t)));
     }
-    static inline auto execute(Int32 d, const DateLUTImpl & time_zone)
+    static auto execute(Int32 d, const DateLUTImpl & time_zone)
     {
         if constexpr (precision_ == ResultPrecision::Extended)
             return static_cast<Int64>(time_zone.toRelativeMinuteNum(ExtendedDayNum(d)));
         else
             return static_cast<UInt32>(time_zone.toRelativeMinuteNum(ExtendedDayNum(d)));
     }
-    static inline UInt32 execute(UInt16 d, const DateLUTImpl & time_zone)
+    static UInt32 execute(UInt16 d, const DateLUTImpl & time_zone)
     {
         return static_cast<UInt32>(time_zone.toRelativeMinuteNum(DayNum(d)));
     }
-    static inline constexpr bool hasPreimage() { return false; }
+    static constexpr bool hasPreimage() { return false; }
 
     using FactorTransform = ZeroTransform;
 };
@@ -1356,26 +1387,26 @@ struct ToRelativeSecondNumImpl
 {
     static constexpr auto name = "toRelativeSecondNum";
 
-    static inline Int64 execute(Int64 t, const DateLUTImpl &)
+    static Int64 execute(Int64 t, const DateLUTImpl &)
     {
         return t;
     }
-    static inline UInt32 execute(UInt32 t, const DateLUTImpl &)
+    static UInt32 execute(UInt32 t, const DateLUTImpl &)
     {
         return t;
     }
-    static inline auto execute(Int32 d, const DateLUTImpl & time_zone)
+    static auto execute(Int32 d, const DateLUTImpl & time_zone)
     {
         if constexpr (precision_ == ResultPrecision::Extended)
             return static_cast<Int64>(time_zone.fromDayNum(ExtendedDayNum(d)));
         else
             return static_cast<UInt32>(time_zone.fromDayNum(ExtendedDayNum(d)));
     }
-    static inline UInt32 execute(UInt16 d, const DateLUTImpl & time_zone)
+    static UInt32 execute(UInt16 d, const DateLUTImpl & time_zone)
     {
         return static_cast<UInt32>(time_zone.fromDayNum(DayNum(d)));
     }
-    static inline constexpr bool hasPreimage() { return false; }
+    static constexpr bool hasPreimage() { return false; }
 
     using FactorTransform = ZeroTransform;
 };
@@ -1385,7 +1416,7 @@ struct ToRelativeSubsecondNumImpl
 {
     static constexpr auto name = "toRelativeSubsecondNumImpl";
 
-    static inline Int64 execute(const DateTime64 & t, DateTime64::NativeType scale, const DateLUTImpl &)
+    static Int64 execute(const DateTime64 & t, DateTime64::NativeType scale, const DateLUTImpl &)
     {
         static_assert(scale_multiplier == 1000 || scale_multiplier == 1000000);
         if (scale == scale_multiplier)
@@ -1394,15 +1425,15 @@ struct ToRelativeSubsecondNumImpl
             return t.value / (scale / scale_multiplier);
         return t.value * (scale_multiplier / scale);
     }
-    static inline Int64 execute(UInt32 t, const DateLUTImpl &)
+    static Int64 execute(UInt32 t, const DateLUTImpl &)
     {
         return t * scale_multiplier;
     }
-    static inline Int64 execute(Int32 d, const DateLUTImpl & time_zone)
+    static Int64 execute(Int32 d, const DateLUTImpl & time_zone)
     {
         return static_cast<Int64>(time_zone.fromDayNum(ExtendedDayNum(d))) * scale_multiplier;
     }
-    static inline Int64 execute(UInt16 d, const DateLUTImpl & time_zone)
+    static Int64 execute(UInt16 d, const DateLUTImpl & time_zone)
     {
         return static_cast<Int64>(time_zone.fromDayNum(DayNum(d)) * scale_multiplier);
     }
@@ -1414,25 +1445,25 @@ struct ToYYYYMMImpl
 {
     static constexpr auto name = "toYYYYMM";
 
-    static inline UInt32 execute(Int64 t, const DateLUTImpl & time_zone)
+    static UInt32 execute(Int64 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toNumYYYYMM(t);
     }
-    static inline UInt32 execute(UInt32 t, const DateLUTImpl & time_zone)
+    static UInt32 execute(UInt32 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toNumYYYYMM(t);
     }
-    static inline UInt32 execute(Int32 d, const DateLUTImpl & time_zone)
+    static UInt32 execute(Int32 d, const DateLUTImpl & time_zone)
     {
         return time_zone.toNumYYYYMM(ExtendedDayNum(d));
     }
-    static inline UInt32 execute(UInt16 d, const DateLUTImpl & time_zone)
+    static UInt32 execute(UInt16 d, const DateLUTImpl & time_zone)
     {
         return time_zone.toNumYYYYMM(DayNum(d));
     }
-    static inline constexpr bool hasPreimage() { return true; }
+    static constexpr bool hasPreimage() { return true; }
 
-    static inline RangeOrNull getPreimage(const IDataType & type, const Field & point)
+    static RangeOrNull getPreimage(const IDataType & type, const Field & point)
     {
         if (point.getType() != Field::Types::UInt64) return std::nullopt;
 
@@ -1463,23 +1494,23 @@ struct ToYYYYMMDDImpl
 {
     static constexpr auto name = "toYYYYMMDD";
 
-    static inline UInt32 execute(Int64 t, const DateLUTImpl & time_zone)
+    static UInt32 execute(Int64 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toNumYYYYMMDD(t);
     }
-    static inline UInt32 execute(UInt32 t, const DateLUTImpl & time_zone)
+    static UInt32 execute(UInt32 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toNumYYYYMMDD(t);
     }
-    static inline UInt32 execute(Int32 d, const DateLUTImpl & time_zone)
+    static UInt32 execute(Int32 d, const DateLUTImpl & time_zone)
     {
         return time_zone.toNumYYYYMMDD(ExtendedDayNum(d));
     }
-    static inline UInt32 execute(UInt16 d, const DateLUTImpl & time_zone)
+    static UInt32 execute(UInt16 d, const DateLUTImpl & time_zone)
     {
         return time_zone.toNumYYYYMMDD(DayNum(d));
     }
-    static inline constexpr bool hasPreimage() { return false; }
+    static constexpr bool hasPreimage() { return false; }
 
     using FactorTransform = ZeroTransform;
 };
@@ -1488,23 +1519,23 @@ struct ToYYYYMMDDhhmmssImpl
 {
     static constexpr auto name = "toYYYYMMDDhhmmss";
 
-    static inline UInt64 execute(Int64 t, const DateLUTImpl & time_zone)
+    static UInt64 execute(Int64 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toNumYYYYMMDDhhmmss(t);
     }
-    static inline UInt64 execute(UInt32 t, const DateLUTImpl & time_zone)
+    static UInt64 execute(UInt32 t, const DateLUTImpl & time_zone)
     {
         return time_zone.toNumYYYYMMDDhhmmss(t);
     }
-    static inline UInt64 execute(Int32 d, const DateLUTImpl & time_zone)
+    static UInt64 execute(Int32 d, const DateLUTImpl & time_zone)
     {
         return time_zone.toNumYYYYMMDDhhmmss(time_zone.toDate(ExtendedDayNum(d)));
     }
-    static inline UInt64 execute(UInt16 d, const DateLUTImpl & time_zone)
+    static UInt64 execute(UInt16 d, const DateLUTImpl & time_zone)
     {
         return time_zone.toNumYYYYMMDDhhmmss(time_zone.toDate(DayNum(d)));
     }
-    static inline constexpr bool hasPreimage() { return false; }
+    static constexpr bool hasPreimage() { return false; }
 
     using FactorTransform = ZeroTransform;
 };
@@ -1519,7 +1550,7 @@ struct ToDateTimeComponentsImpl
 {
     static constexpr auto name = "toDateTimeComponents";
 
-    static inline DateTimeComponentsWithFractionalPart execute(const DateTime64 & t, DateTime64::NativeType scale_multiplier, const DateLUTImpl & time_zone)
+    static DateTimeComponentsWithFractionalPart execute(const DateTime64 & t, DateTime64::NativeType scale_multiplier, const DateLUTImpl & time_zone)
     {
         auto components = DecimalUtils::splitWithScaleMultiplier(t, scale_multiplier);
 
@@ -1539,15 +1570,15 @@ struct ToDateTimeComponentsImpl
         UInt16 microsecond = static_cast<UInt16>(fractional % divider);
         return DateTimeComponentsWithFractionalPart{time_zone.toDateTimeComponents(components.whole), millisecond, microsecond};
     }
-    static inline DateTimeComponentsWithFractionalPart execute(UInt32 t, const DateLUTImpl & time_zone)
+    static DateTimeComponentsWithFractionalPart execute(UInt32 t, const DateLUTImpl & time_zone)
     {
         return DateTimeComponentsWithFractionalPart{time_zone.toDateTimeComponents(static_cast<DateLUTImpl::Time>(t)), 0, 0};
     }
-    static inline DateTimeComponentsWithFractionalPart execute(Int32 d, const DateLUTImpl & time_zone)
+    static DateTimeComponentsWithFractionalPart execute(Int32 d, const DateLUTImpl & time_zone)
     {
         return DateTimeComponentsWithFractionalPart{time_zone.toDateTimeComponents(ExtendedDayNum(d)), 0, 0};
     }
-    static inline DateTimeComponentsWithFractionalPart execute(UInt16 d, const DateLUTImpl & time_zone)
+    static DateTimeComponentsWithFractionalPart execute(UInt16 d, const DateLUTImpl & time_zone)
     {
         return DateTimeComponentsWithFractionalPart{time_zone.toDateTimeComponents(DayNum(d)), 0, 0};
     }
diff --git a/src/Functions/base64Decode.cpp b/src/Functions/base64Decode.cpp
index 842ceeb3a87..5f7a3406c62 100644
--- a/src/Functions/base64Decode.cpp
+++ b/src/Functions/base64Decode.cpp
@@ -9,7 +9,7 @@ REGISTER_FUNCTION(Base64Decode)
 {
     factory.registerFunction<FunctionBase64Conversion<Base64Decode>>();
 
-    /// MysQL compatibility alias.
+    /// MySQL compatibility alias.
     factory.registerAlias("FROM_BASE64", "base64Decode", FunctionFactory::CaseInsensitive);
 }
 }
diff --git a/src/Functions/base64Encode.cpp b/src/Functions/base64Encode.cpp
index 38b45790a3a..69268f5a25d 100644
--- a/src/Functions/base64Encode.cpp
+++ b/src/Functions/base64Encode.cpp
@@ -9,7 +9,7 @@ REGISTER_FUNCTION(Base64Encode)
 {
     factory.registerFunction<FunctionBase64Conversion<Base64Encode>>();
 
-    /// MysQL compatibility alias.
+    /// MySQL compatibility alias.
     factory.registerAlias("TO_BASE64", "base64Encode", FunctionFactory::CaseInsensitive);
 }
 }
diff --git a/src/Functions/toDayOfMonth.cpp b/src/Functions/toDayOfMonth.cpp
index d7689ef00f2..c20b0b75797 100644
--- a/src/Functions/toDayOfMonth.cpp
+++ b/src/Functions/toDayOfMonth.cpp
@@ -13,7 +13,7 @@ REGISTER_FUNCTION(ToDayOfMonth)
 {
     factory.registerFunction<FunctionToDayOfMonth>();
 
-    /// MysQL compatibility alias.
+    /// MySQL compatibility alias.
     factory.registerAlias("DAY", "toDayOfMonth", FunctionFactory::CaseInsensitive);
     factory.registerAlias("DAYOFMONTH", "toDayOfMonth", FunctionFactory::CaseInsensitive);
 }
diff --git a/src/Functions/toDayOfWeek.cpp b/src/Functions/toDayOfWeek.cpp
index 06343714b9d..dc508d70814 100644
--- a/src/Functions/toDayOfWeek.cpp
+++ b/src/Functions/toDayOfWeek.cpp
@@ -12,7 +12,7 @@ REGISTER_FUNCTION(ToDayOfWeek)
 {
     factory.registerFunction<FunctionToDayOfWeek>();
 
-    /// MysQL compatibility alias.
+    /// MySQL compatibility alias.
     factory.registerAlias("DAYOFWEEK", "toDayOfWeek", FunctionFactory::CaseInsensitive);
 }
 
diff --git a/src/Functions/toDayOfYear.cpp b/src/Functions/toDayOfYear.cpp
index 8b03f1a4211..0cbafd6275a 100644
--- a/src/Functions/toDayOfYear.cpp
+++ b/src/Functions/toDayOfYear.cpp
@@ -13,7 +13,7 @@ REGISTER_FUNCTION(ToDayOfYear)
 {
     factory.registerFunction<FunctionToDayOfYear>();
 
-    /// MysQL compatibility alias.
+    /// MySQL compatibility alias.
     factory.registerAlias("DAYOFYEAR", "toDayOfYear", FunctionFactory::CaseInsensitive);
 }
 
diff --git a/src/Functions/toDaysSinceYearZero.cpp b/src/Functions/toDaysSinceYearZero.cpp
new file mode 100644
index 00000000000..e569c5cb1f3
--- /dev/null
+++ b/src/Functions/toDaysSinceYearZero.cpp
@@ -0,0 +1,83 @@
+#include <Columns/ColumnsNumber.h>
+#include <DataTypes/DataTypeDate.h>
+#include <DataTypes/DataTypeDate32.h>
+#include <DataTypes/DataTypesNumber.h>
+#include <Functions/DateTimeTransforms.h>
+#include <Functions/FunctionFactory.h>
+#include <Functions/FunctionHelpers.h>
+#include <Functions/IFunction.h>
+
+
+namespace DB
+{
+
+namespace ErrorCodes
+{
+    extern const int ILLEGAL_TYPE_OF_ARGUMENT;
+}
+
+namespace
+{
+
+/** Returns number of days passed since 0000-01-01 */
+class FunctionToDaysSinceYearZero : public IFunction
+{
+    using ResultType = DataTypeUInt32;
+public:
+    static constexpr auto name = "toDaysSinceYearZero";
+    static FunctionPtr create(ContextPtr context) { return std::make_shared<FunctionToDaysSinceYearZero>(context); }
+
+    explicit FunctionToDaysSinceYearZero(ContextPtr /*context*/) {}
+
+    String getName() const override { return name; }
+    size_t getNumberOfArguments() const override { return 1; }
+    bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & /*arguments*/) const override { return true; }
+    bool useDefaultImplementationForConstants() const override { return true; }
+
+    DataTypePtr getReturnTypeImpl(const ColumnsWithTypeAndName & arguments) const override
+    {
+        FunctionArgumentDescriptors mandatory_args{
+            {"date", &isDateOrDate32<IDataType>, nullptr, "Date or Date32"}
+        };
+
+        validateFunctionArgumentTypes(*this, arguments, mandatory_args);
+
+        return std::make_shared<DataTypeUInt32>();
+    }
+
+    ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count) const override
+    {
+        const IDataType * from_type = arguments[0].type.get();
+        WhichDataType which(from_type);
+
+        if (which.isDate())
+            return DateTimeTransformImpl<DataTypeDate, ResultType, ToDaysSinceYearZeroImpl>::execute(arguments, result_type, input_rows_count);
+        else if (which.isDate32())
+            return DateTimeTransformImpl<DataTypeDate32, ResultType, ToDaysSinceYearZeroImpl>::execute(arguments, result_type, input_rows_count);
+
+        throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
+            "Illegal type {} of argument of function {}",
+            arguments[0].type->getName(), this->getName());
+    }
+};
+
+}
+
+REGISTER_FUNCTION(ToDaysSinceYearZero)
+{
+    factory.registerFunction<FunctionToDaysSinceYearZero>(
+    FunctionDocumentation{
+    .description=R"(
+Returns for a given date, the number of days passed since 1 January 0000 in the proleptic Gregorian calendar defined by ISO 8601.
+The calculation is the same as in MySQL's TO_DAYS() function.
+)",
+    .examples{
+        {"typical", "SELECT toDaysSinceYearZero(toDate('2023-09-08'))", "713569"}},
+    .categories{"Dates and Times"}
+    });
+
+    /// MySQL compatibility alias.
+    factory.registerAlias("TO_DAYS", FunctionToDaysSinceYearZero::name, FunctionFactory::CaseInsensitive);
+}
+
+}
diff --git a/src/Functions/toHour.cpp b/src/Functions/toHour.cpp
index a6a57946e33..fc9ec657adf 100644
--- a/src/Functions/toHour.cpp
+++ b/src/Functions/toHour.cpp
@@ -13,7 +13,7 @@ REGISTER_FUNCTION(ToHour)
 {
     factory.registerFunction<FunctionToHour>();
 
-    /// MysQL compatibility alias.
+    /// MySQL compatibility alias.
     factory.registerAlias("HOUR", "toHour", FunctionFactory::CaseInsensitive);
 }
 
diff --git a/src/Functions/toMinute.cpp b/src/Functions/toMinute.cpp
index 25939870554..162ecb282df 100644
--- a/src/Functions/toMinute.cpp
+++ b/src/Functions/toMinute.cpp
@@ -13,7 +13,7 @@ REGISTER_FUNCTION(ToMinute)
 {
     factory.registerFunction<FunctionToMinute>();
 
-    /// MysQL compatibility alias.
+    /// MySQL compatibility alias.
     factory.registerAlias("MINUTE", "toMinute", FunctionFactory::CaseInsensitive);
 }
 
diff --git a/src/Functions/toMonth.cpp b/src/Functions/toMonth.cpp
index 783a1341e23..422f21e7df8 100644
--- a/src/Functions/toMonth.cpp
+++ b/src/Functions/toMonth.cpp
@@ -12,7 +12,7 @@ using FunctionToMonth = FunctionDateOrDateTimeToSomething<DataTypeUInt8, ToMonth
 REGISTER_FUNCTION(ToMonth)
 {
     factory.registerFunction<FunctionToMonth>();
-    /// MysQL compatibility alias.
+    /// MySQL compatibility alias.
     factory.registerAlias("MONTH", "toMonth", FunctionFactory::CaseInsensitive);
 }
 
diff --git a/src/Functions/toQuarter.cpp b/src/Functions/toQuarter.cpp
index 2268b6402c6..3c301095ff2 100644
--- a/src/Functions/toQuarter.cpp
+++ b/src/Functions/toQuarter.cpp
@@ -12,7 +12,7 @@ using FunctionToQuarter = FunctionDateOrDateTimeToSomething<DataTypeUInt8, ToQua
 REGISTER_FUNCTION(ToQuarter)
 {
     factory.registerFunction<FunctionToQuarter>();
-    /// MysQL compatibility alias.
+    /// MySQL compatibility alias.
     factory.registerAlias("QUARTER", "toQuarter", FunctionFactory::CaseInsensitive);
 }
 
diff --git a/src/Functions/toSecond.cpp b/src/Functions/toSecond.cpp
index 2fd64912c0f..372097fd488 100644
--- a/src/Functions/toSecond.cpp
+++ b/src/Functions/toSecond.cpp
@@ -13,7 +13,7 @@ REGISTER_FUNCTION(ToSecond)
 {
     factory.registerFunction<FunctionToSecond>();
 
-    /// MysQL compatibility alias.
+    /// MySQL compatibility alias.
     factory.registerAlias("SECOND", "toSecond", FunctionFactory::CaseInsensitive);
 }
 
diff --git a/src/Functions/toYear.cpp b/src/Functions/toYear.cpp
index 9cf2a260921..75479adb82c 100644
--- a/src/Functions/toYear.cpp
+++ b/src/Functions/toYear.cpp
@@ -13,7 +13,7 @@ REGISTER_FUNCTION(ToYear)
 {
     factory.registerFunction<FunctionToYear>();
 
-    /// MysQL compatibility alias.
+    /// MySQL compatibility alias.
     factory.registerAlias("YEAR", "toYear", FunctionFactory::CaseInsensitive);
 }
 
diff --git a/tests/queries/0_stateless/02874_toDaysSinceYearZero.reference b/tests/queries/0_stateless/02874_toDaysSinceYearZero.reference
new file mode 100644
index 00000000000..885332ab835
--- /dev/null
+++ b/tests/queries/0_stateless/02874_toDaysSinceYearZero.reference
@@ -0,0 +1,13 @@
+Invalid parameters
+Const argument
+693961
+713569
+668394
+713569
+\N
+Non-const argument
+713569
+713569
+MySQL alias
+713569
+713569
diff --git a/tests/queries/0_stateless/02874_toDaysSinceYearZero.sql b/tests/queries/0_stateless/02874_toDaysSinceYearZero.sql
new file mode 100644
index 00000000000..2c35920e569
--- /dev/null
+++ b/tests/queries/0_stateless/02874_toDaysSinceYearZero.sql
@@ -0,0 +1,22 @@
+SELECT 'Invalid parameters';
+SELECT toDaysSinceYearZero(); -- { serverError NUMBER_OF_ARGUMENTS_DOESNT_MATCH }
+SELECT toDaysSinceYearZero(toDate('2023-09-08'), toDate('2023-09-08')); -- { serverError NUMBER_OF_ARGUMENTS_DOESNT_MATCH }
+SELECT toDaysSinceYearZero('str'); -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
+SELECT toDaysSinceYearZero(42); -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
+SELECT toDaysSinceYearZero(toDateTime('2023-09-08 11:11:11')); -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
+SELECT toDaysSinceYearZero(toDateTime64('2023-09-08 11:11:11', 3)); -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
+
+SELECT 'Const argument';
+SELECT toDaysSinceYearZero(toDate('1970-01-01'));
+SELECT toDaysSinceYearZero(toDate('2023-09-08'));
+SELECT toDaysSinceYearZero(toDate32('1900-01-01'));
+SELECT toDaysSinceYearZero(toDate32('2023-09-08'));
+SELECT toDaysSinceYearZero(NULL);
+
+SELECT 'Non-const argument';
+SELECT toDaysSinceYearZero(materialize(toDate('2023-09-08')));
+SELECT toDaysSinceYearZero(materialize(toDate32('2023-09-08')));
+
+SELECT 'MySQL alias';
+SELECT to_days(toDate('2023-09-08'));
+SELECT TO_DAYS(toDate('2023-09-08'));
diff --git a/utils/check-style/aspell-ignore/en/aspell-dict.txt b/utils/check-style/aspell-ignore/en/aspell-dict.txt
index 6e26a8c8d17..0b6d97998c1 100644
--- a/utils/check-style/aspell-ignore/en/aspell-dict.txt
+++ b/utils/check-style/aspell-ignore/en/aspell-dict.txt
@@ -2002,6 +2002,7 @@ privateKeyPassphraseHandler
 prlimit
 procfs
 profiler
+proleptic
 prometheus
 proto
 protobuf
@@ -2358,6 +2359,7 @@ toDateTimeOrZero
 toDayOfMonth
 toDayOfWeek
 toDayOfYear
+toDaysSinceYearZero
 toDecimal
 toDecimalString
 toFixedString