diff --git a/CMakeLists.txt b/CMakeLists.txt
index cb91f879d5b..a3c0f0fe863 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -169,8 +169,8 @@ endif ()
 option(ENABLE_TESTS "Provide unit_test_dbms target with Google.Test unit tests" ON)
 option(ENABLE_EXAMPLES "Build all example programs in 'examples' subdirectories" OFF)
 
-if (OS_LINUX AND NOT UNBUNDLED AND MAKE_STATIC_LIBRARIES AND NOT SPLIT_SHARED_LIBRARIES AND CMAKE_VERSION VERSION_GREATER "3.9.0")
-    # Only for Linux, x86_64.
+if (OS_LINUX AND (ARCH_AMD64 OR ARCH_AARCH64) AND NOT UNBUNDLED AND MAKE_STATIC_LIBRARIES AND NOT SPLIT_SHARED_LIBRARIES AND CMAKE_VERSION VERSION_GREATER "3.9.0")
+    # Only for Linux, x86_64 or aarch64.
     option(GLIBC_COMPATIBILITY "Enable compatibility with older glibc libraries." ON)
 elseif(GLIBC_COMPATIBILITY)
     message (${RECONFIGURE_MESSAGE_LEVEL} "Glibc compatibility cannot be enabled in current configuration")
diff --git a/base/common/DecomposedFloat.h b/base/common/DecomposedFloat.h
new file mode 100644
index 00000000000..078ba823c15
--- /dev/null
+++ b/base/common/DecomposedFloat.h
@@ -0,0 +1,216 @@
+#pragma once
+
+#include <cstdint>
+#include <cstddef>
+#include <cstring>
+#include <common/extended_types.h>
+
+
+/// Allows to check the internals of IEEE-754 floating point number.
+
+template <typename T> struct FloatTraits;
+
+template <>
+struct FloatTraits<float>
+{
+    using UInt = uint32_t;
+    static constexpr size_t bits = 32;
+    static constexpr size_t exponent_bits = 8;
+    static constexpr size_t mantissa_bits = bits - exponent_bits - 1;
+};
+
+template <>
+struct FloatTraits<double>
+{
+    using UInt = uint64_t;
+    static constexpr size_t bits = 64;
+    static constexpr size_t exponent_bits = 11;
+    static constexpr size_t mantissa_bits = bits - exponent_bits - 1;
+};
+
+
+/// x = sign * (2 ^ normalized_exponent) * (1 + mantissa * 2 ^ -mantissa_bits)
+/// x = sign * (2 ^ normalized_exponent + mantissa * 2 ^ (normalized_exponent - mantissa_bits))
+template <typename T>
+struct DecomposedFloat
+{
+    using Traits = FloatTraits<T>;
+
+    DecomposedFloat(T x)
+    {
+        memcpy(&x_uint, &x, sizeof(x));
+    }
+
+    typename Traits::UInt x_uint;
+
+    bool is_negative() const
+    {
+        return x_uint >> (Traits::bits - 1);
+    }
+
+    /// Returns 0 for both +0. and -0.
+    int sign() const
+    {
+        return (exponent() == 0 && mantissa() == 0)
+            ? 0
+            : (is_negative()
+                ? -1
+                : 1);
+    }
+
+    uint16_t exponent() const
+    {
+        return (x_uint >> (Traits::mantissa_bits)) & (((1ull << (Traits::exponent_bits + 1)) - 1) >> 1);
+    }
+
+    int16_t normalized_exponent() const
+    {
+        return int16_t(exponent()) - ((1ull << (Traits::exponent_bits - 1)) - 1);
+    }
+
+    uint64_t mantissa() const
+    {
+        return x_uint & ((1ull << Traits::mantissa_bits) - 1);
+    }
+
+    int64_t mantissa_with_sign() const
+    {
+        return is_negative() ? -mantissa() : mantissa();
+    }
+
+    /// NOTE Probably floating point instructions can be better.
+    bool is_integer_in_representable_range() const
+    {
+        return x_uint == 0
+            || (normalized_exponent() >= 0  /// The number is not less than one
+                /// The number is inside the range where every integer has exact representation in float
+                && normalized_exponent() <= static_cast<int16_t>(Traits::mantissa_bits)
+                /// After multiplying by 2^exp, the fractional part becomes zero, means the number is integer
+                && ((mantissa() & ((1ULL << (Traits::mantissa_bits - normalized_exponent())) - 1)) == 0));
+    }
+
+
+    /// Compare float with integer of arbitrary width (both signed and unsigned are supported). Assuming two's complement arithmetic.
+    /// Infinities are compared correctly. NaNs are treat similarly to infinities, so they can be less than all numbers.
+    /// (note that we need total order)
+    template <typename Int>
+    int compare(Int rhs)
+    {
+        if (rhs == 0)
+            return sign();
+
+        /// Different signs
+        if (is_negative() && rhs > 0)
+            return -1;
+        if (!is_negative() && rhs < 0)
+            return 1;
+
+        /// Fractional number with magnitude less than one
+        if (normalized_exponent() < 0)
+        {
+            if (!is_negative())
+                return rhs > 0 ? -1 : 1;
+            else
+                return rhs >= 0 ? -1 : 1;
+        }
+
+        /// The case of the most negative integer
+        if constexpr (is_signed_v<Int>)
+        {
+            if (rhs == std::numeric_limits<Int>::lowest())
+            {
+                assert(is_negative());
+
+                if (normalized_exponent() < static_cast<int16_t>(8 * sizeof(Int) - is_signed_v<Int>))
+                    return 1;
+                if (normalized_exponent() > static_cast<int16_t>(8 * sizeof(Int) - is_signed_v<Int>))
+                    return -1;
+
+                if (mantissa() == 0)
+                    return 0;
+                else
+                    return -1;
+            }
+        }
+
+        /// Too large number: abs(float) > abs(rhs). Also the case with infinities and NaN.
+        if (normalized_exponent() >= static_cast<int16_t>(8 * sizeof(Int) - is_signed_v<Int>))
+            return is_negative() ? -1 : 1;
+
+        using UInt = make_unsigned_t<Int>;
+        UInt uint_rhs = rhs < 0 ? -rhs : rhs;
+
+        /// Smaller octave: abs(rhs) < abs(float)
+        if (uint_rhs < (static_cast<UInt>(1) << normalized_exponent()))
+            return is_negative() ? -1 : 1;
+
+        /// Larger octave: abs(rhs) > abs(float)
+        if (normalized_exponent() + 1 < static_cast<int16_t>(8 * sizeof(Int) - is_signed_v<Int>)
+            && uint_rhs >= (static_cast<UInt>(1) << (normalized_exponent() + 1)))
+            return is_negative() ? 1 : -1;
+
+        /// The same octave
+        /// uint_rhs == 2 ^ normalized_exponent + mantissa * 2 ^ (normalized_exponent - mantissa_bits)
+
+        bool large_and_always_integer = normalized_exponent() >= static_cast<int16_t>(Traits::mantissa_bits);
+
+        typename Traits::UInt a = large_and_always_integer
+            ? mantissa() << (normalized_exponent() - Traits::mantissa_bits)
+            : mantissa() >> (Traits::mantissa_bits - normalized_exponent());
+
+        typename Traits::UInt b = uint_rhs - (static_cast<UInt>(1) << normalized_exponent());
+
+        if (a < b)
+            return is_negative() ? 1 : -1;
+        if (a > b)
+            return is_negative() ? -1 : 1;
+
+        /// Float has no fractional part means that the numbers are equal.
+        if (large_and_always_integer || (mantissa() & ((1ULL << (Traits::mantissa_bits - normalized_exponent())) - 1)) == 0)
+            return 0;
+        else
+            /// Float has fractional part means its abs value is larger.
+            return is_negative() ? -1 : 1;
+    }
+
+
+    template <typename Int>
+    bool equals(Int rhs)
+    {
+        return compare(rhs) == 0;
+    }
+
+    template <typename Int>
+    bool notEquals(Int rhs)
+    {
+        return compare(rhs) != 0;
+    }
+
+    template <typename Int>
+    bool less(Int rhs)
+    {
+        return compare(rhs) < 0;
+    }
+
+    template <typename Int>
+    bool greater(Int rhs)
+    {
+        return compare(rhs) > 0;
+    }
+
+    template <typename Int>
+    bool lessOrEquals(Int rhs)
+    {
+        return compare(rhs) <= 0;
+    }
+
+    template <typename Int>
+    bool greaterOrEquals(Int rhs)
+    {
+        return compare(rhs) >= 0;
+    }
+};
+
+
+using DecomposedFloat64 = DecomposedFloat<double>;
+using DecomposedFloat32 = DecomposedFloat<float>;
diff --git a/base/common/arithmeticOverflow.h b/base/common/arithmeticOverflow.h
index c170d214636..175e75a62f4 100644
--- a/base/common/arithmeticOverflow.h
+++ b/base/common/arithmeticOverflow.h
@@ -56,27 +56,33 @@ namespace common
     }
 
     template <>
-    inline bool addOverflow(__int128 x, __int128 y, __int128 & res)
+    inline bool addOverflow(Int128 x, Int128 y, Int128 & res)
     {
-        static constexpr __int128 min_int128 = minInt128();
-        static constexpr __int128 max_int128 = maxInt128();
         res = addIgnoreOverflow(x, y);
-        return (y > 0 && x > max_int128 - y) || (y < 0 && x < min_int128 - y);
+        return (y > 0 && x > std::numeric_limits<Int128>::max() - y) ||
+            (y < 0 && x < std::numeric_limits<Int128>::min() - y);
     }
 
     template <>
-    inline bool addOverflow(wInt256 x, wInt256 y, wInt256 & res)
+    inline bool addOverflow(UInt128 x, UInt128 y, UInt128 & res)
     {
         res = addIgnoreOverflow(x, y);
-        return (y > 0 && x > std::numeric_limits<wInt256>::max() - y) ||
-            (y < 0 && x < std::numeric_limits<wInt256>::min() - y);
+        return x > std::numeric_limits<UInt128>::max() - y;
     }
 
     template <>
-    inline bool addOverflow(wUInt256 x, wUInt256 y, wUInt256 & res)
+    inline bool addOverflow(Int256 x, Int256 y, Int256 & res)
     {
         res = addIgnoreOverflow(x, y);
-        return x > std::numeric_limits<wUInt256>::max() - y;
+        return (y > 0 && x > std::numeric_limits<Int256>::max() - y) ||
+            (y < 0 && x < std::numeric_limits<Int256>::min() - y);
+    }
+
+    template <>
+    inline bool addOverflow(UInt256 x, UInt256 y, UInt256 & res)
+    {
+        res = addIgnoreOverflow(x, y);
+        return x > std::numeric_limits<UInt256>::max() - y;
     }
 
     template <typename T>
@@ -104,24 +110,30 @@ namespace common
     }
 
     template <>
-    inline bool subOverflow(__int128 x, __int128 y, __int128 & res)
+    inline bool subOverflow(Int128 x, Int128 y, Int128 & res)
     {
-        static constexpr __int128 min_int128 = minInt128();
-        static constexpr __int128 max_int128 = maxInt128();
         res = subIgnoreOverflow(x, y);
-        return (y < 0 && x > max_int128 + y) || (y > 0 && x < min_int128 + y);
+        return (y < 0 && x > std::numeric_limits<Int128>::max() + y) ||
+            (y > 0 && x < std::numeric_limits<Int128>::min() + y);
     }
 
     template <>
-    inline bool subOverflow(wInt256 x, wInt256 y, wInt256 & res)
+    inline bool subOverflow(UInt128 x, UInt128 y, UInt128 & res)
     {
         res = subIgnoreOverflow(x, y);
-        return (y < 0 && x > std::numeric_limits<wInt256>::max() + y) ||
-            (y > 0 && x < std::numeric_limits<wInt256>::min() + y);
+        return x < y;
     }
 
     template <>
-    inline bool subOverflow(wUInt256 x, wUInt256 y, wUInt256 & res)
+    inline bool subOverflow(Int256 x, Int256 y, Int256 & res)
+    {
+        res = subIgnoreOverflow(x, y);
+        return (y < 0 && x > std::numeric_limits<Int256>::max() + y) ||
+            (y > 0 && x < std::numeric_limits<Int256>::min() + y);
+    }
+
+    template <>
+    inline bool subOverflow(UInt256 x, UInt256 y, UInt256 & res)
     {
         res = subIgnoreOverflow(x, y);
         return x < y;
@@ -151,36 +163,33 @@ namespace common
         return __builtin_smulll_overflow(x, y, &res);
     }
 
+    /// Overflow check is not implemented for big integers.
+
     template <>
-    inline bool mulOverflow(__int128 x, __int128 y, __int128 & res)
+    inline bool mulOverflow(Int128 x, Int128 y, Int128 & res)
     {
         res = mulIgnoreOverflow(x, y);
-        if (!x || !y)
-            return false;
-
-        unsigned __int128 a = (x > 0) ? x : -x;
-        unsigned __int128 b = (y > 0) ? y : -y;
-        return mulIgnoreOverflow(a, b) / b != a;
+        return false;
     }
 
     template <>
-    inline bool mulOverflow(wInt256 x, wInt256 y, wInt256 & res)
+    inline bool mulOverflow(Int256 x, Int256 y, Int256 & res)
     {
         res = mulIgnoreOverflow(x, y);
-        if (!x || !y)
-            return false;
-
-        wInt256 a = (x > 0) ? x : -x;
-        wInt256 b = (y > 0) ? y : -y;
-        return mulIgnoreOverflow(a, b) / b != a;
+        return false;
     }
 
     template <>
-    inline bool mulOverflow(wUInt256 x, wUInt256 y, wUInt256 & res)
+    inline bool mulOverflow(UInt128 x, UInt128 y, UInt128 & res)
     {
         res = mulIgnoreOverflow(x, y);
-        if (!x || !y)
-            return false;
-        return res / y != x;
+        return false;
+    }
+
+    template <>
+    inline bool mulOverflow(UInt256 x, UInt256 y, UInt256 & res)
+    {
+        res = mulIgnoreOverflow(x, y);
+        return false;
     }
 }
diff --git a/base/common/extended_types.h b/base/common/extended_types.h
index 2ae70c0f432..79209568ef5 100644
--- a/base/common/extended_types.h
+++ b/base/common/extended_types.h
@@ -5,16 +5,14 @@
 #include <common/types.h>
 #include <common/wide_integer.h>
 
-using Int128 = __int128;
 
-using wInt256 = wide::integer<256, signed>;
-using wUInt256 = wide::integer<256, unsigned>;
+using Int128 = wide::integer<128, signed>;
+using UInt128 = wide::integer<128, unsigned>;
+using Int256 = wide::integer<256, signed>;
+using UInt256 = wide::integer<256, unsigned>;
 
-static_assert(sizeof(wInt256) == 32);
-static_assert(sizeof(wUInt256) == 32);
-
-static constexpr __int128 minInt128() { return static_cast<unsigned __int128>(1) << 127; }
-static constexpr __int128 maxInt128() { return (static_cast<unsigned __int128>(1) << 127) - 1; }
+static_assert(sizeof(Int256) == 32);
+static_assert(sizeof(UInt256) == 32);
 
 /// The standard library type traits, such as std::is_arithmetic, with one exception
 /// (std::common_type), are "set in stone". Attempting to specialize them causes undefined behavior.
@@ -26,7 +24,7 @@ struct is_signed
 };
 
 template <> struct is_signed<Int128> { static constexpr bool value = true; };
-template <> struct is_signed<wInt256> { static constexpr bool value = true; };
+template <> struct is_signed<Int256> { static constexpr bool value = true; };
 
 template <typename T>
 inline constexpr bool is_signed_v = is_signed<T>::value;
@@ -37,7 +35,8 @@ struct is_unsigned
     static constexpr bool value = std::is_unsigned_v<T>;
 };
 
-template <> struct is_unsigned<wUInt256> { static constexpr bool value = true; };
+template <> struct is_unsigned<UInt128> { static constexpr bool value = true; };
+template <> struct is_unsigned<UInt256> { static constexpr bool value = true; };
 
 template <typename T>
 inline constexpr bool is_unsigned_v = is_unsigned<T>::value;
@@ -51,8 +50,9 @@ struct is_integer
 };
 
 template <> struct is_integer<Int128> { static constexpr bool value = true; };
-template <> struct is_integer<wInt256> { static constexpr bool value = true; };
-template <> struct is_integer<wUInt256> { static constexpr bool value = true; };
+template <> struct is_integer<UInt128> { static constexpr bool value = true; };
+template <> struct is_integer<Int256> { static constexpr bool value = true; };
+template <> struct is_integer<UInt256> { static constexpr bool value = true; };
 
 template <typename T>
 inline constexpr bool is_integer_v = is_integer<T>::value;
@@ -64,7 +64,11 @@ struct is_arithmetic
     static constexpr bool value = std::is_arithmetic_v<T>;
 };
 
-template <> struct is_arithmetic<__int128> { static constexpr bool value = true; };
+template <> struct is_arithmetic<Int128> { static constexpr bool value = true; };
+template <> struct is_arithmetic<UInt128> { static constexpr bool value = true; };
+template <> struct is_arithmetic<Int256> { static constexpr bool value = true; };
+template <> struct is_arithmetic<UInt256> { static constexpr bool value = true; };
+
 
 template <typename T>
 inline constexpr bool is_arithmetic_v = is_arithmetic<T>::value;
@@ -75,9 +79,10 @@ struct make_unsigned
     typedef std::make_unsigned_t<T> type;
 };
 
-template <> struct make_unsigned<Int128> { using type = unsigned __int128; };
-template <> struct make_unsigned<wInt256>  { using type = wUInt256; };
-template <> struct make_unsigned<wUInt256> { using type = wUInt256; };
+template <> struct make_unsigned<Int128> { using type = UInt128; };
+template <> struct make_unsigned<UInt128> { using type = UInt128; };
+template <> struct make_unsigned<Int256>  { using type = UInt256; };
+template <> struct make_unsigned<UInt256> { using type = UInt256; };
 
 template <typename T> using make_unsigned_t = typename make_unsigned<T>::type;
 
@@ -87,8 +92,10 @@ struct make_signed
     typedef std::make_signed_t<T> type;
 };
 
-template <> struct make_signed<wInt256>  { using type = wInt256; };
-template <> struct make_signed<wUInt256> { using type = wInt256; };
+template <> struct make_signed<Int128>  { using type = Int128; };
+template <> struct make_signed<UInt128> { using type = Int128; };
+template <> struct make_signed<Int256>  { using type = Int256; };
+template <> struct make_signed<UInt256> { using type = Int256; };
 
 template <typename T> using make_signed_t = typename make_signed<T>::type;
 
@@ -98,8 +105,10 @@ struct is_big_int
     static constexpr bool value = false;
 };
 
-template <> struct is_big_int<wInt256> { static constexpr bool value = true; };
-template <> struct is_big_int<wUInt256> { static constexpr bool value = true; };
+template <> struct is_big_int<Int128> { static constexpr bool value = true; };
+template <> struct is_big_int<UInt128> { static constexpr bool value = true; };
+template <> struct is_big_int<Int256> { static constexpr bool value = true; };
+template <> struct is_big_int<UInt256> { static constexpr bool value = true; };
 
 template <typename T>
 inline constexpr bool is_big_int_v = is_big_int<T>::value;
diff --git a/base/common/itoa.h b/base/common/itoa.h
index a02e7b68c05..4c86239de36 100644
--- a/base/common/itoa.h
+++ b/base/common/itoa.h
@@ -30,9 +30,8 @@
 #include <cstddef>
 #include <cstring>
 #include <type_traits>
+#include <common/extended_types.h>
 
-using int128_t = __int128;
-using uint128_t = unsigned __int128;
 
 namespace impl
 {
@@ -106,7 +105,7 @@ using UnsignedOfSize = typename SelectType
     uint16_t,
     uint32_t,
     uint64_t,
-    uint128_t
+    __uint128_t
 >::Result;
 
 /// Holds the result of dividing an unsigned N-byte variable by 10^N resulting in
@@ -313,7 +312,8 @@ namespace convert
     }
 }
 
-static inline int digits10(uint128_t x)
+template <typename T>
+static inline int digits10(T x)
 {
     if (x < 10ULL)
         return 1;
@@ -346,8 +346,11 @@ static inline int digits10(uint128_t x)
     return 12 + digits10(x / 1000000000000ULL);
 }
 
-static inline char * writeUIntText(uint128_t x, char * p)
+template <typename T>
+static inline char * writeUIntText(T x, char * p)
 {
+    static_assert(is_unsigned_v<T>);
+
     int len = digits10(x);
     auto pp = p + len;
     while (x >= 100)
@@ -370,14 +373,28 @@ static inline char * writeLeadingMinus(char * pos)
     return pos + 1;
 }
 
-static inline char * writeSIntText(int128_t x, char * pos)
+template <typename T>
+static inline char * writeSIntText(T x, char * pos)
 {
-    static constexpr int128_t min_int128 = uint128_t(1) << 127;
+    static_assert(std::is_same_v<T, Int128> || std::is_same_v<T, Int256>);
 
-    if (unlikely(x == min_int128))
+    using UnsignedT = make_unsigned_t<T>;
+    static constexpr T min_int = UnsignedT(1) << (sizeof(T) * 8 - 1);
+
+    if (unlikely(x == min_int))
     {
-        memcpy(pos, "-170141183460469231731687303715884105728", 40);
-        return pos + 40;
+        if constexpr (std::is_same_v<T, Int128>)
+        {
+            const char * res = "-170141183460469231731687303715884105728";
+            memcpy(pos, res, strlen(res));
+            return pos + strlen(res);
+        }
+        else if constexpr (std::is_same_v<T, Int256>)
+        {
+            const char * res = "-57896044618658097711785492504343953926634992332820282019728792003956564819968";
+            memcpy(pos, res, strlen(res));
+            return pos + strlen(res);
+        }
     }
 
     if (x < 0)
@@ -385,7 +402,7 @@ static inline char * writeSIntText(int128_t x, char * pos)
         x = -x;
         pos = writeLeadingMinus(pos);
     }
-    return writeUIntText(static_cast<uint128_t>(x), pos);
+    return writeUIntText(UnsignedT(x), pos);
 }
 
 }
@@ -403,13 +420,25 @@ inline char * itoa(char8_t i, char * p)
 }
 
 template <>
-inline char * itoa<uint128_t>(uint128_t i, char * p)
+inline char * itoa(UInt128 i, char * p)
 {
     return impl::writeUIntText(i, p);
 }
 
 template <>
-inline char * itoa<int128_t>(int128_t i, char * p)
+inline char * itoa(Int128 i, char * p)
+{
+    return impl::writeSIntText(i, p);
+}
+
+template <>
+inline char * itoa(UInt256 i, char * p)
+{
+    return impl::writeUIntText(i, p);
+}
+
+template <>
+inline char * itoa(Int256 i, char * p)
 {
     return impl::writeSIntText(i, p);
 }
diff --git a/base/common/strong_typedef.h b/base/common/strong_typedef.h
index 77b83bfa6e5..a1e2b253aa7 100644
--- a/base/common/strong_typedef.h
+++ b/base/common/strong_typedef.h
@@ -4,7 +4,8 @@
 #include <type_traits>
 #include <utility>
 
-template <class T, class Tag>
+
+template <typename T, typename Tag>
 struct StrongTypedef
 {
 private:
@@ -38,14 +39,16 @@ public:
 
     bool operator==(const Self & rhs) const { return t == rhs.t; }
     bool operator<(const Self & rhs) const { return t < rhs.t; }
+    bool operator>(const Self & rhs) const { return t > rhs.t; }
 
     T & toUnderType() { return t; }
     const T & toUnderType() const { return t; }
 };
 
+
 namespace std
 {
-    template <class T, class Tag>
+    template <typename T, typename Tag>
     struct hash<StrongTypedef<T, Tag>>
     {
         size_t operator()(const StrongTypedef<T, Tag> & x) const
diff --git a/base/common/throwError.h b/base/common/throwError.h
index b495a0fbc7a..dd352913e78 100644
--- a/base/common/throwError.h
+++ b/base/common/throwError.h
@@ -1,13 +1,15 @@
 #pragma once
+
 #include <stdexcept>
 
+
 /// Throw DB::Exception-like exception before its definition.
 /// DB::Exception derived from Poco::Exception derived from std::exception.
-/// DB::Exception generally cought as Poco::Exception. std::exception generally has other catch blocks and could lead to other outcomes.
+/// DB::Exception generally caught as Poco::Exception. std::exception generally has other catch blocks and could lead to other outcomes.
 /// DB::Exception is not defined yet. It'd better to throw Poco::Exception but we do not want to include any big header here, even <string>.
 /// So we throw some std::exception instead in the hope its catch block is the same as DB::Exception one.
 template <typename T>
-inline void throwError(const T & err)
+[[noreturn]] inline void throwError(const T & err)
 {
     throw std::runtime_error(err);
 }
diff --git a/base/common/wide_integer.h b/base/common/wide_integer.h
index c9d1eaa32aa..419b4e4558c 100644
--- a/base/common/wide_integer.h
+++ b/base/common/wide_integer.h
@@ -58,9 +58,11 @@ public:
     using signed_base_type = int64_t;
 
     // ctors
-    constexpr integer() noexcept;
+    constexpr integer() noexcept = default;
+
     template <typename T>
     constexpr integer(T rhs) noexcept;
+
     template <typename T>
     constexpr integer(std::initializer_list<T> il) noexcept;
 
@@ -108,9 +110,9 @@ public:
     constexpr explicit operator bool() const noexcept;
 
     template <class T>
-    using __integral_not_wide_integer_class = typename std::enable_if<std::is_arithmetic<T>::value, T>::type;
+    using _integral_not_wide_integer_class = typename std::enable_if<std::is_arithmetic<T>::value, T>::type;
 
-    template <class T, class = __integral_not_wide_integer_class<T>>
+    template <class T, class = _integral_not_wide_integer_class<T>>
     constexpr operator T() const noexcept;
 
     constexpr operator long double() const noexcept;
@@ -119,25 +121,27 @@ public:
 
     struct _impl;
 
+    base_type items[_impl::item_count];
+
 private:
     template <size_t Bits2, typename Signed2>
     friend class integer;
 
     friend class std::numeric_limits<integer<Bits, signed>>;
     friend class std::numeric_limits<integer<Bits, unsigned>>;
-
-    base_type items[_impl::item_count];
 };
 
 template <typename T>
 static constexpr bool ArithmeticConcept() noexcept;
+
 template <class T1, class T2>
-using __only_arithmetic = typename std::enable_if<ArithmeticConcept<T1>() && ArithmeticConcept<T2>()>::type;
+using _only_arithmetic = typename std::enable_if<ArithmeticConcept<T1>() && ArithmeticConcept<T2>()>::type;
 
 template <typename T>
 static constexpr bool IntegralConcept() noexcept;
+
 template <class T, class T2>
-using __only_integer = typename std::enable_if<IntegralConcept<T>() && IntegralConcept<T2>()>::type;
+using _only_integer = typename std::enable_if<IntegralConcept<T>() && IntegralConcept<T2>()>::type;
 
 // Unary operators
 template <size_t Bits, typename Signed>
@@ -153,54 +157,55 @@ constexpr integer<Bits, Signed> operator+(const integer<Bits, Signed> & lhs) noe
 template <size_t Bits, typename Signed, size_t Bits2, typename Signed2>
 std::common_type_t<integer<Bits, Signed>, integer<Bits2, Signed2>> constexpr
 operator*(const integer<Bits, Signed> & lhs, const integer<Bits2, Signed2> & rhs);
-template <typename Arithmetic, typename Arithmetic2, class = __only_arithmetic<Arithmetic, Arithmetic2>>
+template <typename Arithmetic, typename Arithmetic2, class = _only_arithmetic<Arithmetic, Arithmetic2>>
 std::common_type_t<Arithmetic, Arithmetic2> constexpr operator*(const Arithmetic & rhs, const Arithmetic2 & lhs);
 
 template <size_t Bits, typename Signed, size_t Bits2, typename Signed2>
 std::common_type_t<integer<Bits, Signed>, integer<Bits2, Signed2>> constexpr
 operator/(const integer<Bits, Signed> & lhs, const integer<Bits2, Signed2> & rhs);
-template <typename Arithmetic, typename Arithmetic2, class = __only_arithmetic<Arithmetic, Arithmetic2>>
+template <typename Arithmetic, typename Arithmetic2, class = _only_arithmetic<Arithmetic, Arithmetic2>>
 std::common_type_t<Arithmetic, Arithmetic2> constexpr operator/(const Arithmetic & rhs, const Arithmetic2 & lhs);
 
 template <size_t Bits, typename Signed, size_t Bits2, typename Signed2>
 std::common_type_t<integer<Bits, Signed>, integer<Bits2, Signed2>> constexpr
 operator+(const integer<Bits, Signed> & lhs, const integer<Bits2, Signed2> & rhs);
-template <typename Arithmetic, typename Arithmetic2, class = __only_arithmetic<Arithmetic, Arithmetic2>>
+template <typename Arithmetic, typename Arithmetic2, class = _only_arithmetic<Arithmetic, Arithmetic2>>
 std::common_type_t<Arithmetic, Arithmetic2> constexpr operator+(const Arithmetic & rhs, const Arithmetic2 & lhs);
 
 template <size_t Bits, typename Signed, size_t Bits2, typename Signed2>
 std::common_type_t<integer<Bits, Signed>, integer<Bits2, Signed2>> constexpr
 operator-(const integer<Bits, Signed> & lhs, const integer<Bits2, Signed2> & rhs);
-template <typename Arithmetic, typename Arithmetic2, class = __only_arithmetic<Arithmetic, Arithmetic2>>
+template <typename Arithmetic, typename Arithmetic2, class = _only_arithmetic<Arithmetic, Arithmetic2>>
 std::common_type_t<Arithmetic, Arithmetic2> constexpr operator-(const Arithmetic & rhs, const Arithmetic2 & lhs);
 
 template <size_t Bits, typename Signed, size_t Bits2, typename Signed2>
 std::common_type_t<integer<Bits, Signed>, integer<Bits2, Signed2>> constexpr
 operator%(const integer<Bits, Signed> & lhs, const integer<Bits2, Signed2> & rhs);
-template <typename Integral, typename Integral2, class = __only_integer<Integral, Integral2>>
+template <typename Integral, typename Integral2, class = _only_integer<Integral, Integral2>>
 std::common_type_t<Integral, Integral2> constexpr operator%(const Integral & rhs, const Integral2 & lhs);
 
 template <size_t Bits, typename Signed, size_t Bits2, typename Signed2>
 std::common_type_t<integer<Bits, Signed>, integer<Bits2, Signed2>> constexpr
 operator&(const integer<Bits, Signed> & lhs, const integer<Bits2, Signed2> & rhs);
-template <typename Integral, typename Integral2, class = __only_integer<Integral, Integral2>>
+template <typename Integral, typename Integral2, class = _only_integer<Integral, Integral2>>
 std::common_type_t<Integral, Integral2> constexpr operator&(const Integral & rhs, const Integral2 & lhs);
 
 template <size_t Bits, typename Signed, size_t Bits2, typename Signed2>
 std::common_type_t<integer<Bits, Signed>, integer<Bits2, Signed2>> constexpr
 operator|(const integer<Bits, Signed> & lhs, const integer<Bits2, Signed2> & rhs);
-template <typename Integral, typename Integral2, class = __only_integer<Integral, Integral2>>
+template <typename Integral, typename Integral2, class = _only_integer<Integral, Integral2>>
 std::common_type_t<Integral, Integral2> constexpr operator|(const Integral & rhs, const Integral2 & lhs);
 
 template <size_t Bits, typename Signed, size_t Bits2, typename Signed2>
 std::common_type_t<integer<Bits, Signed>, integer<Bits2, Signed2>> constexpr
 operator^(const integer<Bits, Signed> & lhs, const integer<Bits2, Signed2> & rhs);
-template <typename Integral, typename Integral2, class = __only_integer<Integral, Integral2>>
+template <typename Integral, typename Integral2, class = _only_integer<Integral, Integral2>>
 std::common_type_t<Integral, Integral2> constexpr operator^(const Integral & rhs, const Integral2 & lhs);
 
 // TODO: Integral
 template <size_t Bits, typename Signed>
 constexpr integer<Bits, Signed> operator<<(const integer<Bits, Signed> & lhs, int n) noexcept;
+
 template <size_t Bits, typename Signed>
 constexpr integer<Bits, Signed> operator>>(const integer<Bits, Signed> & lhs, int n) noexcept;
 
@@ -217,32 +222,32 @@ constexpr integer<Bits, Signed> operator>>(const integer<Bits, Signed> & lhs, In
 
 template <size_t Bits, typename Signed, size_t Bits2, typename Signed2>
 constexpr bool operator<(const integer<Bits, Signed> & lhs, const integer<Bits2, Signed2> & rhs);
-template <typename Arithmetic, typename Arithmetic2, class = __only_arithmetic<Arithmetic, Arithmetic2>>
+template <typename Arithmetic, typename Arithmetic2, class = _only_arithmetic<Arithmetic, Arithmetic2>>
 constexpr bool operator<(const Arithmetic & rhs, const Arithmetic2 & lhs);
 
 template <size_t Bits, typename Signed, size_t Bits2, typename Signed2>
 constexpr bool operator>(const integer<Bits, Signed> & lhs, const integer<Bits2, Signed2> & rhs);
-template <typename Arithmetic, typename Arithmetic2, class = __only_arithmetic<Arithmetic, Arithmetic2>>
+template <typename Arithmetic, typename Arithmetic2, class = _only_arithmetic<Arithmetic, Arithmetic2>>
 constexpr bool operator>(const Arithmetic & rhs, const Arithmetic2 & lhs);
 
 template <size_t Bits, typename Signed, size_t Bits2, typename Signed2>
 constexpr bool operator<=(const integer<Bits, Signed> & lhs, const integer<Bits2, Signed2> & rhs);
-template <typename Arithmetic, typename Arithmetic2, class = __only_arithmetic<Arithmetic, Arithmetic2>>
+template <typename Arithmetic, typename Arithmetic2, class = _only_arithmetic<Arithmetic, Arithmetic2>>
 constexpr bool operator<=(const Arithmetic & rhs, const Arithmetic2 & lhs);
 
 template <size_t Bits, typename Signed, size_t Bits2, typename Signed2>
 constexpr bool operator>=(const integer<Bits, Signed> & lhs, const integer<Bits2, Signed2> & rhs);
-template <typename Arithmetic, typename Arithmetic2, class = __only_arithmetic<Arithmetic, Arithmetic2>>
+template <typename Arithmetic, typename Arithmetic2, class = _only_arithmetic<Arithmetic, Arithmetic2>>
 constexpr bool operator>=(const Arithmetic & rhs, const Arithmetic2 & lhs);
 
 template <size_t Bits, typename Signed, size_t Bits2, typename Signed2>
 constexpr bool operator==(const integer<Bits, Signed> & lhs, const integer<Bits2, Signed2> & rhs);
-template <typename Arithmetic, typename Arithmetic2, class = __only_arithmetic<Arithmetic, Arithmetic2>>
+template <typename Arithmetic, typename Arithmetic2, class = _only_arithmetic<Arithmetic, Arithmetic2>>
 constexpr bool operator==(const Arithmetic & rhs, const Arithmetic2 & lhs);
 
 template <size_t Bits, typename Signed, size_t Bits2, typename Signed2>
 constexpr bool operator!=(const integer<Bits, Signed> & lhs, const integer<Bits2, Signed2> & rhs);
-template <typename Arithmetic, typename Arithmetic2, class = __only_arithmetic<Arithmetic, Arithmetic2>>
+template <typename Arithmetic, typename Arithmetic2, class = _only_arithmetic<Arithmetic, Arithmetic2>>
 constexpr bool operator!=(const Arithmetic & rhs, const Arithmetic2 & lhs);
 
 }
diff --git a/base/common/wide_integer_impl.h b/base/common/wide_integer_impl.h
index 456c10a22e4..725caec6a3e 100644
--- a/base/common/wide_integer_impl.h
+++ b/base/common/wide_integer_impl.h
@@ -5,6 +5,7 @@
 /// (See at http://www.boost.org/LICENSE_1_0.txt)
 
 #include "throwError.h"
+
 #include <cmath>
 #include <cfloat>
 #include <cassert>
@@ -81,7 +82,7 @@ public:
             res.items[T::_impl::big(0)] = std::numeric_limits<typename wide::integer<Bits, Signed>::signed_base_type>::min();
             return res;
         }
-        return 0;
+        return wide::integer<Bits, Signed>(0);
     }
 
     static constexpr wide::integer<Bits, Signed> max() noexcept
@@ -176,7 +177,7 @@ struct integer<Bits, Signed>::_impl
     constexpr static bool is_negative(const integer<B, T> & n) noexcept
     {
         if constexpr (std::is_same_v<T, signed>)
-            return static_cast<signed_base_type>(n.items[big(0)]) < 0;
+            return static_cast<signed_base_type>(n.items[integer<B, T>::_impl::big(0)]) < 0;
         else
             return false;
     }
@@ -193,40 +194,36 @@ struct integer<Bits, Signed>::_impl
     template <size_t B, class S>
     constexpr static integer<B, S> make_positive(const integer<B, S> & n) noexcept
     {
-        return is_negative(n) ? operator_unary_minus(n) : n;
+        return is_negative(n) ? integer<B, S>(operator_unary_minus(n)) : n;
     }
 
     template <typename T>
     __attribute__((no_sanitize("undefined"))) constexpr static auto to_Integral(T f) noexcept
     {
-        if constexpr (std::is_same_v<T, __int128>)
-            return f;
-        else if constexpr (std::is_signed_v<T>)
+        if constexpr (std::is_signed_v<T>)
             return static_cast<int64_t>(f);
         else
             return static_cast<uint64_t>(f);
     }
 
     template <typename Integral>
-    constexpr static void wide_integer_from_bultin(integer<Bits, Signed> & self, Integral rhs) noexcept
+    constexpr static void wide_integer_from_builtin(integer<Bits, Signed> & self, Integral rhs) noexcept
     {
-        self.items[0] = _impl::to_Integral(rhs);
-        if constexpr (std::is_same_v<Integral, __int128>)
-            self.items[1] = rhs >> base_bits;
+        static_assert(sizeof(Integral) <= sizeof(base_type));
 
-        constexpr const unsigned start = (sizeof(Integral) == 16) ? 2 : 1;
+        self.items[0] = _impl::to_Integral(rhs);
 
         if constexpr (std::is_signed_v<Integral>)
         {
             if (rhs < 0)
             {
-                for (unsigned i = start; i < item_count; ++i)
+                for (size_t i = 1; i < item_count; ++i)
                     self.items[i] = -1;
                 return;
             }
         }
 
-        for (unsigned i = start; i < item_count; ++i)
+        for (size_t i = 1; i < item_count; ++i)
             self.items[i] = 0;
     }
 
@@ -239,7 +236,8 @@ struct integer<Bits, Signed>::_impl
      * a_(n - 1) = a_n * max_int + b2, a_n <= max_int <- base case.
      */
     template <class T>
-    constexpr static void set_multiplier(integer<Bits, Signed> & self, T t) noexcept {
+    constexpr static void set_multiplier(integer<Bits, Signed> & self, T t) noexcept
+    {
         constexpr uint64_t max_int = std::numeric_limits<uint64_t>::max();
 
         /// Implementation specific behaviour on overflow (if we don't check here, stack overflow will triggered in bigint_cast).
@@ -260,7 +258,8 @@ struct integer<Bits, Signed>::_impl
         self += static_cast<uint64_t>(t - alpha * static_cast<T>(max_int)); // += b_i
     }
 
-    constexpr static void wide_integer_from_bultin(integer<Bits, Signed>& self, double rhs) noexcept {
+    constexpr static void wide_integer_from_builtin(integer<Bits, Signed>& self, double rhs) noexcept
+    {
         constexpr int64_t max_int = std::numeric_limits<int64_t>::max();
         constexpr int64_t min_int = std::numeric_limits<int64_t>::min();
 
@@ -383,13 +382,13 @@ struct integer<Bits, Signed>::_impl
             if (bit_shift)
                 lhs.items[big(items_shift)] |= std::numeric_limits<base_type>::max() << (base_bits - bit_shift);
 
-            for (unsigned i = item_count - items_shift; i < items_shift; ++i)
-                lhs.items[little(i)] = std::numeric_limits<base_type>::max();
+            for (unsigned i = 0; i < items_shift; ++i)
+                lhs.items[big(i)] = std::numeric_limits<base_type>::max();
         }
         else
         {
-            for (unsigned i = item_count - items_shift; i < items_shift; ++i)
-                lhs.items[little(i)] = 0;
+            for (unsigned i = 0; i < items_shift; ++i)
+                lhs.items[big(i)] = 0;
         }
 
         return lhs;
@@ -397,23 +396,23 @@ struct integer<Bits, Signed>::_impl
 
 private:
     template <typename T>
-    constexpr static base_type get_item(const T & x, unsigned number)
+    constexpr static base_type get_item(const T & x, unsigned idx)
     {
         if constexpr (IsWideInteger<T>::value)
         {
-            if (number < T::_impl::item_count)
-                return x.items[number];
+            if (idx < T::_impl::item_count)
+                return x.items[idx];
             return 0;
         }
         else
         {
             if constexpr (sizeof(T) <= sizeof(base_type))
             {
-                if (!number)
+                if (0 == idx)
                     return x;
             }
-            else if (number * sizeof(base_type) < sizeof(T))
-                return x >> (number * base_bits); // & std::numeric_limits<base_type>::max()
+            else if (idx * sizeof(base_type) < sizeof(T))
+                return x >> (idx * base_bits); // & std::numeric_limits<base_type>::max()
             return 0;
         }
     }
@@ -439,7 +438,7 @@ private:
 
         for (unsigned i = 1; i < item_count; ++i)
         {
-            if (underflows[i-1])
+            if (underflows[i - 1])
             {
                 base_type & res_item = res.items[little(i)];
                 if (res_item == 0)
@@ -472,7 +471,7 @@ private:
 
         for (unsigned i = 1; i < item_count; ++i)
         {
-            if (overflows[i-1])
+            if (overflows[i - 1])
             {
                 base_type & res_item = res.items[little(i)];
                 ++res_item;
@@ -532,6 +531,17 @@ private:
             res.items[little(2)] = r12 >> 64;
             return res;
         }
+        else if constexpr (Bits == 128 && sizeof(base_type) == 8)
+        {
+            using CompilerUInt128 = unsigned __int128;
+            CompilerUInt128 a = (CompilerUInt128(lhs.items[1]) << 64) + lhs.items[0];
+            CompilerUInt128 b = (CompilerUInt128(rhs.items[1]) << 64) + rhs.items[0];
+            CompilerUInt128 c = a * b;
+            integer<Bits, Signed> res;
+            res.items[0] = c;
+            res.items[1] = c >> 64;
+            return res;
+        }
         else
         {
             integer<Bits, Signed> res{};
@@ -657,7 +667,7 @@ public:
     }
 
     template <typename T>
-    constexpr static bool operator_more(const integer<Bits, Signed> & lhs, const T & rhs) noexcept
+    constexpr static bool operator_greater(const integer<Bits, Signed> & lhs, const T & rhs) noexcept
     {
         if constexpr (should_keep_size<T>())
         {
@@ -677,7 +687,7 @@ public:
         else
         {
             static_assert(IsWideInteger<T>::value);
-            return std::common_type_t<integer<Bits, Signed>, T>::_impl::operator_more(T(lhs), rhs);
+            return std::common_type_t<integer<Bits, Signed>, T>::_impl::operator_greater(T(lhs), rhs);
         }
     }
 
@@ -764,7 +774,6 @@ public:
         }
     }
 
-private:
     template <typename T>
     constexpr static bool is_zero(const T & x)
     {
@@ -781,46 +790,65 @@ private:
     }
 
     /// returns quotient as result and remainder in numerator.
-    template <typename T>
-    constexpr static T divide(T & numerator, T && denominator)
+    template <size_t Bits2>
+    constexpr static integer<Bits2, unsigned> divide(integer<Bits2, unsigned> & numerator, integer<Bits2, unsigned> denominator)
     {
-        if (is_zero(denominator))
-            throwError("divide by zero");
+        static_assert(std::is_unsigned_v<Signed>);
 
-        T & n = numerator;
-        T & d = denominator;
-        T x = 1;
-        T quotient = 0;
-
-        while (!operator_more(d, n) && operator_eq(operator_amp(shift_right(d, base_bits * item_count - 1), 1), 0))
+        if constexpr (Bits == 128 && sizeof(base_type) == 8)
         {
-            x = shift_left(x, 1);
-            d = shift_left(d, 1);
+            using CompilerUInt128 = unsigned __int128;
+
+            CompilerUInt128 a = (CompilerUInt128(numerator.items[1]) << 64) + numerator.items[0];
+            CompilerUInt128 b = (CompilerUInt128(denominator.items[1]) << 64) + denominator.items[0];
+            CompilerUInt128 c = a / b;
+
+            integer<Bits, Signed> res;
+            res.items[0] = c;
+            res.items[1] = c >> 64;
+
+            CompilerUInt128 remainder = a - b * c;
+            numerator.items[0] = remainder;
+            numerator.items[1] = remainder >> 64;
+
+            return res;
         }
 
-        while (!operator_eq(x, 0))
+        if (is_zero(denominator))
+            throwError("Division by zero");
+
+        integer<Bits2, unsigned> x = 1;
+        integer<Bits2, unsigned> quotient = 0;
+
+        while (!operator_greater(denominator, numerator) && is_zero(operator_amp(shift_right(denominator, Bits2 - 1), 1)))
         {
-            if (!operator_more(d, n))
+            x = shift_left(x, 1);
+            denominator = shift_left(denominator, 1);
+        }
+
+        while (!is_zero(x))
+        {
+            if (!operator_greater(denominator, numerator))
             {
-                n = operator_minus(n, d);
+                numerator = operator_minus(numerator, denominator);
                 quotient = operator_pipe(quotient, x);
             }
 
             x = shift_right(x, 1);
-            d = shift_right(d, 1);
+            denominator = shift_right(denominator, 1);
         }
 
         return quotient;
     }
 
-public:
     template <typename T>
     constexpr static auto operator_slash(const integer<Bits, Signed> & lhs, const T & rhs)
     {
         if constexpr (should_keep_size<T>())
         {
-            integer<Bits, Signed> numerator = make_positive(lhs);
-            integer<Bits, Signed> quotient = divide(numerator, make_positive(integer<Bits, Signed>(rhs)));
+            integer<Bits, unsigned> numerator = make_positive(lhs);
+            integer<Bits, unsigned> denominator = make_positive(integer<Bits, Signed>(rhs));
+            integer<Bits, unsigned> quotient = integer<Bits, unsigned>::_impl::divide(numerator, std::move(denominator));
 
             if (std::is_same_v<Signed, signed> && is_negative(rhs) != is_negative(lhs))
                 quotient = operator_unary_minus(quotient);
@@ -838,8 +866,9 @@ public:
     {
         if constexpr (should_keep_size<T>())
         {
-            integer<Bits, Signed> remainder = make_positive(lhs);
-            divide(remainder, make_positive(integer<Bits, Signed>(rhs)));
+            integer<Bits, unsigned> remainder = make_positive(lhs);
+            integer<Bits, unsigned> denominator = make_positive(integer<Bits, Signed>(rhs));
+            integer<Bits, unsigned>::_impl::divide(remainder, std::move(denominator));
 
             if (std::is_same_v<Signed, signed> && is_negative(lhs))
                 remainder = operator_unary_minus(remainder);
@@ -905,7 +934,7 @@ public:
                     ++c;
                 }
                 else
-                    throwError("invalid char from");
+                    throwError("Invalid char from");
             }
         }
         else
@@ -913,7 +942,7 @@ public:
             while (*c)
             {
                 if (*c < '0' || *c > '9')
-                    throwError("invalid char from");
+                    throwError("Invalid char from");
 
                 res = multiply(res, 10U);
                 res = plus(res, *c - '0');
@@ -930,11 +959,6 @@ public:
 
 // Members
 
-template <size_t Bits, typename Signed>
-constexpr integer<Bits, Signed>::integer() noexcept
-    : items{}
-{}
-
 template <size_t Bits, typename Signed>
 template <typename T>
 constexpr integer<Bits, Signed>::integer(T rhs) noexcept
@@ -943,7 +967,7 @@ constexpr integer<Bits, Signed>::integer(T rhs) noexcept
     if constexpr (IsWideInteger<T>::value)
         _impl::wide_integer_from_wide_integer(*this, rhs);
     else
-        _impl::wide_integer_from_bultin(*this, rhs);
+        _impl::wide_integer_from_builtin(*this, rhs);
 }
 
 template <size_t Bits, typename Signed>
@@ -956,10 +980,19 @@ constexpr integer<Bits, Signed>::integer(std::initializer_list<T> il) noexcept
         if constexpr (IsWideInteger<T>::value)
             _impl::wide_integer_from_wide_integer(*this, *il.begin());
         else
-            _impl::wide_integer_from_bultin(*this, *il.begin());
+            _impl::wide_integer_from_builtin(*this, *il.begin());
+    }
+    else if (il.size() == 0)
+    {
+        _impl::wide_integer_from_builtin(*this, 0);
     }
     else
-        _impl::wide_integer_from_bultin(*this, 0);
+    {
+        auto it = il.begin();
+        for (size_t i = 0; i < _impl::item_count; ++i)
+            if (it < il.end())
+                items[i] = *it;
+    }
 }
 
 template <size_t Bits, typename Signed>
@@ -974,7 +1007,7 @@ template <size_t Bits, typename Signed>
 template <typename T>
 constexpr integer<Bits, Signed> & integer<Bits, Signed>::operator=(T rhs) noexcept
 {
-    _impl::wide_integer_from_bultin(*this, rhs);
+    _impl::wide_integer_from_builtin(*this, rhs);
     return *this;
 }
 
@@ -1057,7 +1090,7 @@ constexpr integer<Bits, Signed> & integer<Bits, Signed>::operator>>=(int n) noex
 {
     if (static_cast<size_t>(n) >= Bits)
     {
-        if (is_negative(*this))
+        if (_impl::is_negative(*this))
             *this = -1;
         else
             *this = 0;
@@ -1107,16 +1140,17 @@ template <size_t Bits, typename Signed>
 template <class T, class>
 constexpr integer<Bits, Signed>::operator T() const noexcept
 {
-    if constexpr (std::is_same_v<T, __int128>)
-    {
-        static_assert(Bits >= 128);
-        return (__int128(items[1]) << 64) | items[0];
-    }
-    else
-    {
-        static_assert(std::numeric_limits<T>::is_integer);
-        return items[0];
-    }
+    static_assert(std::numeric_limits<T>::is_integer);
+
+    /// NOTE: memcpy will suffice, but unfortunately, this function is constexpr.
+
+    using UnsignedT = std::make_unsigned_t<T>;
+
+    UnsignedT res{};
+    for (unsigned i = 0; i < _impl::item_count && i < (sizeof(T) + sizeof(base_type) - 1) / sizeof(base_type); ++i)
+        res += UnsignedT(items[i]) << (sizeof(base_type) * 8 * i);
+
+    return res;
 }
 
 template <size_t Bits, typename Signed>
@@ -1280,7 +1314,7 @@ template <size_t Bits, typename Signed>
 constexpr integer<Bits, Signed> operator<<(const integer<Bits, Signed> & lhs, int n) noexcept
 {
     if (static_cast<size_t>(n) >= Bits)
-        return 0;
+        return integer<Bits, Signed>(0);
     if (n <= 0)
         return lhs;
     return integer<Bits, Signed>::_impl::shift_left(lhs, n);
@@ -1289,7 +1323,7 @@ template <size_t Bits, typename Signed>
 constexpr integer<Bits, Signed> operator>>(const integer<Bits, Signed> & lhs, int n) noexcept
 {
     if (static_cast<size_t>(n) >= Bits)
-        return 0;
+        return integer<Bits, Signed>(0);
     if (n <= 0)
         return lhs;
     return integer<Bits, Signed>::_impl::shift_right(lhs, n);
@@ -1309,7 +1343,7 @@ constexpr bool operator<(const Arithmetic & lhs, const Arithmetic2 & rhs)
 template <size_t Bits, typename Signed, size_t Bits2, typename Signed2>
 constexpr bool operator>(const integer<Bits, Signed> & lhs, const integer<Bits2, Signed2> & rhs)
 {
-    return std::common_type_t<integer<Bits, Signed>, integer<Bits2, Signed2>>::_impl::operator_more(lhs, rhs);
+    return std::common_type_t<integer<Bits, Signed>, integer<Bits2, Signed2>>::_impl::operator_greater(lhs, rhs);
 }
 template <typename Arithmetic, typename Arithmetic2, class>
 constexpr bool operator>(const Arithmetic & lhs, const Arithmetic2 & rhs)
@@ -1332,7 +1366,7 @@ constexpr bool operator<=(const Arithmetic & lhs, const Arithmetic2 & rhs)
 template <size_t Bits, typename Signed, size_t Bits2, typename Signed2>
 constexpr bool operator>=(const integer<Bits, Signed> & lhs, const integer<Bits2, Signed2> & rhs)
 {
-    return std::common_type_t<integer<Bits, Signed>, integer<Bits2, Signed2>>::_impl::operator_more(lhs, rhs)
+    return std::common_type_t<integer<Bits, Signed>, integer<Bits2, Signed2>>::_impl::operator_greater(lhs, rhs)
         || std::common_type_t<integer<Bits, Signed>, integer<Bits2, Signed2>>::_impl::operator_eq(lhs, rhs);
 }
 template <typename Arithmetic, typename Arithmetic2, class>
diff --git a/base/common/wide_integer_to_string.h b/base/common/wide_integer_to_string.h
index 9908ef4be7a..8b794fe9bcb 100644
--- a/base/common/wide_integer_to_string.h
+++ b/base/common/wide_integer_to_string.h
@@ -1,9 +1,12 @@
 #pragma once
 
 #include <string>
+#include <ostream>
+#include <fmt/format.h>
 
 #include "wide_integer.h"
 
+
 namespace wide
 {
 
@@ -33,3 +36,34 @@ inline std::string to_string(const integer<Bits, Signed> & n)
 }
 
 }
+
+
+template <size_t Bits, typename Signed>
+std::ostream & operator<<(std::ostream & out, const wide::integer<Bits, Signed> & value)
+{
+    return out << to_string(value);
+}
+
+
+/// See https://fmt.dev/latest/api.html#formatting-user-defined-types
+template <size_t Bits, typename Signed>
+struct fmt::formatter<wide::integer<Bits, Signed>>
+{
+    constexpr auto parse(format_parse_context & ctx)
+    {
+        auto it = ctx.begin();
+        auto end = ctx.end();
+
+        /// Only support {}.
+        if (it != end && *it != '}')
+            throw format_error("invalid format");
+
+        return it;
+    }
+
+    template <typename FormatContext>
+    auto format(const wide::integer<Bits, Signed> & value, FormatContext & ctx)
+    {
+        return format_to(ctx.out(), "{}", to_string(value));
+    }
+};
diff --git a/base/daemon/SentryWriter.cpp b/base/daemon/SentryWriter.cpp
index 1b7d0064b99..1028dc7d2dc 100644
--- a/base/daemon/SentryWriter.cpp
+++ b/base/daemon/SentryWriter.cpp
@@ -102,7 +102,7 @@ void SentryWriter::initialize(Poco::Util::LayeredConfiguration & config)
     auto * logger = &Poco::Logger::get("SentryWriter");
     if (config.getBool("send_crash_reports.enabled", false))
     {
-        if (debug || (strlen(VERSION_OFFICIAL) > 0))
+        if (debug || (strlen(VERSION_OFFICIAL) > 0)) //-V560
         {
             enabled = true;
         }
diff --git a/base/glibc-compatibility/CMakeLists.txt b/base/glibc-compatibility/CMakeLists.txt
index e785e2ab2ce..8cba91de33f 100644
--- a/base/glibc-compatibility/CMakeLists.txt
+++ b/base/glibc-compatibility/CMakeLists.txt
@@ -15,7 +15,7 @@ if (GLIBC_COMPATIBILITY)
 
     add_headers_and_sources(glibc_compatibility .)
     add_headers_and_sources(glibc_compatibility musl)
-    if (ARCH_ARM)
+    if (ARCH_AARCH64)
         list (APPEND glibc_compatibility_sources musl/aarch64/syscall.s musl/aarch64/longjmp.s)
         set (musl_arch_include_dir musl/aarch64)
     elseif (ARCH_AMD64)
diff --git a/base/glibc-compatibility/musl/lgamma.c b/base/glibc-compatibility/musl/lgamma.c
index fb9d105d0fa..5e959504e29 100644
--- a/base/glibc-compatibility/musl/lgamma.c
+++ b/base/glibc-compatibility/musl/lgamma.c
@@ -78,6 +78,9 @@
  *
  */
 
+// Disable warnings by PVS-Studio
+//-V::GA
+
 static const double
 pi  =  3.14159265358979311600e+00, /* 0x400921FB, 0x54442D18 */
 a0  =  7.72156649015328655494e-02, /* 0x3FB3C467, 0xE37DB0C8 */
diff --git a/base/glibc-compatibility/musl/lgammal.c b/base/glibc-compatibility/musl/lgammal.c
index b158748ce1f..775559f13b6 100644
--- a/base/glibc-compatibility/musl/lgammal.c
+++ b/base/glibc-compatibility/musl/lgammal.c
@@ -85,6 +85,9 @@
  *
  */
 
+// Disable warnings by PVS-Studio
+//-V::GA
+
 #include <stdint.h>
 #include <math.h>
 #include "libm.h"
diff --git a/base/glibc-compatibility/musl/libm.h b/base/glibc-compatibility/musl/libm.h
index 55520c2fb03..e5029318693 100644
--- a/base/glibc-compatibility/musl/libm.h
+++ b/base/glibc-compatibility/musl/libm.h
@@ -155,7 +155,7 @@ static inline long double fp_barrierl(long double x)
 static inline void fp_force_evalf(float x)
 {
 	volatile float y;
-	y = x;
+	y = x; //-V1001
 }
 #endif
 
@@ -164,7 +164,7 @@ static inline void fp_force_evalf(float x)
 static inline void fp_force_eval(double x)
 {
 	volatile double y;
-	y = x;
+	y = x; //-V1001
 }
 #endif
 
@@ -173,7 +173,7 @@ static inline void fp_force_eval(double x)
 static inline void fp_force_evall(long double x)
 {
 	volatile long double y;
-	y = x;
+	y = x; //-V1001
 }
 #endif
 
diff --git a/base/glibc-compatibility/musl/powf.c b/base/glibc-compatibility/musl/powf.c
index de8fab54554..35dc3611b94 100644
--- a/base/glibc-compatibility/musl/powf.c
+++ b/base/glibc-compatibility/musl/powf.c
@@ -3,6 +3,9 @@
  * SPDX-License-Identifier: MIT
  */
 
+// Disable warnings by PVS-Studio
+//-V::GA
+
 #include <math.h>
 #include <stdint.h>
 #include "libm.h"
diff --git a/base/loggers/Loggers.cpp b/base/loggers/Loggers.cpp
index f66b1eb5b91..4a66d43606b 100644
--- a/base/loggers/Loggers.cpp
+++ b/base/loggers/Loggers.cpp
@@ -40,7 +40,7 @@ void Loggers::buildLoggers(Poco::Util::AbstractConfiguration & config, Poco::Log
             split->addTextLog(log, text_log_max_priority);
 
     auto current_logger = config.getString("logger", "");
-    if (config_logger == current_logger)
+    if (config_logger == current_logger) //-V1051
         return;
 
     config_logger = current_logger;
diff --git a/base/pcg-random/pcg_extras.hpp b/base/pcg-random/pcg_extras.hpp
index b71e859a25f..39c91c4ecfa 100644
--- a/base/pcg-random/pcg_extras.hpp
+++ b/base/pcg-random/pcg_extras.hpp
@@ -447,69 +447,6 @@ inline SrcIter uneven_copy(SrcIter src_first,
                             std::integral_constant<bool, DEST_IS_SMALLER>{});
 }
 
-/* generate_to, fill in a fixed-size array of integral type using a SeedSeq
- * (actually works for any random-access iterator)
- */
-
-template <size_t size, typename SeedSeq, typename DestIter>
-inline void generate_to_impl(SeedSeq&& generator, DestIter dest,
-                             std::true_type)
-{
-    generator.generate(dest, dest+size);
-}
-
-template <size_t size, typename SeedSeq, typename DestIter>
-void generate_to_impl(SeedSeq&& generator, DestIter dest,
-                      std::false_type)
-{
-    typedef typename std::iterator_traits<DestIter>::value_type dest_t;
-    constexpr auto DEST_SIZE = sizeof(dest_t);
-    constexpr auto GEN_SIZE  = sizeof(uint32_t);
-
-    constexpr bool GEN_IS_SMALLER = GEN_SIZE < DEST_SIZE;
-    constexpr size_t FROM_ELEMS =
-        GEN_IS_SMALLER
-            ? size * ((DEST_SIZE+GEN_SIZE-1) / GEN_SIZE)
-            : (size + (GEN_SIZE / DEST_SIZE) - 1)
-                / ((GEN_SIZE / DEST_SIZE) + GEN_IS_SMALLER);
-                        //  this odd code ^^^^^^^^^^^^^^^^^ is work-around for
-                        //  a bug: http://llvm.org/bugs/show_bug.cgi?id=21287
-
-    if (FROM_ELEMS <= 1024) {
-        uint32_t buffer[FROM_ELEMS];
-        generator.generate(buffer, buffer+FROM_ELEMS);
-        uneven_copy(buffer, dest, dest+size);
-    } else {
-        uint32_t* buffer = static_cast<uint32_t*>(malloc(GEN_SIZE * FROM_ELEMS));
-        generator.generate(buffer, buffer+FROM_ELEMS);
-        uneven_copy(buffer, dest, dest+size);
-        free(static_cast<void*>(buffer));
-    }
-}
-
-template <size_t size, typename SeedSeq, typename DestIter>
-inline void generate_to(SeedSeq&& generator, DestIter dest)
-{
-    typedef typename std::iterator_traits<DestIter>::value_type dest_t;
-    constexpr bool IS_32BIT = sizeof(dest_t) == sizeof(uint32_t);
-
-    generate_to_impl<size>(std::forward<SeedSeq>(generator), dest,
-                           std::integral_constant<bool, IS_32BIT>{});
-}
-
-/* generate_one, produce a value of integral type using a SeedSeq
- * (optionally, we can have it produce more than one and pick which one
- * we want)
- */
-
-template <typename UInt, size_t i = 0UL, size_t N = i+1UL, typename SeedSeq>
-inline UInt generate_one(SeedSeq&& generator)
-{
-    UInt result[N];
-    generate_to<N>(std::forward<SeedSeq>(generator), result);
-    return result[i];
-}
-
 template <typename RngType>
 auto bounded_rand(RngType& rng, typename RngType::result_type upper_bound)
         -> typename RngType::result_type
@@ -517,7 +454,7 @@ auto bounded_rand(RngType& rng, typename RngType::result_type upper_bound)
     typedef typename RngType::result_type rtype;
     rtype threshold = (RngType::max() - RngType::min() + rtype(1) - upper_bound)
                     % upper_bound;
-    for (;;) {
+    for (;;) { //-V1044
         rtype r = rng() - RngType::min();
         if (r >= threshold)
             return r % upper_bound;
diff --git a/base/pcg-random/pcg_random.hpp b/base/pcg-random/pcg_random.hpp
index b7145e2309c..d9d3519a4cf 100644
--- a/base/pcg-random/pcg_random.hpp
+++ b/base/pcg-random/pcg_random.hpp
@@ -928,7 +928,7 @@ struct rxs_m_xs_mixin {
         constexpr bitcount_t shift = bits - xtypebits;
         constexpr bitcount_t mask = (1 << opbits) - 1;
         bitcount_t rshift =
-            opbits ? bitcount_t(internal >> (bits - opbits)) & mask : 0;
+            opbits ? bitcount_t(internal >> (bits - opbits)) & mask : 0; //-V547
         internal ^= internal >> (opbits + rshift);
         internal *= mcg_multiplier<itype>::multiplier();
         xtype result = internal >> shift;
@@ -950,7 +950,7 @@ struct rxs_m_xs_mixin {
 
         internal *= mcg_unmultiplier<itype>::unmultiplier();
 
-        bitcount_t rshift = opbits ? (internal >> (bits - opbits)) & mask : 0;
+        bitcount_t rshift = opbits ? (internal >> (bits - opbits)) & mask : 0; //-V547
         internal = unxorshift(internal, bits, opbits + rshift);
 
         return internal;
@@ -975,7 +975,7 @@ struct rxs_m_mixin {
                                  :                    2;
         constexpr bitcount_t shift = bits - xtypebits;
         constexpr bitcount_t mask = (1 << opbits) - 1;
-        bitcount_t rshift = opbits ? (internal >> (bits - opbits)) & mask : 0;
+        bitcount_t rshift = opbits ? (internal >> (bits - opbits)) & mask : 0; //-V547
         internal ^= internal >> (opbits + rshift);
         internal *= mcg_multiplier<itype>::multiplier();
         xtype result = internal >> shift;
@@ -1366,7 +1366,7 @@ void extended<table_pow2,advance_pow2,baseclass,extvalclass,kdd>::selfinit()
     //      - any strange correlations would only be apparent if we
     //        were to backstep the generator so that the base generator
     //        was generating the same values again
-    result_type xdiff = baseclass::operator()() - baseclass::operator()();
+    result_type xdiff = baseclass::operator()() - baseclass::operator()(); //-V501
     for (size_t i = 0; i < table_size; ++i) {
         data_[i] = baseclass::operator()() ^ xdiff;
     }
diff --git a/cmake/find/llvm.cmake b/cmake/find/llvm.cmake
index 6ea7a5fd683..e08f45b9932 100644
--- a/cmake/find/llvm.cmake
+++ b/cmake/find/llvm.cmake
@@ -2,7 +2,7 @@ if (APPLE OR SPLIT_SHARED_LIBRARIES OR NOT ARCH_AMD64)
     set (ENABLE_EMBEDDED_COMPILER OFF CACHE INTERNAL "")
 endif()
 
-option (ENABLE_EMBEDDED_COMPILER "Set to TRUE to enable support for 'compile_expressions' option for query execution" ${ENABLE_LIBRARIES})
+option (ENABLE_EMBEDDED_COMPILER "Enable support for 'compile_expressions' option for query execution" ON)
 # Broken in macos. TODO: update clang, re-test, enable on Apple
 if (ENABLE_EMBEDDED_COMPILER AND NOT SPLIT_SHARED_LIBRARIES AND ARCH_AMD64 AND NOT (SANITIZE STREQUAL "undefined"))
     option (USE_INTERNAL_LLVM_LIBRARY "Use bundled or system LLVM library." ${NOT_UNBUNDLED})
diff --git a/contrib/datasketches-cpp b/contrib/datasketches-cpp
index f915d35b2de..7d73d7610db 160000
--- a/contrib/datasketches-cpp
+++ b/contrib/datasketches-cpp
@@ -1 +1 @@
-Subproject commit f915d35b2de676683493c86c585141a1e1c83334
+Subproject commit 7d73d7610db31d4e1ecde0fb3a7ee90ef371207f
diff --git a/docker/test/fasttest/run.sh b/docker/test/fasttest/run.sh
index a7cc398e5c9..42c720a7e63 100755
--- a/docker/test/fasttest/run.sh
+++ b/docker/test/fasttest/run.sh
@@ -308,6 +308,8 @@ function run_tests
         01354_order_by_tuple_collate_const
         01355_ilike
         01411_bayesian_ab_testing
+        01798_uniq_theta_sketch
+        01799_long_uniq_theta_sketch
         collate
         collation
         _orc_
@@ -370,6 +372,10 @@ function run_tests
 
         # Depends on AWS
         01801_s3_cluster
+
+        # Depends on LLVM JIT
+        01852_jit_if
+        01865_jit_comparison_constant_result
     )
 
     (time clickhouse-test --hung-check -j 8 --order=random --use-skip-list --no-long --testname --shard --zookeeper --skip "${TESTS_TO_SKIP[@]}" -- "$FASTTEST_FOCUS" 2>&1 ||:) | ts '%Y-%m-%d %H:%M:%S' | tee "$FASTTEST_OUTPUT/test_log.txt"
diff --git a/docker/test/fuzzer/query-fuzzer-tweaks-users.xml b/docker/test/fuzzer/query-fuzzer-tweaks-users.xml
index 1e82f137961..dd6b7467afc 100644
--- a/docker/test/fuzzer/query-fuzzer-tweaks-users.xml
+++ b/docker/test/fuzzer/query-fuzzer-tweaks-users.xml
@@ -14,11 +14,6 @@
                 <max_memory_usage>
                     <max>10G</max>
                 </max_memory_usage>
-
-                <!-- Not ready for production -->
-                <compile_expressions>
-                    <readonly />
-                </compile_expressions>
             </constraints>
         </default>
     </profiles>
diff --git a/docker/test/testflows/runner/Dockerfile b/docker/test/testflows/runner/Dockerfile
index bd7eee4c166..c5e24b5e37f 100644
--- a/docker/test/testflows/runner/Dockerfile
+++ b/docker/test/testflows/runner/Dockerfile
@@ -35,7 +35,7 @@ RUN apt-get update \
 ENV TZ=Europe/Moscow
 RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
 
-RUN pip3 install urllib3 testflows==1.6.74 docker-compose docker dicttoxml kazoo tzlocal
+RUN pip3 install urllib3 testflows==1.6.74 docker-compose docker dicttoxml kazoo tzlocal python-dateutil numpy
 
 ENV DOCKER_CHANNEL stable
 ENV DOCKER_VERSION 17.09.1-ce
@@ -74,4 +74,3 @@ VOLUME /var/lib/docker
 EXPOSE 2375
 ENTRYPOINT ["dockerd-entrypoint.sh"]
 CMD ["sh", "-c", "python3 regression.py --no-color -o classic --local --clickhouse-binary-path ${CLICKHOUSE_TESTS_SERVER_BIN_PATH} --log test.log ${TESTFLOWS_OPTS}; cat test.log | tfs report results --format json > results.json; /usr/local/bin/process_testflows_result.py || echo -e 'failure\tCannot parse results' > check_status.tsv"]
-
diff --git a/docs/en/engines/table-engines/integrations/s3.md b/docs/en/engines/table-engines/integrations/s3.md
index eb0d92b7738..c07ab337cb0 100644
--- a/docs/en/engines/table-engines/integrations/s3.md
+++ b/docs/en/engines/table-engines/integrations/s3.md
@@ -139,6 +139,7 @@ The following settings can be specified in configuration file for given endpoint
 
 -   `endpoint` — Specifies prefix of an endpoint. Mandatory.
 -   `access_key_id` and `secret_access_key` — Specifies credentials to use with given endpoint. Optional.
+-   `region` — Specifies S3 region name. Optional.
 -   `use_environment_credentials` — If set to `true`, S3 client will try to obtain credentials from environment variables and Amazon EC2 metadata for given endpoint. Optional, default value is `false`.
 -   `use_insecure_imds_request` — If set to `true`, S3 client will use insecure IMDS request while obtaining credentials from Amazon EC2 metadata. Optional, default value is `false`.
 -   `header` —  Adds specified HTTP header to a request to given endpoint. Optional, can be speficied multiple times.
@@ -152,6 +153,7 @@ The following settings can be specified in configuration file for given endpoint
         <endpoint>https://storage.yandexcloud.net/my-test-bucket-768/</endpoint>
         <!-- <access_key_id>ACCESS_KEY_ID</access_key_id> -->
         <!-- <secret_access_key>SECRET_ACCESS_KEY</secret_access_key> -->
+        <!-- <region>us-west-1</region> -->
         <!-- <use_environment_credentials>false</use_environment_credentials> -->
         <!-- <use_insecure_imds_request>false</use_insecure_imds_request> -->
         <!-- <header>Authorization: Bearer SOME-TOKEN</header> -->
diff --git a/docs/en/engines/table-engines/mergetree-family/mergetree.md b/docs/en/engines/table-engines/mergetree-family/mergetree.md
index dfe0ca84723..8743090df41 100644
--- a/docs/en/engines/table-engines/mergetree-family/mergetree.md
+++ b/docs/en/engines/table-engines/mergetree-family/mergetree.md
@@ -739,6 +739,7 @@ Configuration markup:
             <endpoint>https://storage.yandexcloud.net/my-bucket/root-path/</endpoint>
             <access_key_id>your_access_key_id</access_key_id>
             <secret_access_key>your_secret_access_key</secret_access_key>
+            <region></region>
             <server_side_encryption_customer_key_base64>your_base64_encoded_customer_key</server_side_encryption_customer_key_base64>
             <proxy>
                 <uri>http://proxy1</uri>
@@ -764,6 +765,7 @@ Required parameters:
 -   `secret_access_key` — S3 secret access key.
 
 Optional parameters:    
+-   `region` — S3 region name.
 -   `use_environment_credentials` — Reads AWS credentials from the Environment variables AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY and AWS_SESSION_TOKEN if they exist. Default value is `false`.
 -   `use_insecure_imds_request` — If set to `true`, S3 client will use insecure IMDS request while obtaining credentials from Amazon EC2 metadata. Default value is `false`.
 -   `proxy` — Proxy configuration for S3 endpoint. Each `uri` element inside `proxy` block should contain a proxy URL. 
diff --git a/docs/en/operations/system-tables/dictionaries.md b/docs/en/operations/system-tables/dictionaries.md
index 3d3bbe2af4e..2bc1be51f19 100644
--- a/docs/en/operations/system-tables/dictionaries.md
+++ b/docs/en/operations/system-tables/dictionaries.md
@@ -21,6 +21,7 @@ Columns:
 -   `bytes_allocated` ([UInt64](../../sql-reference/data-types/int-uint.md#uint-ranges)) — Amount of RAM allocated for the dictionary.
 -   `query_count` ([UInt64](../../sql-reference/data-types/int-uint.md#uint-ranges)) — Number of queries since the dictionary was loaded or since the last successful reboot.
 -   `hit_rate` ([Float64](../../sql-reference/data-types/float.md)) — For cache dictionaries, the percentage of uses for which the value was in the cache.
+-   `found_rate` ([Float64](../../sql-reference/data-types/float.md)) — The percentage of uses for which the value was found.
 -   `element_count` ([UInt64](../../sql-reference/data-types/int-uint.md#uint-ranges)) — Number of items stored in the dictionary.
 -   `load_factor` ([Float64](../../sql-reference/data-types/float.md)) — Percentage filled in the dictionary (for a hashed dictionary, the percentage filled in the hash table).
 -   `source` ([String](../../sql-reference/data-types/string.md)) — Text describing the [data source](../../sql-reference/dictionaries/external-dictionaries/external-dicts-dict-sources.md) for the dictionary.
@@ -60,4 +61,4 @@ SELECT * FROM system.dictionaries
 └──────────┴──────┴────────┴─────────────┴──────┴────────┴──────────────────────────────────────┴─────────────────────┴─────────────────┴─────────────┴──────────┴───────────────┴───────────────────────┴────────────────────────────┴──────────────┴──────────────┴─────────────────────┴──────────────────────────────┘───────────────────────┴────────────────┘
 ```
 
-[Original article](https://clickhouse.tech/docs/en/operations/system_tables/dictionaries) <!--hide-->
\ No newline at end of file
+[Original article](https://clickhouse.tech/docs/en/operations/system_tables/dictionaries) <!--hide-->
diff --git a/docs/en/sql-reference/aggregate-functions/reference/quantiletdigestweighted.md b/docs/en/sql-reference/aggregate-functions/reference/quantiletdigestweighted.md
index 56ef598f7e7..32d174136e0 100644
--- a/docs/en/sql-reference/aggregate-functions/reference/quantiletdigestweighted.md
+++ b/docs/en/sql-reference/aggregate-functions/reference/quantiletdigestweighted.md
@@ -12,6 +12,9 @@ The result depends on the order of running the query, and is nondeterministic.
 
 When using multiple `quantile*` functions with different levels in a query, the internal states are not combined (that is, the query works less efficiently than it could). In this case, use the [quantiles](../../../sql-reference/aggregate-functions/reference/quantiles.md#quantiles) function.
 
+!!! note "Note"
+    Using `quantileTDigestWeighted` [is not recommended for tiny data sets](https://github.com/tdunning/t-digest/issues/167#issuecomment-828650275) and can lead to significat error. In this case, consider possibility of using [`quantileTDigest`](../../../sql-reference/aggregate-functions/reference/quantiletdigest.md) instead.
+
 **Syntax**
 
 ``` sql
diff --git a/docs/en/sql-reference/aggregate-functions/reference/uniq.md b/docs/en/sql-reference/aggregate-functions/reference/uniq.md
index 7ba2cdc6cb8..f060b85c976 100644
--- a/docs/en/sql-reference/aggregate-functions/reference/uniq.md
+++ b/docs/en/sql-reference/aggregate-functions/reference/uniq.md
@@ -38,3 +38,4 @@ We recommend using this function in almost all scenarios.
 -   [uniqCombined64](../../../sql-reference/aggregate-functions/reference/uniqcombined64.md#agg_function-uniqcombined64)
 -   [uniqHLL12](../../../sql-reference/aggregate-functions/reference/uniqhll12.md#agg_function-uniqhll12)
 -   [uniqExact](../../../sql-reference/aggregate-functions/reference/uniqexact.md#agg_function-uniqexact)
+-   [uniqThetaSketch](../../../sql-reference/aggregate-functions/reference/uniqthetasketch.md#agg_function-uniqthetasketch)
diff --git a/docs/en/sql-reference/aggregate-functions/reference/uniqcombined.md b/docs/en/sql-reference/aggregate-functions/reference/uniqcombined.md
index 4434686ae61..7bd392ef870 100644
--- a/docs/en/sql-reference/aggregate-functions/reference/uniqcombined.md
+++ b/docs/en/sql-reference/aggregate-functions/reference/uniqcombined.md
@@ -49,3 +49,4 @@ Compared to the [uniq](../../../sql-reference/aggregate-functions/reference/uniq
 -   [uniqCombined64](../../../sql-reference/aggregate-functions/reference/uniqcombined64.md#agg_function-uniqcombined64)
 -   [uniqHLL12](../../../sql-reference/aggregate-functions/reference/uniqhll12.md#agg_function-uniqhll12)
 -   [uniqExact](../../../sql-reference/aggregate-functions/reference/uniqexact.md#agg_function-uniqexact)
+-   [uniqThetaSketch](../../../sql-reference/aggregate-functions/reference/uniqthetasketch.md#agg_function-uniqthetasketch)
diff --git a/docs/en/sql-reference/aggregate-functions/reference/uniqexact.md b/docs/en/sql-reference/aggregate-functions/reference/uniqexact.md
index eee675016ee..d758c179d7a 100644
--- a/docs/en/sql-reference/aggregate-functions/reference/uniqexact.md
+++ b/docs/en/sql-reference/aggregate-functions/reference/uniqexact.md
@@ -23,3 +23,4 @@ The function takes a variable number of parameters. Parameters can be `Tuple`, `
 -   [uniq](../../../sql-reference/aggregate-functions/reference/uniq.md#agg_function-uniq)
 -   [uniqCombined](../../../sql-reference/aggregate-functions/reference/uniq.md#agg_function-uniqcombined)
 -   [uniqHLL12](../../../sql-reference/aggregate-functions/reference/uniq.md#agg_function-uniqhll12)
+-   [uniqThetaSketch](../../../sql-reference/aggregate-functions/reference/uniqthetasketch.md#agg_function-uniqthetasketch)
diff --git a/docs/en/sql-reference/aggregate-functions/reference/uniqhll12.md b/docs/en/sql-reference/aggregate-functions/reference/uniqhll12.md
index 4983220ed7f..b65a0151e18 100644
--- a/docs/en/sql-reference/aggregate-functions/reference/uniqhll12.md
+++ b/docs/en/sql-reference/aggregate-functions/reference/uniqhll12.md
@@ -37,3 +37,4 @@ We don’t recommend using this function. In most cases, use the [uniq](../../..
 -   [uniq](../../../sql-reference/aggregate-functions/reference/uniq.md#agg_function-uniq)
 -   [uniqCombined](../../../sql-reference/aggregate-functions/reference/uniqcombined.md#agg_function-uniqcombined)
 -   [uniqExact](../../../sql-reference/aggregate-functions/reference/uniqexact.md#agg_function-uniqexact)
+-   [uniqThetaSketch](../../../sql-reference/aggregate-functions/reference/uniqthetasketch.md#agg_function-uniqthetasketch)
diff --git a/docs/en/sql-reference/aggregate-functions/reference/uniqthetasketch.md b/docs/en/sql-reference/aggregate-functions/reference/uniqthetasketch.md
new file mode 100644
index 00000000000..dd744a34190
--- /dev/null
+++ b/docs/en/sql-reference/aggregate-functions/reference/uniqthetasketch.md
@@ -0,0 +1,39 @@
+---
+toc_priority: 195
+---
+
+# uniqThetaSketch {#agg_function-uniqthetasketch}
+
+Calculates the approximate number of different argument values, using the [Theta Sketch Framework](https://datasketches.apache.org/docs/Theta/ThetaSketchFramework.html).
+
+``` sql
+uniqThetaSketch(x[, ...])
+```
+
+**Arguments**
+
+The function takes a variable number of parameters. Parameters can be `Tuple`, `Array`, `Date`, `DateTime`, `String`, or numeric types.
+
+**Returned value**
+
+-   A [UInt64](../../../sql-reference/data-types/int-uint.md)-type number.
+
+**Implementation details**
+
+Function:
+
+-   Calculates a hash for all parameters in the aggregate, then uses it in calculations.
+
+-   Uses the [KMV](https://datasketches.apache.org/docs/Theta/InverseEstimate.html) algorithm to approximate the number of different argument values.
+
+        4096(2^12) 64-bit sketch are used. The size of the state is about 41 KB.
+
+-   The relative error is 3.125% (95% confidence), see the [relative error table](https://datasketches.apache.org/docs/Theta/ThetaErrorTable.html) for detail.
+
+**See Also**
+
+-   [uniq](../../../sql-reference/aggregate-functions/reference/uniq.md#agg_function-uniq)
+-   [uniqCombined](../../../sql-reference/aggregate-functions/reference/uniqcombined.md#agg_function-uniqcombined)
+-   [uniqCombined64](../../../sql-reference/aggregate-functions/reference/uniqcombined64.md#agg_function-uniqcombined64)
+-   [uniqHLL12](../../../sql-reference/aggregate-functions/reference/uniqhll12.md#agg_function-uniqhll12)
+-   [uniqExact](../../../sql-reference/aggregate-functions/reference/uniqexact.md#agg_function-uniqexact)
diff --git a/docs/en/sql-reference/statements/explain.md b/docs/en/sql-reference/statements/explain.md
index 8083fa160fa..1c19adcdcd8 100644
--- a/docs/en/sql-reference/statements/explain.md
+++ b/docs/en/sql-reference/statements/explain.md
@@ -47,9 +47,9 @@ Union
 
 ### EXPLAIN AST {#explain-ast}
 
-Dump query AST.
+Dump query AST. Supports all types of queries, not only `SELECT`.
 
-Example:
+Examples:
 
 ```sql
 EXPLAIN AST SELECT 1;
@@ -63,6 +63,22 @@ SelectWithUnionQuery (children 1)
     Literal UInt64_1
 ```
 
+```sql
+EXPLAIN AST ALTER TABLE t1 DELETE WHERE date = today();
+```
+
+```sql
+  explain
+  AlterQuery  t1 (children 1)
+   ExpressionList (children 1)
+    AlterCommand 27 (children 1)
+     Function equals (children 1)
+      ExpressionList (children 2)
+       Identifier date
+       Function today (children 1)
+        ExpressionList
+```
+
 ### EXPLAIN SYNTAX {#explain-syntax}
 
 Returns query after syntax optimizations.
diff --git a/docs/ru/engines/table-engines/integrations/s3.md b/docs/ru/engines/table-engines/integrations/s3.md
index bee1fc1318a..9a5a985c76b 100644
--- a/docs/ru/engines/table-engines/integrations/s3.md
+++ b/docs/ru/engines/table-engines/integrations/s3.md
@@ -82,6 +82,7 @@ SELECT * FROM s3_engine_table LIMIT 2;
 
 Необязательные настройки:
 -   `access_key_id` и `secret_access_key` — указывают учетные данные для использования с данной точкой приема запроса.
+-   `region` — название региона S3.
 -   `use_environment_credentials` — если `true`, S3-клиент будет пытаться получить учетные данные из переменных среды и метаданных Amazon EC2 для данной точки приема запроса. Значение по умолчанию - `false`.
 -   `header` — добавляет указанный HTTP-заголовок к запросу на заданную точку приема запроса. Может быть определен несколько раз.
 -   `server_side_encryption_customer_key_base64` — устанавливает необходимые заголовки для доступа к объектам S3 с шифрованием SSE-C. 
@@ -94,6 +95,7 @@ SELECT * FROM s3_engine_table LIMIT 2;
         <endpoint>https://storage.yandexcloud.net/my-test-bucket-768/</endpoint>
         <!-- <access_key_id>ACCESS_KEY_ID</access_key_id> -->
         <!-- <secret_access_key>SECRET_ACCESS_KEY</secret_access_key> -->
+        <!-- <region>us-west-1</region> -->
         <!-- <use_environment_credentials>false</use_environment_credentials> -->
         <!-- <header>Authorization: Bearer SOME-TOKEN</header> -->
         <!-- <server_side_encryption_customer_key_base64>BASE64-ENCODED-KEY</server_side_encryption_customer_key_base64> -->
diff --git a/docs/ru/engines/table-engines/mergetree-family/mergetree.md b/docs/ru/engines/table-engines/mergetree-family/mergetree.md
index b8bd259167a..4cff6fcfb80 100644
--- a/docs/ru/engines/table-engines/mergetree-family/mergetree.md
+++ b/docs/ru/engines/table-engines/mergetree-family/mergetree.md
@@ -727,6 +727,7 @@ SETTINGS storage_policy = 'moving_from_ssd_to_hdd'
             <endpoint>https://storage.yandexcloud.net/my-bucket/root-path/</endpoint>
             <access_key_id>your_access_key_id</access_key_id>
             <secret_access_key>your_secret_access_key</secret_access_key>
+            <region></region>
             <proxy>
                 <uri>http://proxy1</uri>
                 <uri>http://proxy2</uri>
@@ -753,6 +754,7 @@ SETTINGS storage_policy = 'moving_from_ssd_to_hdd'
 
 Необязательные параметры:   
 
+-   `region` — название региона S3.
 -   `use_environment_credentials` — признак, нужно ли считывать учетные данные AWS из сетевого окружения, а также из переменных окружения `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY` и `AWS_SESSION_TOKEN`, если они есть. Значение по умолчанию: `false`.
 -   `use_insecure_imds_request` — признак, нужно ли использовать менее безопасное соединение при выполнении запроса к IMDS при получении учётных данных из метаданных Amazon EC2. Значение по умолчанию: `false`.
 -   `proxy` — конфигурация прокси-сервера для конечной точки S3. Каждый элемент `uri` внутри блока `proxy` должен содержать URL прокси-сервера. 
diff --git a/docs/ru/operations/tips.md b/docs/ru/operations/tips.md
deleted file mode 100644
index 4535767e8e0..00000000000
--- a/docs/ru/operations/tips.md
+++ /dev/null
@@ -1,248 +0,0 @@
----
-toc_priority: 58
-toc_title: "Советы по эксплуатации"
----
-
-# Советы по эксплуатации {#sovety-po-ekspluatatsii}
-
-## CPU Scaling Governor {#cpu-scaling-governor}
-
-Всегда используйте `performance` scaling governor. `ondemand` scaling governor работает намного хуже при постоянно высоком спросе.
-
-``` bash
-$ echo 'performance' | sudo tee /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor
-```
-
-## Ограничение CPU {#ogranichenie-cpu}
-
-Процессоры могут перегреваться. С помощью `dmesg` можно увидеть, если тактовая частота процессора была ограничена из-за перегрева.
-Также ограничение может устанавливаться снаружи на уровне дата-центра. С помощью `turbostat` можно за этим наблюдать под нагрузкой.
-
-## Оперативная память {#operativnaia-pamiat}
-
-Для небольших объёмов данных (до ~200 Гб в сжатом виде) лучше всего использовать столько памяти не меньше, чем объём данных.
-Для больших объёмов данных, при выполнении интерактивных (онлайн) запросов, стоит использовать разумный объём оперативной памяти (128 Гб или более) для того, чтобы горячее подмножество данных поместилось в кеше страниц.
-Даже для объёмов данных в ~50 Тб на сервер, использование 128 Гб оперативной памяти намного лучше для производительности выполнения запросов, чем 64 Гб.
-
-Не выключайте overcommit. Значение `cat /proc/sys/vm/overcommit_memory` должно быть 0 or 1. Выполните:
-
-``` bash
-$ echo 0 | sudo tee /proc/sys/vm/overcommit_memory
-```
-
-## Huge Pages {#huge-pages}
-
-Механизм прозрачных huge pages нужно отключить. Он мешает работе аллокаторов памяти, что приводит к значительной деградации производительности.
-
-``` bash
-$ echo 'madvise' | sudo tee /sys/kernel/mm/transparent_hugepage/enabled
-```
-
-С помощью `perf top` можно наблюдать за временем, проведенном в ядре операционной системы для управления памятью.
-Постоянные huge pages так же не нужно аллоцировать.
-
-## Подсистема хранения {#podsistema-khraneniia}
-
-Если ваш бюджет позволяет использовать SSD, используйте SSD.
-В противном случае используйте HDD. SATA HDDs 7200 RPM подойдут.
-
-Предпочитайте много серверов с локальными жесткими дисками вместо меньшего числа серверов с подключенными дисковыми полками.
-Но для хранения архивов с редкими запросами полки всё же подходят.
-
-## RAID {#raid}
-
-При использовании HDD можно объединить их RAID-10, RAID-5, RAID-6 или RAID-50.
-Лучше использовать программный RAID в Linux (`mdadm`). Лучше не использовать LVM.
-При создании RAID-10, нужно выбрать `far` расположение.
-Если бюджет позволяет, лучше выбрать RAID-10.
-
-На более чем 4 дисках вместо RAID-5 нужно использовать RAID-6 (предпочтительнее) или RAID-50.
-При использовании RAID-5, RAID-6 или RAID-50, нужно всегда увеличивать stripe_cache_size, так как значение по умолчанию выбрано не самым удачным образом.
-
-``` bash
-$ echo 4096 | sudo tee /sys/block/md2/md/stripe_cache_size
-```
-
-Точное число стоит вычислять из числа устройств и размер блока по формуле: `2 * num_devices * chunk_size_in_bytes / 4096`.
-
-Размер блока в 1024 Кб подходит для всех конфигураций RAID.
-Никогда не указывайте слишком маленький или слишком большой размер блока.
-
-На SSD можно использовать RAID-0.
-Вне зависимости от использования RAID, всегда используйте репликацию для безопасности данных.
-
-Включите NCQ с длинной очередью. Для HDD стоит выбрать планировщик CFQ, а для SSD — noop. Не стоит уменьшать настройку readahead.
-На HDD стоит включать кеш записи.
-
-## Файловая система {#failovaia-sistema}
-
-Ext4 самый проверенный вариант. Укажите опции монтирования `noatime,nobarrier`.
-XFS также подходит, но не так тщательно протестирована в сочетании с ClickHouse.
-Большинство других файловых систем также должны нормально работать. Файловые системы с отложенной аллокацией работают лучше.
-
-## Ядро Linux {#iadro-linux}
-
-Не используйте слишком старое ядро Linux.
-
-## Сеть {#set}
-
-При использовании IPv6, стоит увеличить размер кеша маршрутов.
-Ядра Linux до 3.2 имели массу проблем в реализации IPv6.
-
-Предпочитайте как минимум 10 Гбит сеть. 1 Гбит также будет работать, но намного хуже для починки реплик с десятками терабайт данных или для обработки распределенных запросов с большим объёмом промежуточных данных.
-
-## ZooKeeper {#zookeeper}
-
-Вероятно вы уже используете ZooKeeper для других целей. Можно использовать ту же инсталляцию ZooKeeper, если она не сильно перегружена.
-
-Лучше использовать свежую версию ZooKeeper, как минимум 3.4.9. Версия в стабильных дистрибутивах Linux может быть устаревшей.
-
-Никогда не используете написанные вручную скрипты для переноса данных между разными ZooKeeper кластерами, потому что результат будет некорректный для sequential нод. Никогда не используйте утилиту «zkcopy», по той же причине: https://github.com/ksprojects/zkcopy/issues/15
-
-Если вы хотите разделить существующий ZooKeeper кластер на два, правильный способ - увеличить количество его реплик, а затем переконфигурировать его как два независимых кластера.
-
-Не запускайте ZooKeeper на тех же серверах, что и ClickHouse. Потому что ZooKeeper очень чувствителен к задержкам, а ClickHouse может использовать все доступные системные ресурсы.
-
-С настройками по умолчанию, ZooKeeper является бомбой замедленного действия:
-
-> Сервер ZooKeeper не будет удалять файлы со старыми снепшоты и логами при использовании конфигурации по умолчанию (см. autopurge), это является ответственностью оператора.
-
-Эту бомбу нужно обезвредить.
-
-Далее описана конфигурация ZooKeeper (3.5.1), используемая в боевом окружении Яндекс.Метрики на момент 20 мая 2017 года:
-
-zoo.cfg:
-
-``` bash
-# http://hadoop.apache.org/zookeeper/docs/current/zookeeperAdmin.html
-
-# The number of milliseconds of each tick
-tickTime=2000
-# The number of ticks that the initial
-# synchronization phase can take
-initLimit=30000
-# The number of ticks that can pass between
-# sending a request and getting an acknowledgement
-syncLimit=10
-
-maxClientCnxns=2000
-
-maxSessionTimeout=60000000
-# the directory where the snapshot is stored.
-dataDir=/opt/zookeeper/{{ '{{' }} cluster['name'] {{ '{{' }} '}}' }}/data
-# Place the dataLogDir to a separate physical disc for better performance
-dataLogDir=/opt/zookeeper/{{ '{{' }} cluster['name'] {{ '{{' }} '}}' }}/logs
-
-autopurge.snapRetainCount=10
-autopurge.purgeInterval=1
-
-
-# To avoid seeks ZooKeeper allocates space in the transaction log file in
-# blocks of preAllocSize kilobytes. The default block size is 64M. One reason
-# for changing the size of the blocks is to reduce the block size if snapshots
-# are taken more often. (Also, see snapCount).
-preAllocSize=131072
-
-# Clients can submit requests faster than ZooKeeper can process them,
-# especially if there are a lot of clients. To prevent ZooKeeper from running
-# out of memory due to queued requests, ZooKeeper will throttle clients so that
-# there is no more than globalOutstandingLimit outstanding requests in the
-# system. The default limit is 1,000.ZooKeeper logs transactions to a
-# transaction log. After snapCount transactions are written to a log file a
-# snapshot is started and a new transaction log file is started. The default
-# snapCount is 10,000.
-snapCount=3000000
-
-# If this option is defined, requests will be will logged to a trace file named
-# traceFile.year.month.day.
-#traceFile=
-
-# Leader accepts client connections. Default value is "yes". The leader machine
-# coordinates updates. For higher update throughput at thes slight expense of
-# read throughput the leader can be configured to not accept clients and focus
-# on coordination.
-leaderServes=yes
-
-standaloneEnabled=false
-dynamicConfigFile=/etc/zookeeper-{{ '{{' }} cluster['name'] {{ '{{' }} '}}' }}/conf/zoo.cfg.dynamic
-```
-
-Версия Java:
-
-``` text
-Java(TM) SE Runtime Environment (build 1.8.0_25-b17)
-Java HotSpot(TM) 64-Bit Server VM (build 25.25-b02, mixed mode)
-```
-
-Параметры JVM:
-
-``` bash
-NAME=zookeeper-{{ '{{' }} cluster['name'] {{ '{{' }} '}}' }}
-ZOOCFGDIR=/etc/$NAME/conf
-
-# TODO this is really ugly
-# How to find out, which jars are needed?
-# seems, that log4j requires the log4j.properties file to be in the classpath
-CLASSPATH="$ZOOCFGDIR:/usr/build/classes:/usr/build/lib/*.jar:/usr/share/zookeeper/zookeeper-3.5.1-metrika.jar:/usr/share/zookeeper/slf4j-log4j12-1.7.5.jar:/usr/share/zookeeper/slf4j-api-1.7.5.jar:/usr/share/zookeeper/servlet-api-2.5-20081211.jar:/usr/share/zookeeper/netty-3.7.0.Final.jar:/usr/share/zookeeper/log4j-1.2.16.jar:/usr/share/zookeeper/jline-2.11.jar:/usr/share/zookeeper/jetty-util-6.1.26.jar:/usr/share/zookeeper/jetty-6.1.26.jar:/usr/share/zookeeper/javacc.jar:/usr/share/zookeeper/jackson-mapper-asl-1.9.11.jar:/usr/share/zookeeper/jackson-core-asl-1.9.11.jar:/usr/share/zookeeper/commons-cli-1.2.jar:/usr/src/java/lib/*.jar:/usr/etc/zookeeper"
-
-ZOOCFG="$ZOOCFGDIR/zoo.cfg"
-ZOO_LOG_DIR=/var/log/$NAME
-USER=zookeeper
-GROUP=zookeeper
-PIDDIR=/var/run/$NAME
-PIDFILE=$PIDDIR/$NAME.pid
-SCRIPTNAME=/etc/init.d/$NAME
-JAVA=/usr/bin/java
-ZOOMAIN="org.apache.zookeeper.server.quorum.QuorumPeerMain"
-ZOO_LOG4J_PROP="INFO,ROLLINGFILE"
-JMXLOCALONLY=false
-JAVA_OPTS="-Xms{{ '{{' }} cluster.get('xms','128M') {{ '{{' }} '}}' }} \
-    -Xmx{{ '{{' }} cluster.get('xmx','1G') {{ '{{' }} '}}' }} \
-    -Xloggc:/var/log/$NAME/zookeeper-gc.log \
-    -XX:+UseGCLogFileRotation \
-    -XX:NumberOfGCLogFiles=16 \
-    -XX:GCLogFileSize=16M \
-    -verbose:gc \
-    -XX:+PrintGCTimeStamps \
-    -XX:+PrintGCDateStamps \
-    -XX:+PrintGCDetails
-    -XX:+PrintTenuringDistribution \
-    -XX:+PrintGCApplicationStoppedTime \
-    -XX:+PrintGCApplicationConcurrentTime \
-    -XX:+PrintSafepointStatistics \
-    -XX:+UseParNewGC \
-    -XX:+UseConcMarkSweepGC \
--XX:+CMSParallelRemarkEnabled"
-```
-
-Salt init:
-
-``` text
-description "zookeeper-{{ '{{' }} cluster['name'] {{ '{{' }} '}}' }} centralized coordination service"
-
-start on runlevel [2345]
-stop on runlevel [!2345]
-
-respawn
-
-limit nofile 8192 8192
-
-pre-start script
-    [ -r "/etc/zookeeper-{{ '{{' }} cluster['name'] {{ '{{' }} '}}' }}/conf/environment" ] || exit 0
-    . /etc/zookeeper-{{ '{{' }} cluster['name'] {{ '{{' }} '}}' }}/conf/environment
-    [ -d $ZOO_LOG_DIR ] || mkdir -p $ZOO_LOG_DIR
-    chown $USER:$GROUP $ZOO_LOG_DIR
-end script
-
-script
-    . /etc/zookeeper-{{ '{{' }} cluster['name'] {{ '{{' }} '}}' }}/conf/environment
-    [ -r /etc/default/zookeeper ] && . /etc/default/zookeeper
-    if [ -z "$JMXDISABLE" ]; then
-        JAVA_OPTS="$JAVA_OPTS -Dcom.sun.management.jmxremote -Dcom.sun.management.jmxremote.local.only=$JMXLOCALONLY"
-    fi
-    exec start-stop-daemon --start -c $USER --exec $JAVA --name zookeeper-{{ '{{' }} cluster['name'] {{ '{{' }} '}}' }} \
-        -- -cp $CLASSPATH $JAVA_OPTS -Dzookeeper.log.dir=${ZOO_LOG_DIR} \
-        -Dzookeeper.root.logger=${ZOO_LOG4J_PROP} $ZOOMAIN $ZOOCFG
-end script
-```
-
diff --git a/docs/ru/operations/tips.md b/docs/ru/operations/tips.md
new file mode 120000
index 00000000000..9b3413bdbc3
--- /dev/null
+++ b/docs/ru/operations/tips.md
@@ -0,0 +1 @@
+../../en/operations/tips.md
\ No newline at end of file
diff --git a/docs/ru/sql-reference/aggregate-functions/reference/quantiletdigestweighted.md b/docs/ru/sql-reference/aggregate-functions/reference/quantiletdigestweighted.md
index f7239be0ba5..6dce79d8a89 100644
--- a/docs/ru/sql-reference/aggregate-functions/reference/quantiletdigestweighted.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/quantiletdigestweighted.md
@@ -12,6 +12,9 @@ toc_priority: 208
 
 Внутренние состояния функций `quantile*` не объединяются, если они используются в одном запросе. Если вам необходимо вычислить квантили нескольких уровней, используйте функцию [quantiles](#quantiles), это повысит эффективность запроса.
 
+!!! note "Примечание"
+    Использование `quantileTDigestWeighted` [не рекомендуется для небольших наборов данных](https://github.com/tdunning/t-digest/issues/167#issuecomment-828650275) и может привести к значительной ошибке. Рассмотрите возможность использования [`quantileTDigest`](../../../sql-reference/aggregate-functions/reference/quantiletdigest.md) в таких случаях.
+
 **Синтаксис**
 
 ``` sql
diff --git a/docs/ru/sql-reference/statements/explain.md b/docs/ru/sql-reference/statements/explain.md
index ef2a670a87e..c2a35f1b925 100644
--- a/docs/ru/sql-reference/statements/explain.md
+++ b/docs/ru/sql-reference/statements/explain.md
@@ -47,9 +47,9 @@ Union
 
 ### EXPLAIN AST {#explain-ast}
 
-Дамп AST запроса.
+Дамп AST запроса. Поддерживает все типы запросов, не только `SELECT`.
 
-Пример:
+Примеры:
 
 ```sql
 EXPLAIN AST SELECT 1;
@@ -63,6 +63,22 @@ SelectWithUnionQuery (children 1)
     Literal UInt64_1
 ```
 
+```sql
+EXPLAIN AST ALTER TABLE t1 DELETE WHERE date = today();
+```
+
+```sql
+  explain
+  AlterQuery  t1 (children 1)
+   ExpressionList (children 1)
+    AlterCommand 27 (children 1)
+     Function equals (children 1)
+      ExpressionList (children 2)
+       Identifier date
+       Function today (children 1)
+        ExpressionList
+```
+
 ### EXPLAIN SYNTAX {#explain-syntax}
 
 Возвращает текст запроса после применения синтаксических оптимизаций.
diff --git a/programs/client/Client.cpp b/programs/client/Client.cpp
index 3917d775cbc..fbcdd0b8e9b 100644
--- a/programs/client/Client.cpp
+++ b/programs/client/Client.cpp
@@ -1461,18 +1461,25 @@ private:
             // when `lambda()` function gets substituted into a wrong place.
             // To avoid dealing with these cases, run the check only for the
             // queries we were able to successfully execute.
-            // The final caveat is that sometimes WITH queries are not executed,
+            // Another caveat is that sometimes WITH queries are not executed,
             // if they are not referenced by the main SELECT, so they can still
             // have the aforementioned problems. Disable this check for such
             // queries, for lack of a better solution.
-            if (!have_error && queryHasWithClause(parsed_query.get()))
+            // There is also a problem that fuzzer substitutes positive Int64
+            // literals or Decimal literals, which are then parsed back as
+            // UInt64, and suddenly duplicate alias substitition starts or stops
+            // working (ASTWithAlias::formatImpl) or something like that.
+            // So we compare not even the first and second formatting of the
+            // query, but second and third.
+            // If you have to add any more workarounds to this check, just remove
+            // it altogether, it's not so useful.
+            if (!have_error && !queryHasWithClause(parsed_query.get()))
             {
-                ASTPtr parsed_formatted_query;
+                ASTPtr ast_2;
                 try
                 {
                     const auto * tmp_pos = query_to_send.c_str();
-                    parsed_formatted_query = parseQuery(tmp_pos,
-                        tmp_pos + query_to_send.size(),
+                    ast_2 = parseQuery(tmp_pos, tmp_pos + query_to_send.size(),
                         false /* allow_multi_statements */);
                 }
                 catch (Exception & e)
@@ -1483,25 +1490,31 @@ private:
                     }
                 }
 
-                if (parsed_formatted_query)
+                if (ast_2)
                 {
-                    const auto formatted_twice
-                        = parsed_formatted_query->formatForErrorMessage();
+                    const auto text_2 = ast_2->formatForErrorMessage();
+                    const auto * tmp_pos = text_2.c_str();
+                    const auto ast_3 = parseQuery(tmp_pos, tmp_pos + text_2.size(),
+                        false /* allow_multi_statements */);
+                    const auto text_3 = ast_3->formatForErrorMessage();
 
-                    if (formatted_twice != query_to_send)
+                    if (text_3 != text_2)
                     {
                         fmt::print(stderr, "The query formatting is broken.\n");
 
                         printChangedSettings();
 
-                        fmt::print(stderr, "Got the following (different) text after formatting the fuzzed query and parsing it back:\n'{}'\n, expected:\n'{}'\n",
-                            formatted_twice, query_to_send);
+                        fmt::print(stderr,
+                            "Got the following (different) text after formatting the fuzzed query and parsing it back:\n'{}'\n, expected:\n'{}'\n",
+                            text_3, text_2);
                         fmt::print(stderr, "In more detail:\n");
-                        fmt::print(stderr, "AST-1:\n'{}'\n", parsed_query->dumpTree());
+                        fmt::print(stderr, "AST-1 (generated by fuzzer):\n'{}'\n", parsed_query->dumpTree());
                         fmt::print(stderr, "Text-1 (AST-1 formatted):\n'{}'\n", query_to_send);
-                        fmt::print(stderr, "AST-2 (Text-1 parsed):\n'{}'\n", parsed_formatted_query->dumpTree());
-                        fmt::print(stderr, "Text-2 (AST-2 formatted):\n'{}'\n", formatted_twice);
-                        fmt::print(stderr, "Text-1 must be equal to Text-2, but it is not.\n");
+                        fmt::print(stderr, "AST-2 (Text-1 parsed):\n'{}'\n", ast_2->dumpTree());
+                        fmt::print(stderr, "Text-2 (AST-2 formatted):\n'{}'\n", text_2);
+                        fmt::print(stderr, "AST-3 (Text-2 parsed):\n'{}'\n", ast_3->dumpTree());
+                        fmt::print(stderr, "Text-3 (AST-3 formatted):\n'{}'\n", text_3);
+                        fmt::print(stderr, "Text-3 must be equal to Text-2, but it is not.\n");
 
                         exit(1);
                     }
@@ -1518,6 +1531,11 @@ private:
                 server_exception.reset();
                 client_exception.reset();
                 have_error = false;
+
+                // We have to reinitialize connection after errors, because it
+                // might have gotten into a wrong state and we'll get false
+                // positives about "Unknown packet from server".
+                connection->forceConnected(connection_parameters.timeouts);
             }
             else if (ast_to_process->formatForErrorMessage().size() > 500)
             {
diff --git a/programs/client/QueryFuzzer.h b/programs/client/QueryFuzzer.h
index 9ef66db1873..7c79e683eb4 100644
--- a/programs/client/QueryFuzzer.h
+++ b/programs/client/QueryFuzzer.h
@@ -4,11 +4,14 @@
 #include <unordered_map>
 #include <vector>
 
+#include <pcg-random/pcg_random.hpp>
+
 #include <Common/randomSeed.h>
 #include <Common/Stopwatch.h>
 #include <Core/Field.h>
 #include <Parsers/IAST.h>
 
+
 namespace DB
 {
 
diff --git a/programs/git-import/git-import.cpp b/programs/git-import/git-import.cpp
index b07435dcf78..7977cfba79d 100644
--- a/programs/git-import/git-import.cpp
+++ b/programs/git-import/git-import.cpp
@@ -774,7 +774,7 @@ UInt128 diffHash(const CommitDiff & file_changes)
     }
 
     UInt128 hash_of_diff;
-    hasher.get128(hash_of_diff.low, hash_of_diff.high);
+    hasher.get128(hash_of_diff.items[0], hash_of_diff.items[1]);
 
     return hash_of_diff;
 }
diff --git a/programs/library-bridge/SharedLibraryHandler.h b/programs/library-bridge/SharedLibraryHandler.h
index 5c0334ac89f..fa476995e32 100644
--- a/programs/library-bridge/SharedLibraryHandler.h
+++ b/programs/library-bridge/SharedLibraryHandler.h
@@ -23,6 +23,8 @@ public:
 
     SharedLibraryHandler(const SharedLibraryHandler & other);
 
+    SharedLibraryHandler & operator=(const SharedLibraryHandler & other) = delete;
+
     ~SharedLibraryHandler();
 
     BlockInputStreamPtr loadAll();
diff --git a/programs/obfuscator/Obfuscator.cpp b/programs/obfuscator/Obfuscator.cpp
index c92eb5c6647..fb6817fbf80 100644
--- a/programs/obfuscator/Obfuscator.cpp
+++ b/programs/obfuscator/Obfuscator.cpp
@@ -365,16 +365,20 @@ static void transformFixedString(const UInt8 * src, UInt8 * dst, size_t size, UI
     }
 }
 
-static void transformUUID(const UInt128 & src, UInt128 & dst, UInt64 seed)
+static void transformUUID(const UUID & src_uuid, UUID & dst_uuid, UInt64 seed)
 {
+    const UInt128 & src = src_uuid.toUnderType();
+    UInt128 & dst = dst_uuid.toUnderType();
+
     SipHash hash;
     hash.update(seed);
-    hash.update(reinterpret_cast<const char *>(&src), sizeof(UInt128));
+    hash.update(reinterpret_cast<const char *>(&src), sizeof(UUID));
 
     /// Saving version and variant from an old UUID
     hash.get128(reinterpret_cast<char *>(&dst));
-    dst.high = (dst.high & 0x1fffffffffffffffull) | (src.high & 0xe000000000000000ull);
-    dst.low = (dst.low & 0xffffffffffff0fffull) | (src.low & 0x000000000000f000ull);
+
+    dst.items[1] = (dst.items[1] & 0x1fffffffffffffffull) | (src.items[1] & 0xe000000000000000ull);
+    dst.items[0] = (dst.items[0] & 0xffffffffffff0fffull) | (src.items[0] & 0x000000000000f000ull);
 }
 
 class FixedStringModel : public IModel
@@ -426,10 +430,10 @@ public:
 
     ColumnPtr generate(const IColumn & column) override
     {
-        const ColumnUInt128 & src_column = assert_cast<const ColumnUInt128 &>(column);
+        const ColumnUUID & src_column = assert_cast<const ColumnUUID &>(column);
         const auto & src_data = src_column.getData();
 
-        auto res_column = ColumnUInt128::create();
+        auto res_column = ColumnUUID::create();
         auto & res_data = res_column->getData();
 
         res_data.resize(src_data.size());
diff --git a/programs/odbc-bridge/ODBCBlockOutputStream.cpp b/programs/odbc-bridge/ODBCBlockOutputStream.cpp
index bdbe8add37e..dc965b3b2a7 100644
--- a/programs/odbc-bridge/ODBCBlockOutputStream.cpp
+++ b/programs/odbc-bridge/ODBCBlockOutputStream.cpp
@@ -1,5 +1,6 @@
 #include "ODBCBlockOutputStream.h"
 
+#include <Common/hex.h>
 #include <common/logger_useful.h>
 #include <Core/Field.h>
 #include <common/LocalDate.h>
@@ -37,7 +38,6 @@ namespace
         query.IAST::format(settings);
         return buf.str();
     }
-
 }
 
 ODBCBlockOutputStream::ODBCBlockOutputStream(nanodbc::ConnectionHolderPtr connection_,
diff --git a/programs/server/Server.cpp b/programs/server/Server.cpp
index 729dc150e07..82392b3fee0 100644
--- a/programs/server/Server.cpp
+++ b/programs/server/Server.cpp
@@ -13,6 +13,7 @@
 #include <Poco/Net/HTTPServer.h>
 #include <Poco/Net/NetException.h>
 #include <Poco/Util/HelpFormatter.h>
+#include <Poco/Environment.h>
 #include <ext/scope_guard.h>
 #include <common/defines.h>
 #include <common/logger_useful.h>
@@ -385,6 +386,11 @@ void Server::initialize(Poco::Util::Application & self)
 {
     BaseDaemon::initialize(self);
     logger().information("starting up");
+
+    LOG_INFO(&logger(), "OS Name = {}, OS Version = {}, OS Architecture = {}",
+        Poco::Environment::osName(),
+        Poco::Environment::osVersion(),
+        Poco::Environment::osArchitecture());
 }
 
 std::string Server::getDefaultCorePath() const
@@ -879,7 +885,8 @@ int Server::main(const std::vector<std::string> & /*args*/)
         global_context->setMMappedFileCache(mmap_cache_size);
 
 #if USE_EMBEDDED_COMPILER
-    size_t compiled_expression_cache_size = config().getUInt64("compiled_expression_cache_size", 500);
+    constexpr size_t compiled_expression_cache_size_default = 1024 * 1024 * 1024;
+    size_t compiled_expression_cache_size = config().getUInt64("compiled_expression_cache_size", compiled_expression_cache_size_default);
     CompiledExpressionCacheFactory::instance().init(compiled_expression_cache_size);
 #endif
 
diff --git a/programs/server/config.xml b/programs/server/config.xml
index a7bb9d49e95..df8a5266c39 100644
--- a/programs/server/config.xml
+++ b/programs/server/config.xml
@@ -329,6 +329,8 @@
       -->
     <mmap_cache_size>1000</mmap_cache_size>
 
+    <!-- Cache size for compiled expressions.-->
+    <compiled_expression_cache_size>1073741824</compiled_expression_cache_size>
 
     <!-- Path to data directory, with trailing slash. -->
     <path>/var/lib/clickhouse/</path>
diff --git a/src/Access/DiskAccessStorage.cpp b/src/Access/DiskAccessStorage.cpp
index 80594f66dfc..8c38cd02f9c 100644
--- a/src/Access/DiskAccessStorage.cpp
+++ b/src/Access/DiskAccessStorage.cpp
@@ -355,8 +355,9 @@ String DiskAccessStorage::getStorageParamsJSON() const
     std::lock_guard lock{mutex};
     Poco::JSON::Object json;
     json.set("path", directory_path);
-    if (readonly)
-        json.set("readonly", readonly.load());
+    bool readonly_loaded = readonly;
+    if (readonly_loaded)
+        json.set("readonly", Poco::Dynamic::Var{true});
     std::ostringstream oss;         // STYLE_CHECK_ALLOW_STD_STRING_STREAM
     oss.exceptions(std::ios::failbit);
     Poco::JSON::Stringifier::stringify(json, oss);
diff --git a/src/Access/ExternalAuthenticators.cpp b/src/Access/ExternalAuthenticators.cpp
index 1cade973724..0c4d2f417c9 100644
--- a/src/Access/ExternalAuthenticators.cpp
+++ b/src/Access/ExternalAuthenticators.cpp
@@ -77,7 +77,7 @@ auto parseLDAPServer(const Poco::Util::AbstractConfiguration & config, const Str
         if (enable_tls_lc_str == "starttls")
             params.enable_tls = LDAPClient::Params::TLSEnable::YES_STARTTLS;
         else if (config.getBool(ldap_server_config + ".enable_tls"))
-            params.enable_tls = LDAPClient::Params::TLSEnable::YES;
+            params.enable_tls = LDAPClient::Params::TLSEnable::YES; //-V1048
         else
             params.enable_tls = LDAPClient::Params::TLSEnable::NO;
     }
@@ -96,7 +96,7 @@ auto parseLDAPServer(const Poco::Util::AbstractConfiguration & config, const Str
         else if (tls_minimum_protocol_version_lc_str == "tls1.1")
             params.tls_minimum_protocol_version = LDAPClient::Params::TLSProtocolVersion::TLS1_1;
         else if (tls_minimum_protocol_version_lc_str == "tls1.2")
-            params.tls_minimum_protocol_version = LDAPClient::Params::TLSProtocolVersion::TLS1_2;
+            params.tls_minimum_protocol_version = LDAPClient::Params::TLSProtocolVersion::TLS1_2; //-V1048
         else
             throw Exception("Bad value for 'tls_minimum_protocol_version' entry, allowed values are: 'ssl2', 'ssl3', 'tls1.0', 'tls1.1', 'tls1.2'", ErrorCodes::BAD_ARGUMENTS);
     }
@@ -113,7 +113,7 @@ auto parseLDAPServer(const Poco::Util::AbstractConfiguration & config, const Str
         else if (tls_require_cert_lc_str == "try")
             params.tls_require_cert = LDAPClient::Params::TLSRequireCert::TRY;
         else if (tls_require_cert_lc_str == "demand")
-            params.tls_require_cert = LDAPClient::Params::TLSRequireCert::DEMAND;
+            params.tls_require_cert = LDAPClient::Params::TLSRequireCert::DEMAND; //-V1048
         else
             throw Exception("Bad value for 'tls_require_cert' entry, allowed values are: 'never', 'allow', 'try', 'demand'", ErrorCodes::BAD_ARGUMENTS);
     }
diff --git a/src/Access/GrantedRoles.cpp b/src/Access/GrantedRoles.cpp
index 7930b56e44d..2659f8a3ec9 100644
--- a/src/Access/GrantedRoles.cpp
+++ b/src/Access/GrantedRoles.cpp
@@ -136,7 +136,7 @@ GrantedRoles::Elements GrantedRoles::getElements() const
     boost::range::set_difference(roles, roles_with_admin_option, std::back_inserter(element.ids));
     if (!element.empty())
     {
-        element.admin_option = false;
+        element.admin_option = false; //-V1048
         elements.emplace_back(std::move(element));
     }
 
diff --git a/src/Access/IAccessStorage.h b/src/Access/IAccessStorage.h
index 2cdd8eabf73..cc914664149 100644
--- a/src/Access/IAccessStorage.h
+++ b/src/Access/IAccessStorage.h
@@ -1,7 +1,7 @@
 #pragma once
 
 #include <Access/IAccessEntity.h>
-#include <common/types.h>
+#include <Core/Types.h>
 #include <Core/UUID.h>
 #include <ext/scope_guard.h>
 #include <functional>
diff --git a/src/Access/Quota.h b/src/Access/Quota.h
index 430bdca29b0..b7970b2583b 100644
--- a/src/Access/Quota.h
+++ b/src/Access/Quota.h
@@ -45,7 +45,7 @@ struct Quota : public IAccessEntity
 
     struct ResourceTypeInfo
     {
-        const char * const raw_name;
+        const char * const raw_name = "";
         const String name;    /// Lowercased with underscores, e.g. "result_rows".
         const String keyword; /// Uppercased with spaces, e.g. "RESULT ROWS".
         const bool output_as_float = false;
diff --git a/src/Access/RolesOrUsersSet.h b/src/Access/RolesOrUsersSet.h
index 0d8983c2ec3..871bb0c0758 100644
--- a/src/Access/RolesOrUsersSet.h
+++ b/src/Access/RolesOrUsersSet.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <Core/UUID.h>
+#include <Core/Types.h>
 #include <boost/container/flat_set.hpp>
 #include <memory>
 #include <optional>
diff --git a/src/Access/RowPolicy.h b/src/Access/RowPolicy.h
index c9b4d69152d..723db545dbe 100644
--- a/src/Access/RowPolicy.h
+++ b/src/Access/RowPolicy.h
@@ -2,6 +2,7 @@
 
 #include <Access/IAccessEntity.h>
 #include <Access/RolesOrUsersSet.h>
+#include <Core/Types.h>
 #include <array>
 
 
diff --git a/src/AggregateFunctions/AggregateFunctionAvg.h b/src/AggregateFunctions/AggregateFunctionAvg.h
index 8a6491d9b61..f2ea51ac28d 100644
--- a/src/AggregateFunctions/AggregateFunctionAvg.h
+++ b/src/AggregateFunctions/AggregateFunctionAvg.h
@@ -7,7 +7,7 @@
 #include <DataTypes/DataTypesDecimal.h>
 #include <DataTypes/DataTypesNumber.h>
 #include <AggregateFunctions/IAggregateFunction.h>
-#include "Core/DecimalFunctions.h"
+#include <Core/DecimalFunctions.h>
 
 
 namespace DB
diff --git a/src/AggregateFunctions/AggregateFunctionAvgWeighted.h b/src/AggregateFunctions/AggregateFunctionAvgWeighted.h
index f8b452fc444..8b932918aa5 100644
--- a/src/AggregateFunctions/AggregateFunctionAvgWeighted.h
+++ b/src/AggregateFunctions/AggregateFunctionAvgWeighted.h
@@ -5,18 +5,18 @@
 
 namespace DB
 {
-template <class T>
+template <typename T>
 using AvgWeightedFieldType = std::conditional_t<IsDecimalNumber<T>,
     std::conditional_t<std::is_same_v<T, Decimal256>, Decimal256, Decimal128>,
     std::conditional_t<DecimalOrExtendedInt<T>,
         Float64, // no way to do UInt128 * UInt128, better cast to Float64
         NearestFieldType<T>>>;
 
-template <class T, class U>
+template <typename T, typename U>
 using MaxFieldType = std::conditional_t<(sizeof(AvgWeightedFieldType<T>) > sizeof(AvgWeightedFieldType<U>)),
     AvgWeightedFieldType<T>, AvgWeightedFieldType<U>>;
 
-template <class Value, class Weight>
+template <typename Value, typename Weight>
 class AggregateFunctionAvgWeighted final :
     public AggregateFunctionAvgBase<
         MaxFieldType<Value, Weight>, AvgWeightedFieldType<Weight>, AggregateFunctionAvgWeighted<Value, Weight>>
diff --git a/src/AggregateFunctions/AggregateFunctionBoundingRatio.h b/src/AggregateFunctions/AggregateFunctionBoundingRatio.h
index 0cfb33efc10..bee58a4a932 100644
--- a/src/AggregateFunctions/AggregateFunctionBoundingRatio.h
+++ b/src/AggregateFunctions/AggregateFunctionBoundingRatio.h
@@ -2,7 +2,6 @@
 
 #include <DataTypes/DataTypesNumber.h>
 #include <Columns/ColumnsNumber.h>
-#include <Common/FieldVisitors.h>
 #include <IO/ReadHelpers.h>
 #include <IO/WriteHelpers.h>
 #include <AggregateFunctions/Helpers.h>
@@ -20,7 +19,7 @@ namespace ErrorCodes
 
 /** Tracks the leftmost and rightmost (x, y) data points.
   */
-struct AggregateFunctionBoundingRatioData
+struct AggregateFunctionBoundingRatioData //-V730
 {
     struct Point
     {
diff --git a/src/AggregateFunctions/AggregateFunctionDistinct.h b/src/AggregateFunctions/AggregateFunctionDistinct.h
index b587bbebf6e..b551f8a4ec5 100644
--- a/src/AggregateFunctions/AggregateFunctionDistinct.h
+++ b/src/AggregateFunctions/AggregateFunctionDistinct.h
@@ -10,7 +10,6 @@
 #include <Common/HashTable/HashMap.h>
 #include <Common/SipHash.h>
 
-#include <Common/FieldVisitors.h>
 
 namespace DB
 {
diff --git a/src/AggregateFunctions/AggregateFunctionGroupArray.h b/src/AggregateFunctions/AggregateFunctionGroupArray.h
index 921274f7d59..e59f19e3bae 100644
--- a/src/AggregateFunctions/AggregateFunctionGroupArray.h
+++ b/src/AggregateFunctions/AggregateFunctionGroupArray.h
@@ -296,12 +296,7 @@ public:
         if (size)
         {
             typename ColumnVector<T>::Container & data_to = assert_cast<ColumnVector<T> &>(arr_to.getData()).getData();
-            if constexpr (is_big_int_v<T>)
-                // is data_to empty? we should probably use std::vector::insert then
-                for (auto it = this->data(place).value.begin(); it != this->data(place).value.end(); it++)
-                    data_to.push_back(*it);
-            else
-                data_to.insert(this->data(place).value.begin(), this->data(place).value.end());
+            data_to.insert(this->data(place).value.begin(), this->data(place).value.end());
         }
     }
 
diff --git a/src/AggregateFunctions/AggregateFunctionGroupArrayMoving.cpp b/src/AggregateFunctions/AggregateFunctionGroupArrayMoving.cpp
index e2139ba882f..b6e9fda9559 100644
--- a/src/AggregateFunctions/AggregateFunctionGroupArrayMoving.cpp
+++ b/src/AggregateFunctions/AggregateFunctionGroupArrayMoving.cpp
@@ -21,6 +21,7 @@ namespace ErrorCodes
 namespace
 {
 
+/// TODO Proper support for Decimal256.
 template <typename T, typename LimitNumberOfElements>
 struct MovingSum
 {
diff --git a/src/AggregateFunctions/AggregateFunctionGroupArrayMoving.h b/src/AggregateFunctions/AggregateFunctionGroupArrayMoving.h
index 3bab831d316..8b7109ae3ef 100644
--- a/src/AggregateFunctions/AggregateFunctionGroupArrayMoving.h
+++ b/src/AggregateFunctions/AggregateFunctionGroupArrayMoving.h
@@ -38,7 +38,7 @@ struct MovingData
     using Array = PODArray<T, 32, Allocator>;
 
     Array value;    /// Prefix sums.
-    T sum = 0;
+    T sum{};
 
     void NO_SANITIZE_UNDEFINED add(T val, Arena * arena)
     {
@@ -69,9 +69,9 @@ struct MovingAvgData : public MovingData<T>
     T NO_SANITIZE_UNDEFINED get(size_t idx, UInt64 window_size) const
     {
         if (idx < window_size)
-            return this->value[idx] / window_size;
+            return this->value[idx] / T(window_size);
         else
-            return (this->value[idx] - this->value[idx - window_size]) / window_size;
+            return (this->value[idx] - this->value[idx - window_size]) / T(window_size);
     }
 };
 
diff --git a/src/AggregateFunctions/AggregateFunctionHistogram.h b/src/AggregateFunctions/AggregateFunctionHistogram.h
index c44cb61b275..a5a6920ce33 100644
--- a/src/AggregateFunctions/AggregateFunctionHistogram.h
+++ b/src/AggregateFunctions/AggregateFunctionHistogram.h
@@ -220,7 +220,7 @@ private:
     }
 
 public:
-    AggregateFunctionHistogramData()
+    AggregateFunctionHistogramData() //-V730
         : size(0)
         , lower_bound(std::numeric_limits<Mean>::max())
         , upper_bound(std::numeric_limits<Mean>::lowest())
diff --git a/src/AggregateFunctions/AggregateFunctionMannWhitney.h b/src/AggregateFunctions/AggregateFunctionMannWhitney.h
index 7efdebf1639..7573de65cc0 100644
--- a/src/AggregateFunctions/AggregateFunctionMannWhitney.h
+++ b/src/AggregateFunctions/AggregateFunctionMannWhitney.h
@@ -6,7 +6,6 @@
 #include <Columns/ColumnVector.h>
 #include <Columns/ColumnTuple.h>
 #include <Common/assert_cast.h>
-#include <Common/FieldVisitors.h>
 #include <Common/PODArray_fwd.h>
 #include <common/types.h>
 #include <DataTypes/DataTypesDecimal.h>
@@ -21,7 +20,7 @@
 
 #include <Common/ArenaAllocator.h>
 
-#include <iostream>
+
 namespace DB
 {
 
diff --git a/src/AggregateFunctions/AggregateFunctionMinMaxAny.h b/src/AggregateFunctions/AggregateFunctionMinMaxAny.h
index 919026a78c1..f4561660ad5 100644
--- a/src/AggregateFunctions/AggregateFunctionMinMaxAny.h
+++ b/src/AggregateFunctions/AggregateFunctionMinMaxAny.h
@@ -181,7 +181,7 @@ public:
 /** For strings. Short strings are stored in the object itself, and long strings are allocated separately.
   * NOTE It could also be suitable for arrays of numbers.
   */
-struct SingleValueDataString
+struct SingleValueDataString //-V730
 {
 private:
     using Self = SingleValueDataString;
diff --git a/src/AggregateFunctions/AggregateFunctionQuantile.cpp b/src/AggregateFunctions/AggregateFunctionQuantile.cpp
index 1dcdb288339..e8d86a03ff1 100644
--- a/src/AggregateFunctions/AggregateFunctionQuantile.cpp
+++ b/src/AggregateFunctions/AggregateFunctionQuantile.cpp
@@ -100,13 +100,14 @@ AggregateFunctionPtr createAggregateFunctionQuantile(const std::string & name, c
         if (which.idx == TypeIndex::Decimal32) return std::make_shared<Function<Decimal32, false>>(argument_types, params);
         if (which.idx == TypeIndex::Decimal64) return std::make_shared<Function<Decimal64, false>>(argument_types, params);
         if (which.idx == TypeIndex::Decimal128) return std::make_shared<Function<Decimal128, false>>(argument_types, params);
+        if (which.idx == TypeIndex::Decimal256) return std::make_shared<Function<Decimal256, false>>(argument_types, params);
         if (which.idx == TypeIndex::DateTime64) return std::make_shared<Function<DateTime64, false>>(argument_types, params);
-        //if (which.idx == TypeIndex::Decimal256) return std::make_shared<Function<Decimal256, false>>(argument_types, params);
     }
 
     if constexpr (supportBigInt<Function>())
     {
         if (which.idx == TypeIndex::Int128) return std::make_shared<Function<Int128, true>>(argument_types, params);
+        if (which.idx == TypeIndex::UInt128) return std::make_shared<Function<Int128, true>>(argument_types, params);
         if (which.idx == TypeIndex::Int256) return std::make_shared<Function<Int256, true>>(argument_types, params);
         if (which.idx == TypeIndex::UInt256) return std::make_shared<Function<UInt256, true>>(argument_types, params);
     }
diff --git a/src/AggregateFunctions/AggregateFunctionStatistics.cpp b/src/AggregateFunctions/AggregateFunctionStatistics.cpp
index 9e3aa0962db..d8c8c2ab210 100644
--- a/src/AggregateFunctions/AggregateFunctionStatistics.cpp
+++ b/src/AggregateFunctions/AggregateFunctionStatistics.cpp
@@ -36,7 +36,7 @@ AggregateFunctionPtr createAggregateFunctionStatisticsBinary(const std::string &
     assertNoParameters(name, parameters);
     assertBinary(name, argument_types);
 
-    AggregateFunctionPtr res(createWithTwoNumericTypes<FunctionTemplate>(*argument_types[0], *argument_types[1], argument_types));
+    AggregateFunctionPtr res(createWithTwoBasicNumericTypes<FunctionTemplate>(*argument_types[0], *argument_types[1], argument_types));
     if (!res)
         throw Exception("Illegal types " + argument_types[0]->getName() + " and " + argument_types[1]->getName()
             + " of arguments for aggregate function " + name, ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
diff --git a/src/AggregateFunctions/AggregateFunctionStatistics.h b/src/AggregateFunctions/AggregateFunctionStatistics.h
index 473bce1d89a..2b778f85d99 100644
--- a/src/AggregateFunctions/AggregateFunctionStatistics.h
+++ b/src/AggregateFunctions/AggregateFunctionStatistics.h
@@ -13,7 +13,7 @@
 namespace DB
 {
 
-namespace
+namespace detail
 {
 
 /// This function returns true if both values are large and comparable.
@@ -72,7 +72,7 @@ public:
         Float64 factor = static_cast<Float64>(count * source.count) / total_count;
         Float64 delta = mean - source.mean;
 
-        if (areComparable(count, source.count))
+        if (detail::areComparable(count, source.count))
             mean = (source.count * source.mean + count * mean) / total_count;
         else
             mean = source.mean + delta * (static_cast<Float64>(count) / total_count);
@@ -302,7 +302,7 @@ public:
         Float64 left_delta = left_mean - source.left_mean;
         Float64 right_delta = right_mean - source.right_mean;
 
-        if (areComparable(count, source.count))
+        if (detail::areComparable(count, source.count))
         {
             left_mean = (source.count * source.left_mean + count * left_mean) / total_count;
             right_mean = (source.count * source.right_mean + count * right_mean) / total_count;
diff --git a/src/AggregateFunctions/AggregateFunctionStatisticsSimple.cpp b/src/AggregateFunctions/AggregateFunctionStatisticsSimple.cpp
index c7c2f9025ed..5dde84c1b64 100644
--- a/src/AggregateFunctions/AggregateFunctionStatisticsSimple.cpp
+++ b/src/AggregateFunctions/AggregateFunctionStatisticsSimple.cpp
@@ -41,7 +41,7 @@ AggregateFunctionPtr createAggregateFunctionStatisticsBinary(const std::string &
     assertNoParameters(name, parameters);
     assertBinary(name, argument_types);
 
-    AggregateFunctionPtr res(createWithTwoNumericTypes<FunctionTemplate>(*argument_types[0], *argument_types[1], argument_types));
+    AggregateFunctionPtr res(createWithTwoBasicNumericTypes<FunctionTemplate>(*argument_types[0], *argument_types[1], argument_types));
     if (!res)
         throw Exception("Illegal types " + argument_types[0]->getName() + " and " + argument_types[1]->getName()
             + " of arguments for aggregate function " + name, ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
diff --git a/src/AggregateFunctions/AggregateFunctionStatisticsSimple.h b/src/AggregateFunctions/AggregateFunctionStatisticsSimple.h
index a5d6bbb7dc8..eaf119a6264 100644
--- a/src/AggregateFunctions/AggregateFunctionStatisticsSimple.h
+++ b/src/AggregateFunctions/AggregateFunctionStatisticsSimple.h
@@ -131,11 +131,10 @@ public:
                 static_cast<ResultType>(static_cast<const ColVecT2 &>(*columns[1]).getData()[row_num]));
         else
         {
-            if constexpr (std::is_same_v<T1, Decimal256>)
+            if constexpr (IsDecimalNumber<T1>)
             {
                 this->data(place).add(static_cast<ResultType>(
-                    static_cast<const ColVecT1 &>(*columns[0]).getData()[row_num].value
-                ));
+                    static_cast<const ColVecT1 &>(*columns[0]).getData()[row_num].value));
             }
             else
                 this->data(place).add(
diff --git a/src/AggregateFunctions/AggregateFunctionTopK.cpp b/src/AggregateFunctions/AggregateFunctionTopK.cpp
index e32da02f442..79a39817ea5 100644
--- a/src/AggregateFunctions/AggregateFunctionTopK.cpp
+++ b/src/AggregateFunctions/AggregateFunctionTopK.cpp
@@ -2,9 +2,10 @@
 #include <AggregateFunctions/AggregateFunctionTopK.h>
 #include <AggregateFunctions/Helpers.h>
 #include <AggregateFunctions/FactoryHelpers.h>
+#include <Common/FieldVisitors.h>
 #include <DataTypes/DataTypeDate.h>
 #include <DataTypes/DataTypeDateTime.h>
-#include "registerAggregateFunctions.h"
+
 
 #define TOP_K_MAX_SIZE 0xFFFFFF
 
diff --git a/src/AggregateFunctions/AggregateFunctionTopK.h b/src/AggregateFunctions/AggregateFunctionTopK.h
index dbc471687ea..5e5e7d07cec 100644
--- a/src/AggregateFunctions/AggregateFunctionTopK.h
+++ b/src/AggregateFunctions/AggregateFunctionTopK.h
@@ -10,7 +10,6 @@
 #include <Columns/ColumnArray.h>
 
 #include <Common/SpaceSaving.h>
-#include <Common/FieldVisitors.h>
 #include <Common/assert_cast.h>
 
 #include <AggregateFunctions/IAggregateFunction.h>
diff --git a/src/AggregateFunctions/AggregateFunctionUniq.cpp b/src/AggregateFunctions/AggregateFunctionUniq.cpp
index 32fdb188529..7637e076d5b 100644
--- a/src/AggregateFunctions/AggregateFunctionUniq.cpp
+++ b/src/AggregateFunctions/AggregateFunctionUniq.cpp
@@ -132,6 +132,12 @@ void registerAggregateFunctionsUniq(AggregateFunctionFactory & factory)
 
     factory.registerFunction("uniqExact",
         {createAggregateFunctionUniq<true, AggregateFunctionUniqExactData, AggregateFunctionUniqExactData<String>>, properties});
+
+#if USE_DATASKETCHES
+    factory.registerFunction("uniqThetaSketch",
+        {createAggregateFunctionUniq<AggregateFunctionUniqThetaSketchData, AggregateFunctionUniqThetaSketchData>, properties});
+#endif
+
 }
 
 }
diff --git a/src/AggregateFunctions/AggregateFunctionUniq.h b/src/AggregateFunctions/AggregateFunctionUniq.h
index 253af6e2895..6db1c49c071 100644
--- a/src/AggregateFunctions/AggregateFunctionUniq.h
+++ b/src/AggregateFunctions/AggregateFunctionUniq.h
@@ -22,6 +22,7 @@
 
 #include <AggregateFunctions/UniquesHashSet.h>
 #include <AggregateFunctions/IAggregateFunction.h>
+#include <AggregateFunctions/ThetaSketchData.h>
 #include <AggregateFunctions/UniqVariadicHash.h>
 
 
@@ -69,7 +70,7 @@ struct AggregateFunctionUniqHLL12Data<String>
 };
 
 template <>
-struct AggregateFunctionUniqHLL12Data<UInt128>
+struct AggregateFunctionUniqHLL12Data<UUID>
 {
     using Set = HyperLogLogWithSmallSetOptimization<UInt64, 16, 12>;
     Set set;
@@ -124,6 +125,19 @@ struct AggregateFunctionUniqExactData<String>
 };
 
 
+/// uniqThetaSketch
+#if USE_DATASKETCHES
+
+struct AggregateFunctionUniqThetaSketchData
+{
+    using Set = ThetaSketchData<UInt64>;
+    Set set;
+
+    static String getName() { return "uniqThetaSketch"; }
+};
+
+#endif
+
 namespace detail
 {
 
@@ -133,16 +147,14 @@ template <typename T> struct AggregateFunctionUniqTraits
 {
     static UInt64 hash(T x)
     {
-        if constexpr (std::is_same_v<T, UInt128>)
-        {
-            return sipHash64(x);
-        }
-        else if constexpr (std::is_same_v<T, Float32> || std::is_same_v<T, Float64>)
+        if constexpr (std::is_same_v<T, Float32> || std::is_same_v<T, Float64>)
         {
             return ext::bit_cast<UInt64>(x);
         }
         else if constexpr (sizeof(T) <= sizeof(UInt64))
+        {
             return x;
+        }
         else
             return DefaultHash64<T>(x);
     }
@@ -184,11 +196,17 @@ struct OneAdder
                 UInt128 key;
                 SipHash hash;
                 hash.update(value.data, value.size);
-                hash.get128(key.low, key.high);
+                hash.get128(key);
 
                 data.set.insert(key);
             }
         }
+#if USE_DATASKETCHES
+        else if constexpr (std::is_same_v<Data, AggregateFunctionUniqThetaSketchData>)
+        {
+            data.set.insertOriginal(column.getDataAt(row_num));
+        }
+#endif
     }
 };
 
diff --git a/src/AggregateFunctions/AggregateFunctionUniqCombined.cpp b/src/AggregateFunctions/AggregateFunctionUniqCombined.cpp
index c0064044f95..84a9267ffe0 100644
--- a/src/AggregateFunctions/AggregateFunctionUniqCombined.cpp
+++ b/src/AggregateFunctions/AggregateFunctionUniqCombined.cpp
@@ -3,11 +3,13 @@
 #include <AggregateFunctions/AggregateFunctionFactory.h>
 #include <AggregateFunctions/Helpers.h>
 
+#include <Common/FieldVisitors.h>
+
 #include <DataTypes/DataTypeDate.h>
 #include <DataTypes/DataTypeDateTime.h>
 
 #include <functional>
-#include "registerAggregateFunctions.h"
+
 
 namespace DB
 {
diff --git a/src/AggregateFunctions/AggregateFunctionUniqCombined.h b/src/AggregateFunctions/AggregateFunctionUniqCombined.h
index 31bd8021dcf..f425a343caa 100644
--- a/src/AggregateFunctions/AggregateFunctionUniqCombined.h
+++ b/src/AggregateFunctions/AggregateFunctionUniqCombined.h
@@ -1,7 +1,6 @@
 #pragma once
 
 #include <Common/CombinedCardinalityEstimator.h>
-#include <Common/FieldVisitors.h>
 #include <Common/SipHash.h>
 #include <Common/typeid_cast.h>
 #include <Common/assert_cast.h>
diff --git a/src/AggregateFunctions/AggregateFunctionUniqUpTo.cpp b/src/AggregateFunctions/AggregateFunctionUniqUpTo.cpp
index 9befc515de6..8195bd8964c 100644
--- a/src/AggregateFunctions/AggregateFunctionUniqUpTo.cpp
+++ b/src/AggregateFunctions/AggregateFunctionUniqUpTo.cpp
@@ -1,11 +1,11 @@
 #include <AggregateFunctions/AggregateFunctionFactory.h>
 #include <AggregateFunctions/Helpers.h>
 #include <AggregateFunctions/AggregateFunctionUniqUpTo.h>
+#include <Common/FieldVisitors.h>
 #include <DataTypes/DataTypeDate.h>
 #include <DataTypes/DataTypeDateTime.h>
 #include <DataTypes/DataTypeString.h>
 #include <DataTypes/DataTypeFixedString.h>
-#include "registerAggregateFunctions.h"
 
 
 namespace DB
diff --git a/src/AggregateFunctions/AggregateFunctionUniqUpTo.h b/src/AggregateFunctions/AggregateFunctionUniqUpTo.h
index 853e1cb6447..5dd62c96a9e 100644
--- a/src/AggregateFunctions/AggregateFunctionUniqUpTo.h
+++ b/src/AggregateFunctions/AggregateFunctionUniqUpTo.h
@@ -1,6 +1,7 @@
 #pragma once
 
-#include <Common/FieldVisitors.h>
+#include <common/unaligned.h>
+
 #include <Common/typeid_cast.h>
 #include <Common/assert_cast.h>
 
@@ -35,7 +36,7 @@ namespace DB
   */
 
 template <typename T>
-struct __attribute__((__packed__)) AggregateFunctionUniqUpToData
+struct AggregateFunctionUniqUpToData
 {
 /** If count == threshold + 1 - this means that it is "overflowed" (values greater than threshold).
   * In this case (for example, after calling the merge function), the `data` array does not necessarily contain the initialized values
@@ -43,7 +44,17 @@ struct __attribute__((__packed__)) AggregateFunctionUniqUpToData
   *   then set count to `threshold + 1`, and values from another state are not copied.
   */
     UInt8 count = 0;
-    T data[0];
+    char data_ptr[0];
+
+    T load(size_t i) const
+    {
+        return unalignedLoad<T>(data_ptr + i * sizeof(T));
+    }
+
+    void store(size_t i, const T & x)
+    {
+        unalignedStore<T>(data_ptr + i * sizeof(T), x);
+    }
 
     size_t size() const
     {
@@ -60,12 +71,12 @@ struct __attribute__((__packed__)) AggregateFunctionUniqUpToData
 
         /// Linear search for the matching element.
         for (size_t i = 0; i < count; ++i)
-            if (data[i] == x)
+            if (load(i) == x)
                 return;
 
         /// Did not find the matching element. If there is room for one more element, insert it.
         if (count < threshold)
-            data[count] = x;
+            store(count, x);
 
         /// After increasing count, the state may be overflowed.
         ++count;
@@ -84,7 +95,7 @@ struct __attribute__((__packed__)) AggregateFunctionUniqUpToData
         }
 
         for (size_t i = 0; i < rhs.count; ++i)
-            insert(rhs.data[i], threshold);
+            insert(rhs.load(i), threshold);
     }
 
     void write(WriteBuffer & wb, UInt8 threshold) const
@@ -93,7 +104,7 @@ struct __attribute__((__packed__)) AggregateFunctionUniqUpToData
 
         /// Write values only if the state is not overflowed. Otherwise, they are not needed, and only the fact that the state is overflowed is important.
         if (count <= threshold)
-            wb.write(reinterpret_cast<const char *>(data), count * sizeof(data[0]));
+            wb.write(data_ptr, count * sizeof(T));
     }
 
     void read(ReadBuffer & rb, UInt8 threshold)
@@ -101,7 +112,7 @@ struct __attribute__((__packed__)) AggregateFunctionUniqUpToData
         readBinary(count, rb);
 
         if (count <= threshold)
-            rb.read(reinterpret_cast<char *>(data), count * sizeof(data[0]));
+            rb.read(data_ptr, count * sizeof(T));
     }
 
     /// ALWAYS_INLINE is required to have better code layout for uniqUpTo function
diff --git a/src/AggregateFunctions/Helpers.h b/src/AggregateFunctions/Helpers.h
index bf51b5f6e2e..d1f1830eb27 100644
--- a/src/AggregateFunctions/Helpers.h
+++ b/src/AggregateFunctions/Helpers.h
@@ -15,12 +15,12 @@
     M(Float32) \
     M(Float64)
 
-// No UInt128 here because of the name conflict
 #define FOR_NUMERIC_TYPES(M) \
     M(UInt8) \
     M(UInt16) \
     M(UInt32) \
     M(UInt64) \
+    M(UInt128) \
     M(UInt256) \
     M(Int8) \
     M(Int16) \
@@ -109,6 +109,8 @@ static IAggregateFunction * createWithUnsignedIntegerType(const IDataType & argu
     if (which.idx == TypeIndex::UInt16) return new AggregateFunctionTemplate<UInt16, Data<UInt16>>(std::forward<TArgs>(args)...);
     if (which.idx == TypeIndex::UInt32) return new AggregateFunctionTemplate<UInt32, Data<UInt32>>(std::forward<TArgs>(args)...);
     if (which.idx == TypeIndex::UInt64) return new AggregateFunctionTemplate<UInt64, Data<UInt64>>(std::forward<TArgs>(args)...);
+    if (which.idx == TypeIndex::UInt128) return new AggregateFunctionTemplate<UInt128, Data<UInt128>>(std::forward<TArgs>(args)...);
+    if (which.idx == TypeIndex::UInt256) return new AggregateFunctionTemplate<UInt256, Data<UInt256>>(std::forward<TArgs>(args)...);
     return nullptr;
 }
 
@@ -119,11 +121,11 @@ static IAggregateFunction * createWithNumericBasedType(const IDataType & argumen
     if (f)
         return f;
 
-    /// expects that DataTypeDate based on UInt16, DataTypeDateTime based on UInt32 and UUID based on UInt128
+    /// expects that DataTypeDate based on UInt16, DataTypeDateTime based on UInt32
     WhichDataType which(argument_type);
     if (which.idx == TypeIndex::Date) return new AggregateFunctionTemplate<UInt16>(std::forward<TArgs>(args)...);
     if (which.idx == TypeIndex::DateTime) return new AggregateFunctionTemplate<UInt32>(std::forward<TArgs>(args)...);
-    if (which.idx == TypeIndex::UUID) return new AggregateFunctionTemplate<UInt128>(std::forward<TArgs>(args)...);
+    if (which.idx == TypeIndex::UUID) return new AggregateFunctionTemplate<UUID>(std::forward<TArgs>(args)...);
     return nullptr;
 }
 
@@ -184,6 +186,29 @@ static IAggregateFunction * createWithTwoNumericTypes(const IDataType & first_ty
     return nullptr;
 }
 
+template <typename FirstType, template <typename, typename> class AggregateFunctionTemplate, typename... TArgs>
+static IAggregateFunction * createWithTwoBasicNumericTypesSecond(const IDataType & second_type, TArgs && ... args)
+{
+    WhichDataType which(second_type);
+#define DISPATCH(TYPE) \
+    if (which.idx == TypeIndex::TYPE) return new AggregateFunctionTemplate<FirstType, TYPE>(std::forward<TArgs>(args)...);
+    FOR_BASIC_NUMERIC_TYPES(DISPATCH)
+#undef DISPATCH
+    return nullptr;
+}
+
+template <template <typename, typename> class AggregateFunctionTemplate, typename... TArgs>
+static IAggregateFunction * createWithTwoBasicNumericTypes(const IDataType & first_type, const IDataType & second_type, TArgs && ... args)
+{
+    WhichDataType which(first_type);
+#define DISPATCH(TYPE) \
+    if (which.idx == TypeIndex::TYPE) \
+        return createWithTwoBasicNumericTypesSecond<TYPE, AggregateFunctionTemplate>(second_type, std::forward<TArgs>(args)...);
+    FOR_BASIC_NUMERIC_TYPES(DISPATCH)
+#undef DISPATCH
+    return nullptr;
+}
+
 template <typename FirstType, template <typename, typename> class AggregateFunctionTemplate, typename... TArgs>
 static IAggregateFunction * createWithTwoNumericOrDateTypesSecond(const IDataType & second_type, TArgs && ... args)
 {
@@ -195,7 +220,7 @@ static IAggregateFunction * createWithTwoNumericOrDateTypesSecond(const IDataTyp
     if (which.idx == TypeIndex::Enum8) return new AggregateFunctionTemplate<FirstType, Int8>(std::forward<TArgs>(args)...);
     if (which.idx == TypeIndex::Enum16) return new AggregateFunctionTemplate<FirstType, Int16>(std::forward<TArgs>(args)...);
 
-    /// expects that DataTypeDate based on UInt16, DataTypeDateTime based on UInt32 and UUID based on UInt128
+    /// expects that DataTypeDate based on UInt16, DataTypeDateTime based on UInt32
     if (which.idx == TypeIndex::Date) return new AggregateFunctionTemplate<FirstType, UInt16>(std::forward<TArgs>(args)...);
     if (which.idx == TypeIndex::DateTime) return new AggregateFunctionTemplate<FirstType, UInt32>(std::forward<TArgs>(args)...);
 
@@ -216,7 +241,7 @@ static IAggregateFunction * createWithTwoNumericOrDateTypes(const IDataType & fi
     if (which.idx == TypeIndex::Enum16)
         return createWithTwoNumericOrDateTypesSecond<Int16, AggregateFunctionTemplate>(second_type, std::forward<TArgs>(args)...);
 
-    /// expects that DataTypeDate based on UInt16, DataTypeDateTime based on UInt32 and UUID based on UInt128
+    /// expects that DataTypeDate based on UInt16, DataTypeDateTime based on UInt32
     if (which.idx == TypeIndex::Date)
         return createWithTwoNumericOrDateTypesSecond<UInt16, AggregateFunctionTemplate>(second_type, std::forward<TArgs>(args)...);
     if (which.idx == TypeIndex::DateTime)
diff --git a/src/AggregateFunctions/QuantileExact.h b/src/AggregateFunctions/QuantileExact.h
index aa7b4bbe250..cca16aac610 100644
--- a/src/AggregateFunctions/QuantileExact.h
+++ b/src/AggregateFunctions/QuantileExact.h
@@ -263,7 +263,7 @@ struct QuantileExactLow : public QuantileExactBase<Value, QuantileExactLow<Value
         {
             // sort inputs in ascending order
             std::sort(array.begin(), array.end());
-            size_t n = level < 1 ? level * array.size() : (array.size() - 1);
+
             // if level is 0.5 then compute the "low" median of the sorted array
             // by the method of rounding.
             if (level == 0.5)
@@ -278,10 +278,14 @@ struct QuantileExactLow : public QuantileExactBase<Value, QuantileExactLow<Value
                     return array[static_cast<size_t>((floor(s / 2)) - 1)];
                 }
             }
-            // else quantile is the nth index of the sorted array obtained by multiplying
-            // level and size of array. Example if level = 0.1 and size of array is 10,
-            // then return array[1].
-            return array[n];
+            else
+            {
+                // else quantile is the nth index of the sorted array obtained by multiplying
+                // level and size of array. Example if level = 0.1 and size of array is 10,
+                // then return array[1].
+                size_t n = level < 1 ? level * array.size() : (array.size() - 1);
+                return array[n];
+            }
         }
         return std::numeric_limits<Value>::quiet_NaN();
     }
@@ -295,7 +299,7 @@ struct QuantileExactLow : public QuantileExactBase<Value, QuantileExactLow<Value
             for (size_t i = 0; i < size; ++i)
             {
                 auto level = levels[indices[i]];
-                size_t n = level < 1 ? level * array.size() : (array.size() - 1);
+
                 // if level is 0.5 then compute the "low" median of the sorted array
                 // by the method of rounding.
                 if (level == 0.5)
@@ -310,9 +314,13 @@ struct QuantileExactLow : public QuantileExactBase<Value, QuantileExactLow<Value
                         result[indices[i]] = array[static_cast<size_t>(floor((s / 2) - 1))];
                     }
                 }
-                // else quantile is the nth index of the sorted array obtained by multiplying
-                // level and size of array. Example if level = 0.1 and size of array is 10.
-                result[indices[i]] = array[n];
+                else
+                {
+                    // else quantile is the nth index of the sorted array obtained by multiplying
+                    // level and size of array. Example if level = 0.1 and size of array is 10.
+                    size_t n = level < 1 ? level * array.size() : (array.size() - 1);
+                    result[indices[i]] = array[n];
+                }
             }
         }
         else
@@ -337,7 +345,7 @@ struct QuantileExactHigh : public QuantileExactBase<Value, QuantileExactHigh<Val
         {
             // sort inputs in ascending order
             std::sort(array.begin(), array.end());
-            size_t n = level < 1 ? level * array.size() : (array.size() - 1);
+
             // if level is 0.5 then compute the "high" median of the sorted array
             // by the method of rounding.
             if (level == 0.5)
@@ -345,9 +353,13 @@ struct QuantileExactHigh : public QuantileExactBase<Value, QuantileExactHigh<Val
                 auto s = array.size();
                 return array[static_cast<size_t>(floor(s / 2))];
             }
-            // else quantile is the nth index of the sorted array obtained by multiplying
-            // level and size of array. Example if level = 0.1 and size of array is 10.
-            return array[n];
+            else
+            {
+                // else quantile is the nth index of the sorted array obtained by multiplying
+                // level and size of array. Example if level = 0.1 and size of array is 10.
+                size_t n = level < 1 ? level * array.size() : (array.size() - 1);
+                return array[n];
+            }
         }
         return std::numeric_limits<Value>::quiet_NaN();
     }
@@ -361,7 +373,7 @@ struct QuantileExactHigh : public QuantileExactBase<Value, QuantileExactHigh<Val
             for (size_t i = 0; i < size; ++i)
             {
                 auto level = levels[indices[i]];
-                size_t n = level < 1 ? level * array.size() : (array.size() - 1);
+
                 // if level is 0.5 then compute the "high" median of the sorted array
                 // by the method of rounding.
                 if (level == 0.5)
@@ -369,9 +381,13 @@ struct QuantileExactHigh : public QuantileExactBase<Value, QuantileExactHigh<Val
                     auto s = array.size();
                     result[indices[i]] = array[static_cast<size_t>(floor(s / 2))];
                 }
-                // else quantile is the nth index of the sorted array obtained by multiplying
-                // level and size of array. Example if level = 0.1 and size of array is 10.
-                result[indices[i]] = array[n];
+                else
+                {
+                    // else quantile is the nth index of the sorted array obtained by multiplying
+                    // level and size of array. Example if level = 0.1 and size of array is 10.
+                    size_t n = level < 1 ? level * array.size() : (array.size() - 1);
+                    result[indices[i]] = array[n];
+                }
             }
         }
         else
diff --git a/src/AggregateFunctions/QuantileReservoirSampler.h b/src/AggregateFunctions/QuantileReservoirSampler.h
index 6b4af04a5fb..e0217731a12 100644
--- a/src/AggregateFunctions/QuantileReservoirSampler.h
+++ b/src/AggregateFunctions/QuantileReservoirSampler.h
@@ -54,7 +54,7 @@ struct QuantileReservoirSampler
     /// Get the value of the `level` quantile. The level must be between 0 and 1.
     Value get(Float64 level)
     {
-        return data.quantileInterpolated(level);
+        return Value(data.quantileInterpolated(level));
     }
 
     /// Get the `size` values of `levels` quantiles. Write `size` results starting with `result` address.
@@ -62,7 +62,7 @@ struct QuantileReservoirSampler
     void getMany(const Float64 * levels, const size_t * indices, size_t size, Value * result)
     {
         for (size_t i = 0; i < size; ++i)
-            result[indices[i]] = data.quantileInterpolated(levels[indices[i]]);
+            result[indices[i]] = Value(data.quantileInterpolated(levels[indices[i]]));
     }
 
     /// The same, but in the case of an empty state, NaN is returned.
diff --git a/src/AggregateFunctions/ReservoirSampler.h b/src/AggregateFunctions/ReservoirSampler.h
index a321ef08648..e4cc77dd361 100644
--- a/src/AggregateFunctions/ReservoirSampler.h
+++ b/src/AggregateFunctions/ReservoirSampler.h
@@ -131,12 +131,20 @@ public:
         size_t left_index = static_cast<size_t>(index);
         size_t right_index = left_index + 1;
         if (right_index == samples.size())
-            return static_cast<double>(samples[left_index]);
+        {
+            if constexpr (DB::IsDecimalNumber<T>)
+                return static_cast<double>(samples[left_index].value);
+            else
+                return static_cast<double>(samples[left_index]);
+        }
 
         double left_coef = right_index - index;
         double right_coef = index - left_index;
 
-        return static_cast<double>(samples[left_index]) * left_coef + static_cast<double>(samples[right_index]) * right_coef;
+        if constexpr (DB::IsDecimalNumber<T>)
+            return static_cast<double>(samples[left_index].value) * left_coef + static_cast<double>(samples[right_index].value) * right_coef;
+        else
+            return static_cast<double>(samples[left_index]) * left_coef + static_cast<double>(samples[right_index]) * right_coef;
     }
 
     void merge(const ReservoirSampler<T, OnEmpty> & b)
diff --git a/src/AggregateFunctions/ThetaSketchData.h b/src/AggregateFunctions/ThetaSketchData.h
new file mode 100644
index 00000000000..b2e32db6c75
--- /dev/null
+++ b/src/AggregateFunctions/ThetaSketchData.h
@@ -0,0 +1,119 @@
+#pragma once
+
+#if !defined(ARCADIA_BUILD)
+#    include <Common/config.h>
+#endif
+
+#if USE_DATASKETCHES
+
+#include <boost/noncopyable.hpp>
+#include <memory>
+#include <theta_sketch.hpp> // Y_IGNORE
+#include <theta_union.hpp> // Y_IGNORE
+
+
+namespace DB
+{
+
+
+template <typename Key>
+class ThetaSketchData : private boost::noncopyable
+{
+private:
+    std::unique_ptr<datasketches::update_theta_sketch> sk_update;
+    std::unique_ptr<datasketches::theta_union> sk_union;
+
+    inline datasketches::update_theta_sketch * getSkUpdate()
+    {
+        if (!sk_update)
+            sk_update = std::make_unique<datasketches::update_theta_sketch>(datasketches::update_theta_sketch::builder().build());
+        return sk_update.get();
+    }
+
+    inline datasketches::theta_union * getSkUnion()
+    {
+        if (!sk_union)
+            sk_union = std::make_unique<datasketches::theta_union>(datasketches::theta_union::builder().build());
+        return sk_union.get();
+    }
+
+public:
+    using value_type = Key;
+
+    ThetaSketchData() = default;
+    ~ThetaSketchData() = default;
+
+    /// Insert original value without hash, as `datasketches::update_theta_sketch.update` will do the hash internal.
+    void insertOriginal(const StringRef & value)
+    {
+        getSkUpdate()->update(value.data, value.size);
+    }
+
+    /// Note that `datasketches::update_theta_sketch.update` will do the hash again.
+    void insert(Key value)
+    {
+        getSkUpdate()->update(value);
+    }
+
+    UInt64 size() const
+    {
+        if (sk_union)
+            return static_cast<UInt64>(sk_union->get_result().get_estimate());
+        else if (sk_update)
+            return static_cast<UInt64>(sk_update->get_estimate());
+        else
+            return 0;
+    }
+
+    void merge(const ThetaSketchData & rhs)
+    {
+        datasketches::theta_union * u = getSkUnion();
+
+        if (sk_update)
+        {
+            u->update(*sk_update);
+            sk_update.reset(nullptr);
+        }
+
+        if (rhs.sk_update)
+            u->update(*rhs.sk_update);
+        else if (rhs.sk_union)
+            u->update(rhs.sk_union->get_result());
+    }
+
+    /// You can only call for an empty object.
+    void read(DB::ReadBuffer & in)
+    {
+        datasketches::compact_theta_sketch::vector_bytes bytes;
+        readVectorBinary(bytes, in);
+        if (!bytes.empty())
+        {
+            auto sk = datasketches::compact_theta_sketch::deserialize(bytes.data(), bytes.size());
+            getSkUnion()->update(sk);
+        }
+    }
+
+    void write(DB::WriteBuffer & out) const
+    {
+        if (sk_update)
+        {
+            auto bytes = sk_update->compact().serialize();
+            writeVectorBinary(bytes, out);
+        }
+        else if (sk_union)
+        {
+            auto bytes = sk_union->get_result().serialize();
+            writeVectorBinary(bytes, out);
+        }
+        else
+        {
+            datasketches::compact_theta_sketch::vector_bytes bytes;
+            writeVectorBinary(bytes, out);
+        }
+    }
+};
+
+
+}
+
+#endif
diff --git a/src/AggregateFunctions/UniqVariadicHash.h b/src/AggregateFunctions/UniqVariadicHash.h
index d6e584a2e1e..7ca80a9db34 100644
--- a/src/AggregateFunctions/UniqVariadicHash.h
+++ b/src/AggregateFunctions/UniqVariadicHash.h
@@ -3,7 +3,6 @@
 #include <city.h>
 #include <Core/Defines.h>
 #include <Common/SipHash.h>
-#include <Common/UInt128.h>
 #include <Common/assert_cast.h>
 #include <Columns/ColumnTuple.h>
 
@@ -107,7 +106,7 @@ struct UniqVariadicHash<true, false>
         }
 
         UInt128 key;
-        hash.get128(key.low, key.high);
+        hash.get128(key);
         return key;
     }
 };
@@ -131,7 +130,7 @@ struct UniqVariadicHash<true, true>
         }
 
         UInt128 key;
-        hash.get128(key.low, key.high);
+        hash.get128(key);
         return key;
     }
 };
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 69a84dbeb2c..292adc0e124 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -184,6 +184,7 @@ add_object_library(clickhouse_disks Disks)
 add_object_library(clickhouse_interpreters Interpreters)
 add_object_library(clickhouse_interpreters_mysql Interpreters/MySQL)
 add_object_library(clickhouse_interpreters_clusterproxy Interpreters/ClusterProxy)
+add_object_library(clickhouse_interpreters_jit Interpreters/JIT)
 add_object_library(clickhouse_columns Columns)
 add_object_library(clickhouse_storages Storages)
 add_object_library(clickhouse_storages_distributed Storages/Distributed)
diff --git a/src/Columns/ColumnDecimal.h b/src/Columns/ColumnDecimal.h
index a4fa15c2d95..8621a793f49 100644
--- a/src/Columns/ColumnDecimal.h
+++ b/src/Columns/ColumnDecimal.h
@@ -85,8 +85,8 @@ private:
     {}
 
 public:
-    const char * getFamilyName() const override { return TypeName<T>::get(); }
-    TypeIndex getDataType() const override { return TypeId<T>::value; }
+    const char * getFamilyName() const override { return TypeName<T>; }
+    TypeIndex getDataType() const override { return TypeId<T>; }
 
     bool isNumeric() const override { return false; }
     bool canBeInsideNullable() const override { return true; }
diff --git a/src/Columns/ColumnUnique.h b/src/Columns/ColumnUnique.h
index 82083339107..51b45be53fd 100644
--- a/src/Columns/ColumnUnique.h
+++ b/src/Columns/ColumnUnique.h
@@ -665,7 +665,7 @@ UInt128 ColumnUnique<ColumnType>::IncrementalHash::getHash(const ColumnType & co
             column.updateHashWithValue(i, sip_hash);
 
         std::lock_guard lock(mutex);
-        sip_hash.get128(hash.low, hash.high);
+        sip_hash.get128(hash);
         cur_hash = hash;
         num_added_rows.store(column_size);
     }
diff --git a/src/Columns/ColumnVector.cpp b/src/Columns/ColumnVector.cpp
index a64906ba257..4e2a8c16586 100644
--- a/src/Columns/ColumnVector.cpp
+++ b/src/Columns/ColumnVector.cpp
@@ -33,6 +33,7 @@ namespace ErrorCodes
     extern const int PARAMETER_OUT_OF_BOUND;
     extern const int SIZES_OF_COLUMNS_DOESNT_MATCH;
     extern const int LOGICAL_ERROR;
+    extern const int NOT_IMPLEMENTED;
 }
 
 template <typename T>
@@ -154,7 +155,7 @@ void ColumnVector<T>::getPermutation(bool reverse, size_t limit, int nan_directi
     else
     {
         /// A case for radix sort
-        if constexpr (is_arithmetic_v<T> && !std::is_same_v<T, UInt128>)
+        if constexpr (is_arithmetic_v<T> && !is_big_int_v<T>)
         {
             /// Thresholds on size. Lower threshold is arbitrary. Upper threshold is chosen by the type for histogram counters.
             if (s >= 256 && s <= std::numeric_limits<UInt32>::max())
@@ -292,28 +293,37 @@ MutableColumnPtr ColumnVector<T>::cloneResized(size_t size) const
         memcpy(new_col.data.data(), data.data(), count * sizeof(data[0]));
 
         if (size > count)
-            memset(static_cast<void *>(&new_col.data[count]), static_cast<int>(ValueType()), (size - count) * sizeof(ValueType));
+            memset(static_cast<void *>(&new_col.data[count]), 0, (size - count) * sizeof(ValueType));
     }
 
     return res;
 }
 
 template <typename T>
-UInt64 ColumnVector<T>::get64(size_t n) const
+UInt64 ColumnVector<T>::get64(size_t n [[maybe_unused]]) const
 {
-    return ext::bit_cast<UInt64>(data[n]);
+    if constexpr (is_arithmetic_v<T>)
+        return ext::bit_cast<UInt64>(data[n]);
+    else
+        throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Cannot get the value of {} as UInt64", TypeName<T>);
 }
 
 template <typename T>
-inline Float64 ColumnVector<T>::getFloat64(size_t n) const
+inline Float64 ColumnVector<T>::getFloat64(size_t n [[maybe_unused]]) const
 {
-    return static_cast<Float64>(data[n]);
+    if constexpr (is_arithmetic_v<T>)
+        return static_cast<Float64>(data[n]);
+    else
+        throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Cannot get the value of {} as Float64", TypeName<T>);
 }
 
 template <typename T>
-Float32 ColumnVector<T>::getFloat32(size_t n) const
+Float32 ColumnVector<T>::getFloat32(size_t n [[maybe_unused]]) const
 {
-    return static_cast<Float32>(data[n]);
+    if constexpr (is_arithmetic_v<T>)
+        return static_cast<Float32>(data[n]);
+    else
+        throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Cannot get the value of {} as Float32", TypeName<T>);
 }
 
 template <typename T>
@@ -482,8 +492,6 @@ void ColumnVector<T>::gather(ColumnGathererStream & gatherer)
 template <typename T>
 void ColumnVector<T>::getExtremes(Field & min, Field & max) const
 {
-    using FastRefT = std::conditional_t<is_big_int_v<T>, const T &, const T>;
-
     size_t size = data.size();
 
     if (size == 0)
@@ -504,7 +512,7 @@ void ColumnVector<T>::getExtremes(Field & min, Field & max) const
     T cur_min = NaNOrZero<T>();
     T cur_max = NaNOrZero<T>();
 
-    for (FastRefT x : data)
+    for (const T & x : data)
     {
         if (isNaN(x))
             continue;
@@ -569,5 +577,6 @@ template class ColumnVector<Int128>;
 template class ColumnVector<Int256>;
 template class ColumnVector<Float32>;
 template class ColumnVector<Float64>;
+template class ColumnVector<UUID>;
 
 }
diff --git a/src/Columns/ColumnVector.h b/src/Columns/ColumnVector.h
index 30ab38ed1c2..e75fd11d190 100644
--- a/src/Columns/ColumnVector.h
+++ b/src/Columns/ColumnVector.h
@@ -12,6 +12,12 @@
 namespace DB
 {
 
+namespace ErrorCodes
+{
+    extern const int NOT_IMPLEMENTED;
+}
+
+
 /** Stuff for comparing numbers.
   * Integer values are compared as usual.
   * Floating-point numbers are compared this way that NaNs always end up at the end
@@ -90,6 +96,7 @@ struct FloatCompareHelper
 template <class U> struct CompareHelper<Float32, U> : public FloatCompareHelper<Float32> {};
 template <class U> struct CompareHelper<Float64, U> : public FloatCompareHelper<Float64> {};
 
+
 /** A template for columns that use a simple array to store.
  */
 template <typename T>
@@ -118,7 +125,7 @@ private:
     ColumnVector(std::initializer_list<T> il) : data{il} {}
 
 public:
-    bool isNumeric() const override { return IsNumber<T>; }
+    bool isNumeric() const override { return is_arithmetic_v<T>; }
 
     size_t size() const override
     {
@@ -221,8 +228,8 @@ public:
         data.reserve(n);
     }
 
-    const char * getFamilyName() const override { return TypeName<T>::get(); }
-    TypeIndex getDataType() const override { return TypeId<T>::value; }
+    const char * getFamilyName() const override { return TypeName<T>; }
+    TypeIndex getDataType() const override { return TypeId<T>; }
 
     MutableColumnPtr cloneResized(size_t size) const override;
 
@@ -245,18 +252,27 @@ public:
     /// Out of range conversion is permitted.
     UInt64 NO_SANITIZE_UNDEFINED getUInt(size_t n) const override
     {
-        return UInt64(data[n]);
+        if constexpr (is_arithmetic_v<T>)
+            return UInt64(data[n]);
+        else
+            throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Cannot get the value of {} as UInt", TypeName<T>);
     }
 
     /// Out of range conversion is permitted.
     Int64 NO_SANITIZE_UNDEFINED getInt(size_t n) const override
     {
-        return Int64(data[n]);
+        if constexpr (is_arithmetic_v<T>)
+            return Int64(data[n]);
+        else
+            throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Cannot get the value of {} as Int", TypeName<T>);
     }
 
     bool getBool(size_t n) const override
     {
-        return bool(data[n]);
+        if constexpr (is_arithmetic_v<T>)
+            return bool(data[n]);
+        else
+            throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Cannot get the value of {} as bool", TypeName<T>);
     }
 
     void insert(const Field & x) override
@@ -370,5 +386,6 @@ extern template class ColumnVector<Int128>;
 extern template class ColumnVector<Int256>;
 extern template class ColumnVector<Float32>;
 extern template class ColumnVector<Float64>;
+extern template class ColumnVector<UUID>;
 
 }
diff --git a/src/Columns/ColumnsNumber.h b/src/Columns/ColumnsNumber.h
index 17a28e617c3..48721c32fa0 100644
--- a/src/Columns/ColumnsNumber.h
+++ b/src/Columns/ColumnsNumber.h
@@ -26,6 +26,6 @@ using ColumnInt256 = ColumnVector<Int256>;
 using ColumnFloat32 = ColumnVector<Float32>;
 using ColumnFloat64 = ColumnVector<Float64>;
 
-using ColumnUUID = ColumnVector<UInt128>;
+using ColumnUUID = ColumnVector<UUID>;
 
 }
diff --git a/src/Columns/IColumnUnique.h b/src/Columns/IColumnUnique.h
index 731445e2b80..2c1c542fce5 100644
--- a/src/Columns/IColumnUnique.h
+++ b/src/Columns/IColumnUnique.h
@@ -1,7 +1,6 @@
 #pragma once
 #include <optional>
 #include <Columns/IColumn.h>
-#include <Common/UInt128.h>
 
 namespace DB
 {
diff --git a/src/Columns/tests/gtest_weak_hash_32.cpp b/src/Columns/tests/gtest_weak_hash_32.cpp
index 0dabfc32b33..2fa6c0ea8ac 100644
--- a/src/Columns/tests/gtest_weak_hash_32.cpp
+++ b/src/Columns/tests/gtest_weak_hash_32.cpp
@@ -14,11 +14,11 @@
 #include <DataTypes/DataTypesNumber.h>
 
 #include <Common/WeakHash.h>
+#include <Common/hex.h>
 
 #include <unordered_map>
 #include <iostream>
 #include <sstream>
-#include <Common/hex.h>
 
 
 using namespace DB;
@@ -27,20 +27,11 @@ template <typename T>
 void checkColumn(
     const WeakHash32::Container & hash,
     const PaddedPODArray<T> & eq_class,
-    const std::function<std::string(size_t)> & print_function,
     size_t allowed_collisions = 0,
     size_t max_collisions_to_print = 10)
 {
     ASSERT_EQ(hash.size(), eq_class.size());
 
-    auto print_for_row = [&](size_t row)
-    {
-        std::string res = "row: " + std::to_string(row);
-        res += " hash: " + std::to_string(hash[row]);
-        res += " value: " + print_function(row);
-        return res;
-    };
-
     /// Check equal rows has equal hash.
     {
         std::unordered_map<T, UInt32> map;
@@ -55,11 +46,7 @@ void checkColumn(
             else
             {
                 if (it->second != hash[i])
-                {
-                    std::cout << "Different hashes for the same equivalent class (" << size_t(val) << "):\n";
-                    std::cout << print_for_row(it->first) << '\n';
-                    std::cout << print_for_row(i) << std::endl;
-                }
+                    std::cout << "Different hashes for the same equivalent class (" << toString(val) << ")\n";
 
                 ASSERT_EQ(it->second, hash[i]);
             }
@@ -88,7 +75,6 @@ void checkColumn(
                 if (num_collisions <= max_collisions_to_print)
                 {
                     collisions_str << "Collision:\n";
-                    collisions_str << print_for_row(i) << std::endl;
                 }
 
                 if (num_collisions > allowed_collisions)
@@ -117,7 +103,7 @@ TEST(WeakHash32, ColumnVectorU8)
     WeakHash32 hash(col->size());
     col->updateWeakHash32(hash);
 
-    checkColumn(hash.getData(), col->getData(), [&](size_t row) { return std::to_string(col->getElement(row)); });
+    checkColumn(hash.getData(), col->getData());
 }
 
 TEST(WeakHash32, ColumnVectorI8)
@@ -134,7 +120,7 @@ TEST(WeakHash32, ColumnVectorI8)
     WeakHash32 hash(col->size());
     col->updateWeakHash32(hash);
 
-    checkColumn(hash.getData(), col->getData(), [&](size_t row) { return std::to_string(col->getElement(row)); });
+    checkColumn(hash.getData(), col->getData());
 }
 
 TEST(WeakHash32, ColumnVectorU16)
@@ -151,7 +137,7 @@ TEST(WeakHash32, ColumnVectorU16)
     WeakHash32 hash(col->size());
     col->updateWeakHash32(hash);
 
-    checkColumn(hash.getData(), col->getData(), [&](size_t row) { return std::to_string(col->getElement(row)); });
+    checkColumn(hash.getData(), col->getData());
 }
 
 TEST(WeakHash32, ColumnVectorI16)
@@ -168,7 +154,7 @@ TEST(WeakHash32, ColumnVectorI16)
     WeakHash32 hash(col->size());
     col->updateWeakHash32(hash);
 
-    checkColumn(hash.getData(), col->getData(), [&](size_t row) { return std::to_string(col->getElement(row)); });
+    checkColumn(hash.getData(), col->getData());
 }
 
 TEST(WeakHash32, ColumnVectorU32)
@@ -185,7 +171,7 @@ TEST(WeakHash32, ColumnVectorU32)
     WeakHash32 hash(col->size());
     col->updateWeakHash32(hash);
 
-    checkColumn(hash.getData(), col->getData(), [&](size_t row) { return std::to_string(col->getElement(row)); });
+    checkColumn(hash.getData(), col->getData());
 }
 
 TEST(WeakHash32, ColumnVectorI32)
@@ -202,7 +188,7 @@ TEST(WeakHash32, ColumnVectorI32)
     WeakHash32 hash(col->size());
     col->updateWeakHash32(hash);
 
-    checkColumn(hash.getData(), col->getData(), [&](size_t row) { return std::to_string(col->getElement(row)); });
+    checkColumn(hash.getData(), col->getData());
 }
 
 TEST(WeakHash32, ColumnVectorU64)
@@ -219,7 +205,7 @@ TEST(WeakHash32, ColumnVectorU64)
     WeakHash32 hash(col->size());
     col->updateWeakHash32(hash);
 
-    checkColumn(hash.getData(), col->getData(), [&](size_t row) { return std::to_string(col->getElement(row)); });
+    checkColumn(hash.getData(), col->getData());
 }
 
 TEST(WeakHash32, ColumnVectorI64)
@@ -236,7 +222,7 @@ TEST(WeakHash32, ColumnVectorI64)
     WeakHash32 hash(col->size());
     col->updateWeakHash32(hash);
 
-    checkColumn(hash.getData(), col->getData(), [&](size_t row) { return std::to_string(col->getElement(row)); });
+    checkColumn(hash.getData(), col->getData());
 }
 
 TEST(WeakHash32, ColumnVectorU128)
@@ -250,7 +236,9 @@ TEST(WeakHash32, ColumnVectorU128)
     {
         for (uint64_t i = 0; i < 65536; ++i)
         {
-            UInt128 val(i << 32u, i << 32u);
+            UInt128 val;
+            val.items[0] = i << 32u;
+            val.items[1] = i << 32u;
             data.push_back(val);
             eq_data.push_back(i);
         }
@@ -259,7 +247,7 @@ TEST(WeakHash32, ColumnVectorU128)
     WeakHash32 hash(col->size());
     col->updateWeakHash32(hash);
 
-    checkColumn(hash.getData(), eq_data, [&](size_t row) { return col->getElement(row).toHexString(); });
+    checkColumn(hash.getData(), eq_data);
 }
 
 TEST(WeakHash32, ColumnVectorI128)
@@ -276,7 +264,7 @@ TEST(WeakHash32, ColumnVectorI128)
     WeakHash32 hash(col->size());
     col->updateWeakHash32(hash);
 
-    checkColumn(hash.getData(), col->getData(), [&](size_t row) { return std::to_string(Int64(col->getElement(row))); });
+    checkColumn(hash.getData(), col->getData());
 }
 
 TEST(WeakHash32, ColumnDecimal32)
@@ -293,7 +281,7 @@ TEST(WeakHash32, ColumnDecimal32)
     WeakHash32 hash(col->size());
     col->updateWeakHash32(hash);
 
-    checkColumn(hash.getData(), col->getData(), [&](size_t row) { return std::to_string(col->getElement(row)); });
+    checkColumn(hash.getData(), col->getData());
 }
 
 TEST(WeakHash32, ColumnDecimal64)
@@ -310,7 +298,7 @@ TEST(WeakHash32, ColumnDecimal64)
     WeakHash32 hash(col->size());
     col->updateWeakHash32(hash);
 
-    checkColumn(hash.getData(), col->getData(), [&](size_t row) { return std::to_string(col->getElement(row)); });
+    checkColumn(hash.getData(), col->getData());
 }
 
 TEST(WeakHash32, ColumnDecimal128)
@@ -327,7 +315,7 @@ TEST(WeakHash32, ColumnDecimal128)
     WeakHash32 hash(col->size());
     col->updateWeakHash32(hash);
 
-    checkColumn(hash.getData(), col->getData(), [&](size_t row) { return std::to_string(Int64(col->getElement(row))); });
+    checkColumn(hash.getData(), col->getData());
 }
 
 TEST(WeakHash32, ColumnString1)
@@ -349,7 +337,7 @@ TEST(WeakHash32, ColumnString1)
     WeakHash32 hash(col->size());
     col->updateWeakHash32(hash);
 
-    checkColumn(hash.getData(), data, [&](size_t row) { return col->getDataAt(row).toString(); });
+    checkColumn(hash.getData(), data);
 }
 
 TEST(WeakHash32, ColumnString2)
@@ -389,7 +377,7 @@ TEST(WeakHash32, ColumnString2)
     /// Now there is single collision between 'k' * 544 and 'q' * 2512 (which is calculated twice)
     size_t allowed_collisions = 4;
 
-    checkColumn(hash.getData(), data, [&](size_t row) { return col->getDataAt(row).toString(); }, allowed_collisions);
+    checkColumn(hash.getData(), data, allowed_collisions);
 }
 
 TEST(WeakHash32, ColumnString3)
@@ -427,7 +415,7 @@ TEST(WeakHash32, ColumnString3)
     WeakHash32 hash(col->size());
     col->updateWeakHash32(hash);
 
-    checkColumn(hash.getData(), data, [&](size_t row) { return col->getDataAt(row).toString(); });
+    checkColumn(hash.getData(), data);
 }
 
 TEST(WeakHash32, ColumnFixedString)
@@ -455,7 +443,7 @@ TEST(WeakHash32, ColumnFixedString)
     WeakHash32 hash(col->size());
     col->updateWeakHash32(hash);
 
-    checkColumn(hash.getData(), data, [&](size_t row) { return col->getDataAt(row).toString(); });
+    checkColumn(hash.getData(), data);
 }
 
 TEST(WeakHash32, ColumnArray)
@@ -502,15 +490,7 @@ TEST(WeakHash32, ColumnArray)
     WeakHash32 hash(col_arr->size());
     col_arr->updateWeakHash32(hash);
 
-    auto print_function = [&col_arr](size_t row)
-    {
-        auto & offsets = col_arr->getOffsets();
-        size_t s = offsets[row] - offsets[row - 1];
-        auto value = col_arr->getData().getUInt(offsets[row]);
-        return std::string("[array of size ") + std::to_string(s) + " with values " + std::to_string(value) + "]";
-    };
-
-    checkColumn(hash.getData(), eq_data, print_function);
+    checkColumn(hash.getData(), eq_data);
 }
 
 TEST(WeakHash32, ColumnArray2)
@@ -545,15 +525,7 @@ TEST(WeakHash32, ColumnArray2)
     WeakHash32 hash(col_arr->size());
     col_arr->updateWeakHash32(hash);
 
-    auto print_function = [&col_arr](size_t row)
-    {
-        auto & offsets = col_arr->getOffsets();
-        auto value1 = col_arr->getData().getUInt(offsets[row]);
-        auto value2 = col_arr->getData().getUInt(offsets[row] + 1);
-        return std::string("[") + std::to_string(value1) + ", " + std::to_string(value2) + "]";
-    };
-
-    checkColumn(hash.getData(), eq_data, print_function);
+    checkColumn(hash.getData(), eq_data);
 }
 
 TEST(WeakHash32, ColumnArrayArray)
@@ -610,20 +582,7 @@ TEST(WeakHash32, ColumnArrayArray)
     WeakHash32 hash(col_arr_arr->size());
     col_arr_arr->updateWeakHash32(hash);
 
-    auto print_function = [&col_arr_arr](size_t row2)
-    {
-        auto & offsets2 = col_arr_arr->getOffsets();
-        size_t s2 = offsets2[row2] - offsets2[row2 - 1];
-        const auto & arr2 = typeid_cast<const ColumnArray &>(col_arr_arr->getData());
-        const auto & offsets = arr2.getOffsets();
-        size_t row = offsets2[row2];
-        size_t s = offsets[row] - offsets[row - 1];
-        auto value = arr2.getData().getUInt(offsets[row]);
-        return std::string("[array of size ") + std::to_string(s2) + " with values ["
-                                "[[array of size " + std::to_string(s) + " with values " + std::to_string(value) + "]]";
-    };
-
-    checkColumn(hash.getData(), eq_data, print_function);
+    checkColumn(hash.getData(), eq_data);
 }
 
 TEST(WeakHash32, ColumnConst)
@@ -642,7 +601,7 @@ TEST(WeakHash32, ColumnConst)
     WeakHash32 hash(col_const->size());
     col_const->updateWeakHash32(hash);
 
-    checkColumn(hash.getData(), data, [&](size_t) { return std::to_string(0); });
+    checkColumn(hash.getData(), data);
 }
 
 TEST(WeakHash32, ColumnLowcardinality)
@@ -663,7 +622,7 @@ TEST(WeakHash32, ColumnLowcardinality)
     WeakHash32 hash(col->size());
     col->updateWeakHash32(hash);
 
-    checkColumn(hash.getData(), data, [&](size_t row) { return std::to_string(col->getUInt(row)); });
+    checkColumn(hash.getData(), data);
 }
 
 TEST(WeakHash32, ColumnNullable)
@@ -689,7 +648,7 @@ TEST(WeakHash32, ColumnNullable)
     WeakHash32 hash(col_null->size());
     col_null->updateWeakHash32(hash);
 
-    checkColumn(hash.getData(), eq, [&](size_t row) { return eq[row] == -1 ? "Null" : std::to_string(eq[row]); });
+    checkColumn(hash.getData(), eq);
 }
 
 TEST(WeakHash32, ColumnTupleUInt64UInt64)
@@ -720,14 +679,7 @@ TEST(WeakHash32, ColumnTupleUInt64UInt64)
     WeakHash32 hash(col_tuple->size());
     col_tuple->updateWeakHash32(hash);
 
-    auto print_func = [&](size_t row)
-    {
-        std::string l = std::to_string(col_tuple->getColumn(0).getUInt(row));
-        std::string r = std::to_string(col_tuple->getColumn(1).getUInt(row));
-        return "(" + l + ", " + r + ")";
-    };
-
-    checkColumn(hash.getData(), eq, print_func);
+    checkColumn(hash.getData(), eq);
 }
 
 TEST(WeakHash32, ColumnTupleUInt64String)
@@ -765,15 +717,8 @@ TEST(WeakHash32, ColumnTupleUInt64String)
     WeakHash32 hash(col_tuple->size());
     col_tuple->updateWeakHash32(hash);
 
-    auto print_func = [&](size_t row)
-    {
-        std::string l = std::to_string(col_tuple->getColumn(0).getUInt(row));
-        std::string r = col_tuple->getColumn(1).getDataAt(row).toString();
-        return "(" + l + ", " + r + ")";
-    };
-
     size_t allowed_collisions = 8;
-    checkColumn(hash.getData(), eq, print_func, allowed_collisions);
+    checkColumn(hash.getData(), eq, allowed_collisions);
 }
 
 TEST(WeakHash32, ColumnTupleUInt64FixedString)
@@ -811,14 +756,7 @@ TEST(WeakHash32, ColumnTupleUInt64FixedString)
     WeakHash32 hash(col_tuple->size());
     col_tuple->updateWeakHash32(hash);
 
-    auto print_func = [&](size_t row)
-    {
-        std::string l = std::to_string(col_tuple->getColumn(0).getUInt(row));
-        std::string r = col_tuple->getColumn(1).getDataAt(row).toString();
-        return "(" + l + ", " + r + ")";
-    };
-
-    checkColumn(hash.getData(), eq, print_func);
+    checkColumn(hash.getData(), eq);
 }
 
 TEST(WeakHash32, ColumnTupleUInt64Array)
@@ -865,23 +803,10 @@ TEST(WeakHash32, ColumnTupleUInt64Array)
     WeakHash32 hash(col_tuple->size());
     col_tuple->updateWeakHash32(hash);
 
-    auto print_func = [&](size_t row)
-    {
-        std::string l = std::to_string(col_tuple->getColumn(0).getUInt(row));
-
-        const auto * col_arr = typeid_cast<const ColumnArray *>(col_tuple->getColumnPtr(1).get());
-        const auto & offsets = col_arr->getOffsets();
-        size_t s = offsets[row] - offsets[row - 1];
-        auto value = col_arr->getData().getUInt(offsets[row]);
-        auto r = std::string("[array of size ") + std::to_string(s) + " with values " + std::to_string(value) + "]";
-
-        return "(" + l + ", " + r + ")";
-    };
-
     /// There are 2 collisions right now (repeated 2 times each):
     /// (0, [array of size 1212 with values 7]) vs (0, [array of size 2265 with values 17])
     /// (0, [array of size 558 with values 5]) vs (1, [array of size 879 with values 21])
 
     size_t allowed_collisions = 8;
-    checkColumn(hash.getData(), eq_data, print_func, allowed_collisions);
+    checkColumn(hash.getData(), eq_data, allowed_collisions);
 }
diff --git a/src/Common/ColumnsHashing.h b/src/Common/ColumnsHashing.h
index ada783d982c..3ffa9bb71de 100644
--- a/src/Common/ColumnsHashing.h
+++ b/src/Common/ColumnsHashing.h
@@ -166,8 +166,7 @@ public:
         size_t operator()(const DictionaryKey & key) const
         {
             SipHash hash;
-            hash.update(key.hash.low);
-            hash.update(key.hash.high);
+            hash.update(key.hash);
             hash.update(key.size);
             return hash.get64();
         }
diff --git a/src/Common/CompactArray.h b/src/Common/CompactArray.h
index 785cd04b4d0..7291fe3f18d 100644
--- a/src/Common/CompactArray.h
+++ b/src/Common/CompactArray.h
@@ -159,12 +159,12 @@ private:
     /// The number of bytes read.
     size_t read_count = 0;
     /// The content in the current position.
-    UInt8 value_l;
-    UInt8 value_r;
+    UInt8 value_l = 0;
+    UInt8 value_r = 0;
     ///
     bool is_eof = false;
     /// Does the cell fully fit into one byte?
-    bool fits_in_byte;
+    bool fits_in_byte = false;
 };
 
 /** TODO This code looks very suboptimal.
diff --git a/src/Common/Dwarf.cpp b/src/Common/Dwarf.cpp
index d0b3244dac2..18e9315d5c3 100644
--- a/src/Common/Dwarf.cpp
+++ b/src/Common/Dwarf.cpp
@@ -804,7 +804,7 @@ bool Dwarf::findLocation(
         findSubProgramDieForAddress(cu, die, address, base_addr_cu, subprogram);
 
         // Subprogram is the DIE of caller function.
-        if (check_inline && subprogram.abbr.has_children)
+        if (/*check_inline &&*/ subprogram.abbr.has_children)
         {
             // Use an extra location and get its call file and call line, so that
             // they can be used for the second last location when we don't have
@@ -832,7 +832,7 @@ bool Dwarf::findLocation(
                 // file+line of the non-inlined outer function making the call.
                 // locationInfo.name is already set by the caller by looking up the
                 // non-inlined function @address belongs to.
-                info.has_file_and_line = true;
+                info.has_file_and_line = true; //-V1048
                 info.file = call_locations[0].file;
                 info.line = call_locations[0].line;
 
diff --git a/src/Common/Dwarf.h b/src/Common/Dwarf.h
index 9ea940c3380..4712daad28c 100644
--- a/src/Common/Dwarf.h
+++ b/src/Common/Dwarf.h
@@ -121,7 +121,7 @@ public:
     struct CallLocation
     {
         Path file = {};
-        uint64_t line;
+        uint64_t line = 0;
         std::string_view name;
     };
 
@@ -202,8 +202,8 @@ private:
     // Abbreviation for a Debugging Information Entry.
     struct DIEAbbreviation
     {
-        uint64_t code;
-        uint64_t tag;
+        uint64_t code = 0;
+        uint64_t tag = 0;
         bool has_children = false;
 
         std::string_view attributes;
diff --git a/src/Common/ErrorCodes.h b/src/Common/ErrorCodes.h
index ffd0b8b8619..cefd77df868 100644
--- a/src/Common/ErrorCodes.h
+++ b/src/Common/ErrorCodes.h
@@ -29,7 +29,7 @@ namespace ErrorCodes
     struct Error
     {
         /// Number of times Exception with this ErrorCode had been throw.
-        Value count;
+        Value count = 0;
         /// Time of the last error.
         UInt64 error_time_ms = 0;
         /// Message for the last error.
diff --git a/src/Common/FieldVisitors.cpp b/src/Common/FieldVisitors.cpp
index 62f04816032..b87152da7e7 100644
--- a/src/Common/FieldVisitors.cpp
+++ b/src/Common/FieldVisitors.cpp
@@ -1,4 +1,3 @@
-#include <Core/UUID.h>
 #include <IO/ReadBuffer.h>
 #include <IO/WriteBuffer.h>
 #include <IO/WriteHelpers.h>
@@ -27,7 +26,7 @@ template <typename T>
 static inline String formatQuotedWithPrefix(T x, const char * prefix)
 {
     WriteBufferFromOwnString wb;
-    wb.write(prefix, strlen(prefix));
+    writeCString(prefix, wb);
     writeQuoted(x, wb);
     return wb.str();
 }
@@ -48,10 +47,11 @@ String FieldVisitorDump::operator() (const DecimalField<Decimal32> & x) const {
 String FieldVisitorDump::operator() (const DecimalField<Decimal64> & x) const { return formatQuotedWithPrefix(x, "Decimal64_"); }
 String FieldVisitorDump::operator() (const DecimalField<Decimal128> & x) const { return formatQuotedWithPrefix(x, "Decimal128_"); }
 String FieldVisitorDump::operator() (const DecimalField<Decimal256> & x) const { return formatQuotedWithPrefix(x, "Decimal256_"); }
+String FieldVisitorDump::operator() (const UInt128 & x) const { return formatQuotedWithPrefix(x, "UInt128_"); }
 String FieldVisitorDump::operator() (const UInt256 & x) const { return formatQuotedWithPrefix(x, "UInt256_"); }
-String FieldVisitorDump::operator() (const Int256 & x) const { return formatQuotedWithPrefix(x, "Int256_"); }
 String FieldVisitorDump::operator() (const Int128 & x) const { return formatQuotedWithPrefix(x, "Int128_"); }
-String FieldVisitorDump::operator() (const UInt128 & x) const { return formatQuotedWithPrefix(UUID(x), "UUID_"); }
+String FieldVisitorDump::operator() (const Int256 & x) const { return formatQuotedWithPrefix(x, "Int256_"); }
+String FieldVisitorDump::operator() (const UUID & x) const { return formatQuotedWithPrefix(x, "UUID_"); }
 
 
 String FieldVisitorDump::operator() (const String & x) const
@@ -152,13 +152,11 @@ String FieldVisitorToString::operator() (const DecimalField<Decimal64> & x) cons
 String FieldVisitorToString::operator() (const DecimalField<Decimal128> & x) const { return formatQuoted(x); }
 String FieldVisitorToString::operator() (const DecimalField<Decimal256> & x) const { return formatQuoted(x); }
 String FieldVisitorToString::operator() (const Int128 & x) const { return formatQuoted(x); }
-String FieldVisitorToString::operator() (const UInt128 & x) const { return formatQuoted(UUID(x)); }
-String FieldVisitorToString::operator() (const AggregateFunctionStateData & x) const
-{
-    return formatQuoted(x.data);
-}
+String FieldVisitorToString::operator() (const UInt128 & x) const { return formatQuoted(x); }
 String FieldVisitorToString::operator() (const UInt256 & x) const { return formatQuoted(x); }
 String FieldVisitorToString::operator() (const Int256 & x) const { return formatQuoted(x); }
+String FieldVisitorToString::operator() (const UUID & x) const { return formatQuoted(x); }
+String FieldVisitorToString::operator() (const AggregateFunctionStateData & x) const { return formatQuoted(x.data); }
 
 String FieldVisitorToString::operator() (const Array & x) const
 {
@@ -228,6 +226,7 @@ void FieldVisitorWriteBinary::operator() (const UInt128 & x, WriteBuffer & buf)
 void FieldVisitorWriteBinary::operator() (const Int128 & x, WriteBuffer & buf) const { DB::writeVarInt(x, buf); }
 void FieldVisitorWriteBinary::operator() (const UInt256 & x, WriteBuffer & buf) const { DB::writeBinary(x, buf); }
 void FieldVisitorWriteBinary::operator() (const Int256 & x, WriteBuffer & buf) const { DB::writeBinary(x, buf); }
+void FieldVisitorWriteBinary::operator() (const UUID & x, WriteBuffer & buf) const { DB::writeBinary(x, buf); }
 void FieldVisitorWriteBinary::operator() (const DecimalField<Decimal32> & x, WriteBuffer & buf) const { DB::writeBinary(x.getValue(), buf); }
 void FieldVisitorWriteBinary::operator() (const DecimalField<Decimal64> & x, WriteBuffer & buf) const { DB::writeBinary(x.getValue(), buf); }
 void FieldVisitorWriteBinary::operator() (const DecimalField<Decimal128> & x, WriteBuffer & buf) const { DB::writeBinary(x.getValue(), buf); }
@@ -315,6 +314,13 @@ void FieldVisitorHash::operator() (const Int128 & x) const
     hash.update(x);
 }
 
+void FieldVisitorHash::operator() (const UUID & x) const
+{
+    UInt8 type = Field::Types::UUID;
+    hash.update(type);
+    hash.update(x);
+}
+
 void FieldVisitorHash::operator() (const Float64 & x) const
 {
     UInt8 type = Field::Types::Float64;
diff --git a/src/Common/FieldVisitors.h b/src/Common/FieldVisitors.h
index 5adbf2b01ac..0384be39494 100644
--- a/src/Common/FieldVisitors.h
+++ b/src/Common/FieldVisitors.h
@@ -19,14 +19,6 @@ namespace ErrorCodes
     extern const int NOT_IMPLEMENTED;
 }
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wredundant-decls"
-// Just dont mess with it. If the redundant redeclaration is removed then ReaderHelpers.h should be included.
-// This leads to Arena.h inclusion which has a problem with ASAN stuff included properly and messing macro definition
-// which intefrers with... You dont want to know, really.
-UInt128 stringToUUID(const String & str);
-#pragma GCC diagnostic pop
-
 
 /** StaticVisitor (and its descendants) - class with overloaded operator() for all types of fields.
   * You could call visitor for field using function 'applyVisitor'.
@@ -71,8 +63,11 @@ public:
     String operator() (const Null & x) const;
     String operator() (const UInt64 & x) const;
     String operator() (const UInt128 & x) const;
+    String operator() (const UInt256 & x) const;
     String operator() (const Int64 & x) const;
     String operator() (const Int128 & x) const;
+    String operator() (const Int256 & x) const;
+    String operator() (const UUID & x) const;
     String operator() (const Float64 & x) const;
     String operator() (const String & x) const;
     String operator() (const Array & x) const;
@@ -83,9 +78,6 @@ public:
     String operator() (const DecimalField<Decimal128> & x) const;
     String operator() (const DecimalField<Decimal256> & x) const;
     String operator() (const AggregateFunctionStateData & x) const;
-
-    String operator() (const UInt256 & x) const;
-    String operator() (const Int256 & x) const;
 };
 
 
@@ -95,8 +87,11 @@ public:
     void operator() (const Null & x, WriteBuffer & buf) const;
     void operator() (const UInt64 & x, WriteBuffer & buf) const;
     void operator() (const UInt128 & x, WriteBuffer & buf) const;
+    void operator() (const UInt256 & x, WriteBuffer & buf) const;
     void operator() (const Int64 & x, WriteBuffer & buf) const;
     void operator() (const Int128 & x, WriteBuffer & buf) const;
+    void operator() (const Int256 & x, WriteBuffer & buf) const;
+    void operator() (const UUID & x, WriteBuffer & buf) const;
     void operator() (const Float64 & x, WriteBuffer & buf) const;
     void operator() (const String & x, WriteBuffer & buf) const;
     void operator() (const Array & x, WriteBuffer & buf) const;
@@ -107,9 +102,6 @@ public:
     void operator() (const DecimalField<Decimal128> & x, WriteBuffer & buf) const;
     void operator() (const DecimalField<Decimal256> & x, WriteBuffer & buf) const;
     void operator() (const AggregateFunctionStateData & x, WriteBuffer & buf) const;
-
-    void operator() (const UInt256 & x, WriteBuffer & buf) const;
-    void operator() (const Int256 & x, WriteBuffer & buf) const;
 };
 
 
@@ -120,8 +112,11 @@ public:
     String operator() (const Null & x) const;
     String operator() (const UInt64 & x) const;
     String operator() (const UInt128 & x) const;
+    String operator() (const UInt256 & x) const;
     String operator() (const Int64 & x) const;
     String operator() (const Int128 & x) const;
+    String operator() (const Int256 & x) const;
+    String operator() (const UUID & x) const;
     String operator() (const Float64 & x) const;
     String operator() (const String & x) const;
     String operator() (const Array & x) const;
@@ -132,9 +127,6 @@ public:
     String operator() (const DecimalField<Decimal128> & x) const;
     String operator() (const DecimalField<Decimal256> & x) const;
     String operator() (const AggregateFunctionStateData & x) const;
-
-    String operator() (const UInt256 & x) const;
-    String operator() (const Int256 & x) const;
 };
 
 
@@ -171,6 +163,7 @@ public:
     T operator() (const UInt64 & x) const { return T(x); }
     T operator() (const Int64 & x) const { return T(x); }
     T operator() (const Int128 & x) const { return T(x); }
+    T operator() (const UUID & x) const { return T(x.toUnderType()); }
 
     T operator() (const Float64 & x) const
     {
@@ -259,8 +252,11 @@ public:
     void operator() (const Null & x) const;
     void operator() (const UInt64 & x) const;
     void operator() (const UInt128 & x) const;
+    void operator() (const UInt256 & x) const;
     void operator() (const Int64 & x) const;
     void operator() (const Int128 & x) const;
+    void operator() (const Int256 & x) const;
+    void operator() (const UUID & x) const;
     void operator() (const Float64 & x) const;
     void operator() (const String & x) const;
     void operator() (const Array & x) const;
@@ -271,9 +267,6 @@ public:
     void operator() (const DecimalField<Decimal128> & x) const;
     void operator() (const DecimalField<Decimal256> & x) const;
     void operator() (const AggregateFunctionStateData & x) const;
-
-    void operator() (const UInt256 & x) const;
-    void operator() (const Int256 & x) const;
 };
 
 
@@ -309,7 +302,7 @@ public:
     bool operator() (Array &) const { throw Exception("Cannot sum Arrays", ErrorCodes::LOGICAL_ERROR); }
     bool operator() (Tuple &) const { throw Exception("Cannot sum Tuples", ErrorCodes::LOGICAL_ERROR); }
     bool operator() (Map &) const { throw Exception("Cannot sum Maps", ErrorCodes::LOGICAL_ERROR); }
-    bool operator() (UInt128 &) const { throw Exception("Cannot sum UUIDs", ErrorCodes::LOGICAL_ERROR); }
+    bool operator() (UUID &) const { throw Exception("Cannot sum UUIDs", ErrorCodes::LOGICAL_ERROR); }
     bool operator() (AggregateFunctionStateData &) const { throw Exception("Cannot sum AggregateFunctionStates", ErrorCodes::LOGICAL_ERROR); }
 
     bool operator() (Int128 & x) const
diff --git a/src/Common/FieldVisitorsAccurateComparison.h b/src/Common/FieldVisitorsAccurateComparison.h
index 84099eafb0f..cf3cbb208dc 100644
--- a/src/Common/FieldVisitorsAccurateComparison.h
+++ b/src/Common/FieldVisitorsAccurateComparison.h
@@ -36,41 +36,30 @@ public:
             if constexpr (std::is_arithmetic_v<T> && std::is_arithmetic_v<U>)
                 return accurate::equalsOp(l, r);
 
+            /// TODO This is wrong (does not respect scale).
             if constexpr (isDecimalField<T>() && isDecimalField<U>())
                 return l == r;
 
             if constexpr (isDecimalField<T>() && std::is_arithmetic_v<U>)
-                return l == DecimalField<Decimal128>(r, 0);
+                return l == DecimalField<Decimal256>(Decimal256(r), 0);
 
             if constexpr (std::is_arithmetic_v<T> && isDecimalField<U>())
-                return DecimalField<Decimal128>(l, 0) == r;
+                return DecimalField<Decimal256>(Decimal256(l), 0) == r;
 
-            if constexpr (std::is_same_v<T, String>)
+            if constexpr (std::is_same_v<T, String> && std::is_arithmetic_v<U>)
             {
-                if constexpr (std::is_same_v<U, UInt128>)
-                    return stringToUUID(l) == r;
-
-                if constexpr (std::is_arithmetic_v<U>)
-                {
-                    ReadBufferFromString in(l);
-                    U parsed;
-                    readText(parsed, in);
-                    return operator()(parsed, r);
-                }
+                ReadBufferFromString in(l);
+                U parsed;
+                readText(parsed, in);
+                return operator()(parsed, r);
             }
 
-            if constexpr (std::is_same_v<U, String>)
+            if constexpr (std::is_same_v<U, String> && std::is_arithmetic_v<T>)
             {
-                if constexpr (std::is_same_v<T, UInt128>)
-                    return l == stringToUUID(r);
-
-                if constexpr (std::is_arithmetic_v<T>)
-                {
-                    ReadBufferFromString in(r);
-                    T parsed;
-                    readText(parsed, in);
-                    return operator()(l, parsed);
-                }
+                ReadBufferFromString in(r);
+                T parsed;
+                readText(parsed, in);
+                return operator()(l, parsed);
             }
         }
 
@@ -96,41 +85,30 @@ public:
             if constexpr (std::is_arithmetic_v<T> && std::is_arithmetic_v<U>)
                 return accurate::lessOp(l, r);
 
+            /// TODO This is wrong (does not respect scale).
             if constexpr (isDecimalField<T>() && isDecimalField<U>())
                 return l < r;
 
             if constexpr (isDecimalField<T>() && std::is_arithmetic_v<U>)
-                return l < DecimalField<Decimal128>(r, 0);
+                return l < DecimalField<Decimal256>(Decimal256(r), 0);
 
             if constexpr (std::is_arithmetic_v<T> && isDecimalField<U>())
-                return DecimalField<Decimal128>(l, 0) < r;
+                return DecimalField<Decimal256>(Decimal256(l), 0) < r;
 
-            if constexpr (std::is_same_v<T, String>)
+            if constexpr (std::is_same_v<T, String> && std::is_arithmetic_v<U>)
             {
-                if constexpr (std::is_same_v<U, UInt128>)
-                    return stringToUUID(l) < r;
-
-                if constexpr (std::is_arithmetic_v<U>)
-                {
-                    ReadBufferFromString in(l);
-                    U parsed;
-                    readText(parsed, in);
-                    return operator()(parsed, r);
-                }
+                ReadBufferFromString in(l);
+                U parsed;
+                readText(parsed, in);
+                return operator()(parsed, r);
             }
 
-            if constexpr (std::is_same_v<U, String>)
+            if constexpr (std::is_same_v<U, String> && std::is_arithmetic_v<T>)
             {
-                if constexpr (std::is_same_v<T, UInt128>)
-                    return l < stringToUUID(r);
-
-                if constexpr (std::is_arithmetic_v<T>)
-                {
-                    ReadBufferFromString in(r);
-                    T parsed;
-                    readText(parsed, in);
-                    return operator()(l, parsed);
-                }
+                ReadBufferFromString in(r);
+                T parsed;
+                readText(parsed, in);
+                return operator()(l, parsed);
             }
         }
 
diff --git a/src/Common/HashTable/ClearableHashSet.h b/src/Common/HashTable/ClearableHashSet.h
index dc057afacd8..7da0469a99a 100644
--- a/src/Common/HashTable/ClearableHashSet.h
+++ b/src/Common/HashTable/ClearableHashSet.h
@@ -44,7 +44,7 @@ struct ClearableHashTableCell : public BaseCell
     /// Do I need to store the zero key separately (that is, can a zero key be inserted into the hash table).
     static constexpr bool need_zero_value_storage = false;
 
-    ClearableHashTableCell() {}
+    ClearableHashTableCell() {} //-V730
     ClearableHashTableCell(const Key & key_, const State & state) : BaseCell(key_, state), version(state.version) {}
 };
 
diff --git a/src/Common/HashTable/FixedClearableHashSet.h b/src/Common/HashTable/FixedClearableHashSet.h
index 19d4669831f..56c7afd250e 100644
--- a/src/Common/HashTable/FixedClearableHashSet.h
+++ b/src/Common/HashTable/FixedClearableHashSet.h
@@ -13,7 +13,7 @@ struct FixedClearableHashTableCell
     using mapped_type = VoidMapped;
     UInt32 version;
 
-    FixedClearableHashTableCell() {}
+    FixedClearableHashTableCell() {} //-V730
     FixedClearableHashTableCell(const Key &, const State & state) : version(state.version) {}
 
     const VoidKey getKey() const { return {}; }
diff --git a/src/Common/HashTable/FixedHashMap.h b/src/Common/HashTable/FixedHashMap.h
index 9fc331e09e4..37bd81c8b4f 100644
--- a/src/Common/HashTable/FixedHashMap.h
+++ b/src/Common/HashTable/FixedHashMap.h
@@ -16,7 +16,7 @@ struct FixedHashMapCell
     bool full;
     Mapped mapped;
 
-    FixedHashMapCell() {}
+    FixedHashMapCell() {} //-V730
     FixedHashMapCell(const Key &, const State &) : full(true) {}
     FixedHashMapCell(const value_type & value_, const State &) : full(true), mapped(value_.second) {}
 
@@ -31,7 +31,7 @@ struct FixedHashMapCell
     ///  Note that we have to assemble a continuous layout for the value_type on each call of getValue().
     struct CellExt
     {
-        CellExt() {}
+        CellExt() {} //-V730
         CellExt(Key && key_, const FixedHashMapCell * ptr_) : key(key_), ptr(const_cast<FixedHashMapCell *>(ptr_)) {}
         void update(Key && key_, const FixedHashMapCell * ptr_)
         {
@@ -76,7 +76,7 @@ struct FixedHashMapImplicitZeroCell
     ///  Note that we have to assemble a continuous layout for the value_type on each call of getValue().
     struct CellExt
     {
-        CellExt() {}
+        CellExt() {} //-V730
         CellExt(Key && key_, const FixedHashMapImplicitZeroCell * ptr_) : key(key_), ptr(const_cast<FixedHashMapImplicitZeroCell *>(ptr_)) {}
         void update(Key && key_, const FixedHashMapImplicitZeroCell * ptr_)
         {
diff --git a/src/Common/HashTable/FixedHashTable.h b/src/Common/HashTable/FixedHashTable.h
index e4715a6c1da..c1d2c8fe6ee 100644
--- a/src/Common/HashTable/FixedHashTable.h
+++ b/src/Common/HashTable/FixedHashTable.h
@@ -19,7 +19,7 @@ struct FixedHashTableCell
     using mapped_type = VoidMapped;
     bool full;
 
-    FixedHashTableCell() {}
+    FixedHashTableCell() {} //-V730
     FixedHashTableCell(const Key &, const State &) : full(true) {}
 
     const VoidKey getKey() const { return {}; }
@@ -267,7 +267,7 @@ public:
         DB::ReadBuffer & in;
         Cell cell;
         size_t read_count = 0;
-        size_t size;
+        size_t size = 0;
         bool is_eof = false;
         bool is_initialized = false;
     };
diff --git a/src/Common/HashTable/Hash.h b/src/Common/HashTable/Hash.h
index d601d945ccf..84e514c1375 100644
--- a/src/Common/HashTable/Hash.h
+++ b/src/Common/HashTable/Hash.h
@@ -1,9 +1,10 @@
 #pragma once
 
+#include <city.h>
+#include <Core/Types.h>
 #include <common/types.h>
 #include <common/unaligned.h>
 #include <common/StringRef.h>
-#include <Common/UInt128.h>
 
 #include <type_traits>
 
@@ -167,35 +168,36 @@ inline size_t DefaultHash64(std::enable_if_t<(sizeof(T) <= sizeof(UInt64)), T> k
     return intHash64(u.out);
 }
 
-template <typename T>
-static constexpr bool UseDefaultHashForBigInts =
-    std::is_same_v<T, DB::Int128>  ||
-    std::is_same_v<T, DB::UInt128> ||
-    (is_big_int_v<T> && sizeof(T) == 32);
 
 template <typename T>
-inline size_t DefaultHash64(std::enable_if_t<(sizeof(T) > sizeof(UInt64) && UseDefaultHashForBigInts<T>), T> key)
+inline size_t DefaultHash64(std::enable_if_t<(sizeof(T) > sizeof(UInt64)), T> key)
 {
-    if constexpr (std::is_same_v<T, DB::Int128>)
+    if constexpr (is_big_int_v<T> && sizeof(T) == 16)
     {
-        return intHash64(static_cast<UInt64>(key) ^ static_cast<UInt64>(key >> 64));
+        /// TODO This is classical antipattern.
+        return intHash64(
+            static_cast<UInt64>(key) ^
+            static_cast<UInt64>(key >> 64));
     }
-    else if constexpr (std::is_same_v<T, DB::UInt128>)
+    else if constexpr (std::is_same_v<T, DB::UUID>)
     {
-        return intHash64(key.low ^ key.high);
+        return intHash64(
+            static_cast<UInt64>(key.toUnderType()) ^
+            static_cast<UInt64>(key.toUnderType() >> 64));
     }
     else if constexpr (is_big_int_v<T> && sizeof(T) == 32)
     {
-        return intHash64(static_cast<UInt64>(key) ^
+        return intHash64(
+            static_cast<UInt64>(key) ^
             static_cast<UInt64>(key >> 64) ^
             static_cast<UInt64>(key >> 128) ^
             static_cast<UInt64>(key >> 256));
     }
-
     assert(false);
     __builtin_unreachable();
 }
 
+
 template <typename T, typename Enable = void>
 struct DefaultHash;
 
@@ -213,7 +215,7 @@ struct DefaultHash<T, std::enable_if_t<DB::IsDecimalNumber<T>>>
 {
     size_t operator() (T key) const
     {
-        return DefaultHash64<typename T::NativeType>(key);
+        return DefaultHash64<typename T::NativeType>(key.value);
     }
 };
 
@@ -261,15 +263,98 @@ DEFINE_HASH(DB::Int128)
 DEFINE_HASH(DB::Int256)
 DEFINE_HASH(DB::Float32)
 DEFINE_HASH(DB::Float64)
+DEFINE_HASH(DB::UUID)
 
 #undef DEFINE_HASH
 
 
-template <>
-struct DefaultHash<DB::UInt128> : public DB::UInt128Hash {};
+struct UInt128Hash
+{
+    size_t operator()(UInt128 x) const
+    {
+        return CityHash_v1_0_2::Hash128to64({x.items[0], x.items[1]});
+    }
+};
+
+struct UUIDHash
+{
+    size_t operator()(DB::UUID x) const
+    {
+        return UInt128Hash()(x.toUnderType());
+    }
+};
+
+#ifdef __SSE4_2__
+
+struct UInt128HashCRC32
+{
+    size_t operator()(UInt128 x) const
+    {
+        UInt64 crc = -1ULL;
+        crc = _mm_crc32_u64(crc, x.items[0]);
+        crc = _mm_crc32_u64(crc, x.items[1]);
+        return crc;
+    }
+};
+
+#else
+
+/// On other platforms we do not use CRC32. NOTE This can be confusing.
+struct UInt128HashCRC32 : public UInt128Hash {};
+
+#endif
+
+struct UInt128TrivialHash
+{
+    size_t operator()(UInt128 x) const { return x.items[0]; }
+};
+
+struct UUIDTrivialHash
+{
+    size_t operator()(DB::UUID x) const { return x.toUnderType().items[0]; }
+};
+
+struct UInt256Hash
+{
+    size_t operator()(UInt256 x) const
+    {
+        /// NOTE suboptimal
+        return CityHash_v1_0_2::Hash128to64({
+            CityHash_v1_0_2::Hash128to64({x.items[0], x.items[1]}),
+            CityHash_v1_0_2::Hash128to64({x.items[2], x.items[3]})});
+    }
+};
+
+#ifdef __SSE4_2__
+
+struct UInt256HashCRC32
+{
+    size_t operator()(UInt256 x) const
+    {
+        UInt64 crc = -1ULL;
+        crc = _mm_crc32_u64(crc, x.items[0]);
+        crc = _mm_crc32_u64(crc, x.items[1]);
+        crc = _mm_crc32_u64(crc, x.items[2]);
+        crc = _mm_crc32_u64(crc, x.items[3]);
+        return crc;
+    }
+};
+
+#else
+
+/// We do not need to use CRC32 on other platforms. NOTE This can be confusing.
+struct UInt256HashCRC32 : public UInt256Hash {};
+
+#endif
 
 template <>
-struct DefaultHash<DB::DummyUInt256> : public DB::UInt256Hash {};
+struct DefaultHash<DB::UInt128> : public UInt128Hash {};
+
+template <>
+struct DefaultHash<DB::UInt256> : public UInt256Hash {};
+
+template <>
+struct DefaultHash<DB::UUID> : public UUIDHash {};
 
 
 /// It is reasonable to use for UInt8, UInt16 with sufficient hash table size.
@@ -322,23 +407,18 @@ struct IntHash32
 {
     size_t operator() (const T & key) const
     {
-        if constexpr (std::is_same_v<T, DB::Int128>)
+        if constexpr (is_big_int_v<T> && sizeof(T) == 16)
         {
-            return intHash32<salt>(static_cast<UInt64>(key) ^ static_cast<UInt64>(key >> 64));
-        }
-        else if constexpr (std::is_same_v<T, DB::UInt128>)
-        {
-            return intHash32<salt>(key.low ^ key.high);
+            return intHash32<salt>(key.items[0] ^ key.items[1]);
         }
         else if constexpr (is_big_int_v<T> && sizeof(T) == 32)
         {
-            return intHash32<salt>(static_cast<UInt64>(key) ^
-                static_cast<UInt64>(key >> 64) ^
-                static_cast<UInt64>(key >> 128) ^
-                static_cast<UInt64>(key >> 256));
+            return intHash32<salt>(key.items[0] ^ key.items[1] ^ key.items[2] ^ key.items[3]);
         }
         else if constexpr (sizeof(T) <= sizeof(UInt64))
+        {
             return intHash32<salt>(key);
+        }
 
         assert(false);
         __builtin_unreachable();
diff --git a/src/Common/HashTable/HashSet.h b/src/Common/HashTable/HashSet.h
index 19dba189ddc..d06fc761362 100644
--- a/src/Common/HashTable/HashSet.h
+++ b/src/Common/HashTable/HashSet.h
@@ -73,8 +73,8 @@ struct HashSetCellWithSavedHash : public HashTableCell<Key, Hash, TState>
 
     size_t saved_hash;
 
-    HashSetCellWithSavedHash() : Base() {}
-    HashSetCellWithSavedHash(const Key & key_, const typename Base::State & state) : Base(key_, state) {}
+    HashSetCellWithSavedHash() : Base() {} //-V730
+    HashSetCellWithSavedHash(const Key & key_, const typename Base::State & state) : Base(key_, state) {} //-V730
 
     bool keyEquals(const Key & key_) const { return bitEquals(this->key, key_); }
     bool keyEquals(const Key & key_, size_t hash_) const { return saved_hash == hash_ && bitEquals(this->key, key_); }
diff --git a/src/Common/HashTable/HashTable.h b/src/Common/HashTable/HashTable.h
index 0f394db5938..e25b3191652 100644
--- a/src/Common/HashTable/HashTable.h
+++ b/src/Common/HashTable/HashTable.h
@@ -70,10 +70,10 @@ namespace ZeroTraits
 {
 
 template <typename T>
-bool check(const T x) { return x == 0; }
+bool check(const T x) { return x == T{}; }
 
 template <typename T>
-void set(T & x) { x = 0; }
+void set(T & x) { x = {}; }
 
 }
 
@@ -305,7 +305,7 @@ template <bool need_zero_value_storage, typename Cell>
 struct ZeroValueStorage;
 
 template <typename Cell>
-struct ZeroValueStorage<true, Cell>
+struct ZeroValueStorage<true, Cell> //-V730
 {
 private:
     bool has_zero = false;
diff --git a/src/Common/HashTable/SmallTable.h b/src/Common/HashTable/SmallTable.h
index 25f29ae869e..895d2adc83e 100644
--- a/src/Common/HashTable/SmallTable.h
+++ b/src/Common/HashTable/SmallTable.h
@@ -80,7 +80,7 @@ public:
     {
     public:
         Reader(DB::ReadBuffer & in_)
-        : in(in_)
+            : in(in_)
         {
         }
 
@@ -124,15 +124,15 @@ public:
         DB::ReadBuffer & in;
         Cell cell;
         size_t read_count = 0;
-        size_t size;
+        size_t size = 0;
         bool is_eof = false;
         bool is_initialized = false;
     };
 
     class iterator
     {
-        Self * container;
-        Cell * ptr;
+        Self * container = nullptr;
+        Cell * ptr = nullptr;
 
         friend class SmallTable;
 
@@ -158,8 +158,8 @@ public:
 
     class const_iterator
     {
-        const Self * container;
-        const Cell * ptr;
+        const Self * container = nullptr;
+        const Cell * ptr = nullptr;
 
         friend class SmallTable;
 
@@ -184,16 +184,16 @@ public:
     };
 
 
-    const_iterator begin() const     { return iteratorTo(buf); }
-    iterator begin()                 { return iteratorTo(buf); }
+    const_iterator begin() const { return iteratorTo(buf); }
+    iterator begin()             { return iteratorTo(buf); }
 
-    const_iterator end() const         { return iteratorTo(buf + m_size); }
-    iterator end()                     { return iteratorTo(buf + m_size); }
+    const_iterator end() const   { return iteratorTo(buf + m_size); }
+    iterator end()               { return iteratorTo(buf + m_size); }
 
 
 protected:
-    const_iterator iteratorTo(const Cell * ptr) const     { return const_iterator(this, ptr); }
-    iterator iteratorTo(Cell * ptr)                     { return iterator(this, ptr); }
+    const_iterator iteratorTo(const Cell * ptr) const { return const_iterator(this, ptr); }
+    iterator iteratorTo(Cell * ptr)                   { return iterator(this, ptr); }
 
 
 public:
diff --git a/src/Common/HashTable/StringHashMap.h b/src/Common/HashTable/StringHashMap.h
index fe4eab16092..298580dc837 100644
--- a/src/Common/HashTable/StringHashMap.h
+++ b/src/Common/HashTable/StringHashMap.h
@@ -28,9 +28,8 @@ struct StringHashMapCell<StringKey16, TMapped> : public HashMapCell<StringKey16,
 
     // Zero means unoccupied cells in hash table. Use key with last word = 0 as
     // zero keys, because such keys are unrepresentable (no way to encode length).
-    static bool isZero(const StringKey16 & key, const HashTableNoState &)
-    { return key.high == 0; }
-    void setZero() { this->value.first.high = 0; }
+    static bool isZero(const StringKey16 & key, const HashTableNoState &) { return key.items[1] == 0; }
+    void setZero() { this->value.first.items[1] = 0; }
 
     // external
     const StringRef getKey() const { return toStringRef(this->value.first); }
diff --git a/src/Common/HashTable/StringHashSet.h b/src/Common/HashTable/StringHashSet.h
index 8714a0e1fe4..0466dca3574 100644
--- a/src/Common/HashTable/StringHashSet.h
+++ b/src/Common/HashTable/StringHashSet.h
@@ -33,8 +33,8 @@ struct StringHashSetCell<StringKey16> : public HashTableCell<StringKey16, String
     // Zero means unoccupied cells in hash table. Use key with last word = 0 as
     // zero keys, because such keys are unrepresentable (no way to encode length).
     static bool isZero(const StringKey16 & key_, const HashTableNoState &)
-    { return key_.high == 0; }
-    void setZero() { this->key.high = 0; }
+    { return key_.items[1] == 0; }
+    void setZero() { this->key.items[1] = 0; }
 };
 
 template <>
diff --git a/src/Common/HashTable/StringHashTable.h b/src/Common/HashTable/StringHashTable.h
index 9f91de5585b..b05d119e0e9 100644
--- a/src/Common/HashTable/StringHashTable.h
+++ b/src/Common/HashTable/StringHashTable.h
@@ -25,8 +25,8 @@ inline StringRef ALWAYS_INLINE toStringRef(const StringKey8 & n)
 }
 inline StringRef ALWAYS_INLINE toStringRef(const StringKey16 & n)
 {
-    assert(n.high != 0);
-    return {reinterpret_cast<const char *>(&n), 16ul - (__builtin_clzll(n.high) >> 3)};
+    assert(n.items[1] != 0);
+    return {reinterpret_cast<const char *>(&n), 16ul - (__builtin_clzll(n.items[1]) >> 3)};
 }
 inline StringRef ALWAYS_INLINE toStringRef(const StringKey24 & n)
 {
@@ -46,8 +46,8 @@ struct StringHashTableHash
     size_t ALWAYS_INLINE operator()(StringKey16 key) const
     {
         size_t res = -1ULL;
-        res = _mm_crc32_u64(res, key.low);
-        res = _mm_crc32_u64(res, key.high);
+        res = _mm_crc32_u64(res, key.items[0]);
+        res = _mm_crc32_u64(res, key.items[1]);
         return res;
     }
     size_t ALWAYS_INLINE operator()(StringKey24 key) const
@@ -79,7 +79,7 @@ struct StringHashTableHash
 };
 
 template <typename Cell>
-struct StringHashTableEmpty
+struct StringHashTableEmpty //-V730
 {
     using Self = StringHashTableEmpty;
 
diff --git a/src/Common/HashTable/TwoLevelHashTable.h b/src/Common/HashTable/TwoLevelHashTable.h
index 7eabb5fa138..14afb91c071 100644
--- a/src/Common/HashTable/TwoLevelHashTable.h
+++ b/src/Common/HashTable/TwoLevelHashTable.h
@@ -119,9 +119,9 @@ public:
 
     class iterator
     {
-        Self * container;
-        size_t bucket;
-        typename Impl::iterator current_it;
+        Self * container{};
+        size_t bucket{};
+        typename Impl::iterator current_it{};
 
         friend class TwoLevelHashTable;
 
@@ -156,9 +156,9 @@ public:
 
     class const_iterator
     {
-        Self * container;
-        size_t bucket;
-        typename Impl::const_iterator current_it;
+        Self * container{};
+        size_t bucket{};
+        typename Impl::const_iterator current_it{};
 
         friend class TwoLevelHashTable;
 
diff --git a/src/Common/HyperLogLogCounter.h b/src/Common/HyperLogLogCounter.h
index 0acffaaaf33..1cb014a050a 100644
--- a/src/Common/HyperLogLogCounter.h
+++ b/src/Common/HyperLogLogCounter.h
@@ -80,10 +80,7 @@ template <UInt64 MaxValue> struct MinCounterType
 /// Denominator of expression for HyperLogLog algorithm.
 template <UInt8 precision, int max_rank, typename HashValueType, typename DenominatorType,
     DenominatorMode denominator_mode, typename Enable = void>
-class __attribute__ ((packed)) Denominator;
-
-namespace
-{
+class Denominator;
 
 /// Returns true if rank storage is big.
 constexpr bool isBigRankStore(UInt8 precision)
@@ -91,8 +88,6 @@ constexpr bool isBigRankStore(UInt8 precision)
     return precision >= 12;
 }
 
-}
-
 /// Used to deduce denominator type depending on options provided.
 template <typename HashValueType, typename DenominatorType, DenominatorMode denominator_mode, typename Enable = void>
 struct IntermediateDenominator;
@@ -120,7 +115,7 @@ struct IntermediateDenominator<HashValueType, DenominatorType, DenominatorMode::
 /// Satisfiable when rank storage is small enough.
 template <UInt8 precision, int max_rank, typename HashValueType, typename DenominatorType,
     DenominatorMode denominator_mode>
-class __attribute__ ((packed)) Denominator<precision, max_rank, HashValueType, DenominatorType,
+class __attribute__((__packed__)) Denominator<precision, max_rank, HashValueType, DenominatorType,
     denominator_mode,
     std::enable_if_t<!details::isBigRankStore(precision) || !(denominator_mode == DenominatorMode::StableIfBig)>>
 {
@@ -164,7 +159,7 @@ private:
 /// Used when rank storage is big.
 template <UInt8 precision, int max_rank, typename HashValueType, typename DenominatorType,
     DenominatorMode denominator_mode>
-class __attribute__ ((packed)) Denominator<precision, max_rank, HashValueType, DenominatorType,
+class __attribute__((__packed__)) Denominator<precision, max_rank, HashValueType, DenominatorType,
     denominator_mode,
     std::enable_if_t<details::isBigRankStore(precision) && denominator_mode == DenominatorMode::StableIfBig>>
 {
@@ -252,6 +247,7 @@ struct RankWidth<UInt64>
 
 }
 
+
 /// Sets behavior of HyperLogLog class.
 enum class HyperLogLogMode
 {
diff --git a/src/Common/LRUCache.h b/src/Common/LRUCache.h
index 012ab7fe6c4..10533a154d1 100644
--- a/src/Common/LRUCache.h
+++ b/src/Common/LRUCache.h
@@ -145,6 +145,11 @@ public:
         return cells.size();
     }
 
+    size_t maxSize() const
+    {
+        return max_size;
+    }
+
     void reset()
     {
         std::lock_guard lock(mutex);
diff --git a/src/Common/MemoryTracker.cpp b/src/Common/MemoryTracker.cpp
index 60fb4d06b14..e4c4e0b0ab1 100644
--- a/src/Common/MemoryTracker.cpp
+++ b/src/Common/MemoryTracker.cpp
@@ -6,12 +6,14 @@
 #include <Common/formatReadable.h>
 #include <common/logger_useful.h>
 #include <Common/ProfileEvents.h>
+#include <Common/thread_local_rng.h>
 
 #include <atomic>
 #include <cmath>
 #include <random>
 #include <cstdlib>
 
+
 #ifdef MEMORY_TRACKER_DEBUG_CHECKS
 thread_local bool _memory_tracker_always_throw_logical_error_on_allocation = false;
 #endif
diff --git a/src/Common/MemoryTracker.h b/src/Common/MemoryTracker.h
index 9475b555975..4dada6f4ef7 100644
--- a/src/Common/MemoryTracker.h
+++ b/src/Common/MemoryTracker.h
@@ -208,7 +208,7 @@ public:
 
         static bool isBlocked(VariableContext current_level, bool fault_injection)
         {
-            return counter > 0 && current_level >= level && (!fault_injection || (fault_injection && block_fault_injections));
+            return counter > 0 && current_level >= level && (!fault_injection || block_fault_injections);
         }
     };
 };
diff --git a/src/Common/OpenTelemetryTraceContext.h b/src/Common/OpenTelemetryTraceContext.h
index 56503c16a00..9f2b5af9105 100644
--- a/src/Common/OpenTelemetryTraceContext.h
+++ b/src/Common/OpenTelemetryTraceContext.h
@@ -6,12 +6,12 @@ namespace DB
 // The runtime info we need to create new OpenTelemetry spans.
 struct OpenTelemetryTraceContext
 {
-    __uint128_t trace_id = 0;
+    UUID trace_id{};
     UInt64 span_id = 0;
     // The incoming tracestate header and the trace flags, we just pass them
     // downstream. See https://www.w3.org/TR/trace-context/
     String tracestate;
-    uint8_t trace_flags = 0;
+    UInt8 trace_flags = 0;
 
     // Parse/compose OpenTelemetry traceparent header.
     bool parseTraceparentHeader(const std::string & traceparent, std::string & error);
diff --git a/src/Common/PODArray.h b/src/Common/PODArray.h
index b1042332cfa..8f6414b3fa9 100644
--- a/src/Common/PODArray.h
+++ b/src/Common/PODArray.h
@@ -260,22 +260,12 @@ public:
     template <typename ... TAllocatorParams>
     void push_back_raw(const void * ptr, TAllocatorParams &&... allocator_params)
     {
-        push_back_raw_many(1, ptr, std::forward<TAllocatorParams>(allocator_params)...);
-    }
-
-    template <typename ... TAllocatorParams>
-    void push_back_raw_many(size_t number_of_items, const void * ptr, TAllocatorParams &&... allocator_params)
-    {
-        size_t required_capacity = size() + number_of_items;
+        size_t required_capacity = size() + ELEMENT_SIZE;
         if (unlikely(required_capacity > capacity()))
             reserve(required_capacity, std::forward<TAllocatorParams>(allocator_params)...);
 
-        size_t items_byte_size = byte_size(number_of_items);
-        if (items_byte_size)
-        {
-            memcpy(c_end, ptr, items_byte_size);
-            c_end += items_byte_size;
-        }
+        memcpy(c_end, ptr, ELEMENT_SIZE);
+        c_end += ELEMENT_SIZE;
     }
 
     void protect()
diff --git a/src/Common/PoolWithFailoverBase.h b/src/Common/PoolWithFailoverBase.h
index 141ac7a7e49..78d45a93b13 100644
--- a/src/Common/PoolWithFailoverBase.h
+++ b/src/Common/PoolWithFailoverBase.h
@@ -388,7 +388,7 @@ void PoolWithFailoverBase<TNestedPool>::updateErrorCounts(PoolWithFailoverBase<T
 {
     time_t current_time = time(nullptr);
 
-    if (last_decrease_time)
+    if (last_decrease_time) //-V1051
     {
         time_t delta = current_time - last_decrease_time;
 
diff --git a/src/Common/SharedBlockRowRef.h b/src/Common/SharedBlockRowRef.h
index 193f7e4dd05..46c35c6ac47 100644
--- a/src/Common/SharedBlockRowRef.h
+++ b/src/Common/SharedBlockRowRef.h
@@ -44,7 +44,7 @@ using SharedBlockPtr = boost::intrusive_ptr<detail::SharedBlock>;
 struct SharedBlockRowRef
 {
     ColumnRawPtrs * columns = nullptr;
-    size_t row_num;
+    size_t row_num = 0;
     SharedBlockPtr shared_block;
 
     void swap(SharedBlockRowRef & other)
diff --git a/src/Common/SipHash.h b/src/Common/SipHash.h
index ce7e80a7204..92d635eb63c 100644
--- a/src/Common/SipHash.h
+++ b/src/Common/SipHash.h
@@ -155,7 +155,6 @@ public:
         unalignedStore<UInt64>(out + 8, v2 ^ v3);
     }
 
-    /// template for avoiding 'unsigned long long' vs 'unsigned long' problem on old poco in macos
     template <typename T>
     ALWAYS_INLINE void get128(T & lo, T & hi)
     {
@@ -165,6 +164,13 @@ public:
         hi = v2 ^ v3;
     }
 
+    template <typename T>
+    ALWAYS_INLINE void get128(T & dst)
+    {
+        static_assert(sizeof(T) == 16);
+        get128(reinterpret_cast<char *>(&dst));
+    }
+
     UInt64 get64()
     {
         finalize();
diff --git a/src/Common/SpaceSaving.h b/src/Common/SpaceSaving.h
index 7ad48a6cf87..b7353d803b7 100644
--- a/src/Common/SpaceSaving.h
+++ b/src/Common/SpaceSaving.h
@@ -6,7 +6,6 @@
 #include <boost/range/adaptor/reversed.hpp>
 
 #include <Common/ArenaWithFreeLists.h>
-#include <Common/UInt128.h>
 #include <Common/HashTable/Hash.h>
 #include <Common/HashTable/HashMap.h>
 
diff --git a/src/Common/ThreadStatus.h b/src/Common/ThreadStatus.h
index 3b39e462fa6..6fc43114621 100644
--- a/src/Common/ThreadStatus.h
+++ b/src/Common/ThreadStatus.h
@@ -71,7 +71,7 @@ public:
     LogsLevel client_logs_level = LogsLevel::none;
 
     String query;
-    UInt64 normalized_query_hash;
+    UInt64 normalized_query_hash = 0;
 };
 
 using ThreadGroupStatusPtr = std::shared_ptr<ThreadGroupStatus>;
diff --git a/src/Common/TraceCollector.cpp b/src/Common/TraceCollector.cpp
index ab1845ebbd2..3cb4e5615c8 100644
--- a/src/Common/TraceCollector.cpp
+++ b/src/Common/TraceCollector.cpp
@@ -24,7 +24,10 @@ namespace
     /// Thus upper bound on query_id length should be introduced to avoid buffer overflow in signal handler.
     ///
     /// And it cannot be large, since otherwise it will not fit into PIPE_BUF.
-    constexpr size_t QUERY_ID_MAX_LEN = sizeof("00000000-0000-0000-0000-000000000000") - 1; // 36
+    /// The performance test query ids can be surprisingly long like
+    /// `aggregating_merge_tree_simple_aggregate_function_string.query100.profile100`,
+    /// so make some allowance for them as well.
+    constexpr size_t QUERY_ID_MAX_LEN = 128;
 }
 
 LazyPipeFDs pipe;
diff --git a/src/Common/UInt128.h b/src/Common/UInt128.h
deleted file mode 100644
index be96f409673..00000000000
--- a/src/Common/UInt128.h
+++ /dev/null
@@ -1,292 +0,0 @@
-#pragma once
-
-#include <tuple>
-#include <iomanip>
-#include <city.h>
-
-#include <Core/Types.h>
-#include <Common/hex.h>
-
-#ifdef __SSE4_2__
-#include <nmmintrin.h>
-#endif
-
-
-namespace DB
-{
-
-/// For aggregation by SipHash, UUID type or concatenation of several fields.
-struct UInt128
-{
-/// Suppress gcc7 warnings: 'prev_key.DB::UInt128::low' may be used uninitialized in this function
-#if !defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
-#endif
-
-    /// This naming assumes little endian.
-    UInt64 low;
-    UInt64 high;
-
-    /// TODO: Make this constexpr. Currently it is used in unions
-    /// and union cannot contain member with non trivial constructor
-    /// constructor must be non user provided but compiler cannot constexpr constructor
-    /// if members low and high are not initialized, if we default member initialize them
-    /// constructor becomes non trivial.
-    UInt128() = default;
-    explicit constexpr UInt128(const UInt64 low_, const UInt64 high_) : low(low_), high(high_) { }
-
-    /// We need Int128 to UInt128 conversion or AccurateComparison will call greaterOp<Int128, UInt64> instead of greaterOp<Int128, UInt128>
-    explicit constexpr UInt128(const Int128 rhs) : low(rhs), high(rhs >> 64) {}
-    explicit constexpr UInt128(const Int64 rhs) : low(rhs), high() {}
-    explicit constexpr UInt128(const Int32 rhs) : low(rhs), high() {}
-    explicit constexpr UInt128(const Int16 rhs) : low(rhs), high() {}
-    explicit constexpr UInt128(const Int8 rhs) : low(rhs), high() {}
-    explicit constexpr UInt128(const UInt8 rhs) : low(rhs), high() {}
-    explicit constexpr UInt128(const UInt16 rhs) : low(rhs), high() {}
-    explicit constexpr UInt128(const UInt32 rhs) : low(rhs), high() {}
-    explicit constexpr UInt128(const UInt64 rhs) : low(rhs), high() {}
-    explicit constexpr UInt128(const Float32 rhs) : low(rhs), high() {}
-    explicit constexpr UInt128(const Float64 rhs) : low(rhs), high() {}
-
-    constexpr auto tuple() const { return std::tie(high, low); }
-
-    String toHexString() const
-    {
-        String res(2 * sizeof(UInt128), 0);
-        writeHexUIntLowercase(*this, res.data());
-        return res;
-    }
-
-    constexpr bool operator== (const UInt128 rhs) const { return tuple() == rhs.tuple(); }
-    constexpr bool operator!= (const UInt128 rhs) const { return tuple() != rhs.tuple(); }
-    constexpr bool operator<  (const UInt128 rhs) const { return tuple() < rhs.tuple(); }
-    constexpr bool operator<= (const UInt128 rhs) const { return tuple() <= rhs.tuple(); }
-    constexpr bool operator>  (const UInt128 rhs) const { return tuple() > rhs.tuple(); }
-    constexpr bool operator>= (const UInt128 rhs) const { return tuple() >= rhs.tuple(); }
-
-    constexpr bool operator == (const Int128 rhs) const { return *this == UInt128(rhs, rhs >> 64) && rhs >= 0; }
-    constexpr bool operator != (const Int128 rhs) const { return *this != UInt128(rhs, rhs >> 64) || rhs < 0; }
-    constexpr bool operator >= (const Int128 rhs) const { return *this >= UInt128(rhs, rhs >> 64) || rhs < 0; }
-    constexpr bool operator >  (const Int128 rhs) const { return *this >  UInt128(rhs, rhs >> 64) || rhs < 0; }
-    constexpr bool operator <= (const Int128 rhs) const { return *this <= UInt128(rhs, rhs >> 64) && rhs >= 0; }
-    constexpr bool operator <  (const Int128 rhs) const { return *this <  UInt128(rhs, rhs >> 64) && rhs >= 0; }
-
-    constexpr bool operator >  (const Int256 rhs) const { return (rhs < 0) || ((Int256(high) << 64) + low) > rhs; }
-    constexpr bool operator >  (const UInt256 rhs) const { return ((UInt256(high) << 64) + low) > rhs; }
-    constexpr bool operator <  (const Int256 rhs) const { return (rhs >= 0) && ((Int256(high) << 64) + low) < rhs; }
-    constexpr bool operator <  (const UInt256 rhs) const { return ((UInt256(high) << 64) + low) < rhs; }
-
-    template <typename T> constexpr bool operator== (const T rhs) const { return *this == UInt128(rhs); }
-    template <typename T> constexpr bool operator!= (const T rhs) const { return *this != UInt128(rhs); }
-    template <typename T> constexpr bool operator>= (const T rhs) const { return *this >= UInt128(rhs); }
-    template <typename T> constexpr bool operator>  (const T rhs) const { return *this >  UInt128(rhs); }
-    template <typename T> constexpr bool operator<= (const T rhs) const { return *this <= UInt128(rhs); }
-    template <typename T> constexpr bool operator<  (const T rhs) const { return *this <  UInt128(rhs); }
-
-    template <typename T> explicit operator T() const
-    {
-        if constexpr (std::is_class_v<T>)
-            return T();
-        else
-            return static_cast<T>(low);
-    }
-
-#if !defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-
-    constexpr UInt128 & operator= (const UInt64 rhs) { low = rhs; high = 0; return *this; }
-};
-
-template <typename T> constexpr bool operator == (T a, const UInt128 b) { return b.operator==(a); }
-template <typename T> constexpr bool operator != (T a, const UInt128 b) { return b.operator!=(a); }
-template <typename T> constexpr bool operator >= (T a, const UInt128 b) { return b <= a; }
-template <typename T> constexpr bool operator >  (T a, const UInt128 b) { return b < a; }
-template <typename T> constexpr bool operator <= (T a, const UInt128 b) { return b >= a; }
-template <typename T> constexpr bool operator <  (T a, const UInt128 b) { return b > a; }
-
-template <> inline constexpr bool IsNumber<UInt128> = true;
-template <> struct TypeName<UInt128> { static constexpr const char * get() { return "UInt128"; } };
-template <> struct TypeId<UInt128> { static constexpr const TypeIndex value = TypeIndex::UInt128; };
-
-struct UInt128Hash
-{
-    size_t operator()(UInt128 x) const
-    {
-        return CityHash_v1_0_2::Hash128to64({x.low, x.high});
-    }
-};
-
-#ifdef __SSE4_2__
-
-struct UInt128HashCRC32
-{
-    size_t operator()(UInt128 x) const
-    {
-        UInt64 crc = -1ULL;
-        crc = _mm_crc32_u64(crc, x.low);
-        crc = _mm_crc32_u64(crc, x.high);
-        return crc;
-    }
-};
-
-#else
-
-/// On other platforms we do not use CRC32. NOTE This can be confusing.
-struct UInt128HashCRC32 : public UInt128Hash {};
-
-#endif
-
-struct UInt128TrivialHash
-{
-    size_t operator()(UInt128 x) const { return x.low; }
-};
-
-
-/** Used for aggregation, for putting a large number of constant-length keys in a hash table.
-  */
-struct DummyUInt256
-{
-
-/// Suppress gcc7 warnings: 'prev_key.DB::UInt256::a' may be used uninitialized in this function
-#if !defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
-#endif
-
-    UInt64 a;
-    UInt64 b;
-    UInt64 c;
-    UInt64 d;
-
-    bool operator== (const DummyUInt256 rhs) const
-    {
-        return a == rhs.a && b == rhs.b && c == rhs.c && d == rhs.d;
-
-    /* So it's no better.
-        return 0xFFFF == _mm_movemask_epi8(_mm_and_si128(
-            _mm_cmpeq_epi8(
-                _mm_loadu_si128(reinterpret_cast<const __m128i *>(&a)),
-                _mm_loadu_si128(reinterpret_cast<const __m128i *>(&rhs.a))),
-            _mm_cmpeq_epi8(
-                _mm_loadu_si128(reinterpret_cast<const __m128i *>(&c)),
-                _mm_loadu_si128(reinterpret_cast<const __m128i *>(&rhs.c)))));*/
-    }
-
-    bool operator!= (const DummyUInt256 rhs) const { return !operator==(rhs); }
-
-    bool operator== (const UInt64 rhs) const { return a == rhs && b == 0 && c == 0 && d == 0; }
-    bool operator!= (const UInt64 rhs) const { return !operator==(rhs); }
-
-#if !defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-
-    DummyUInt256 & operator = (const UInt64 rhs) { a = rhs; b = 0; c = 0; d = 0; return *this; }
-};
-
-struct UInt256Hash
-{
-    size_t operator()(DummyUInt256 x) const
-    {
-        /// NOTE suboptimal
-        return CityHash_v1_0_2::Hash128to64({CityHash_v1_0_2::Hash128to64({x.a, x.b}), CityHash_v1_0_2::Hash128to64({x.c, x.d})});
-    }
-};
-
-#ifdef __SSE4_2__
-
-struct UInt256HashCRC32
-{
-    size_t operator()(DummyUInt256 x) const
-    {
-        UInt64 crc = -1ULL;
-        crc = _mm_crc32_u64(crc, x.a);
-        crc = _mm_crc32_u64(crc, x.b);
-        crc = _mm_crc32_u64(crc, x.c);
-        crc = _mm_crc32_u64(crc, x.d);
-        return crc;
-    }
-};
-
-#else
-
-/// We do not need to use CRC32 on other platforms. NOTE This can be confusing.
-struct UInt256HashCRC32 : public UInt256Hash {};
-
-#endif
-
-}
-
-template <> struct is_signed<DB::UInt128>
-{
-    static constexpr bool value = false;
-};
-
-template <> struct is_unsigned<DB::UInt128>
-{
-    static constexpr bool value = true;
-};
-
-template <> struct is_integer<DB::UInt128>
-{
-    static constexpr bool value = true;
-};
-
-// Operator +, -, /, *, % aren't implemented so it's not an arithmetic type
-template <> struct is_arithmetic<DB::UInt128>
-{
-    static constexpr bool value = false;
-};
-
-/// Overload hash for type casting
-namespace std
-{
-template <> struct hash<DB::UInt128>
-{
-    size_t operator()(const DB::UInt128 & u) const
-    {
-        return CityHash_v1_0_2::Hash128to64({u.low, u.high});
-    }
-};
-
-template<>
-class numeric_limits<DB::UInt128>
-{
-public:
-    static constexpr bool is_specialized = true;
-    static constexpr bool is_signed = ::is_signed<DB::UInt128>::value;
-    static constexpr bool is_integer = ::is_integer<DB::UInt128>::value;
-    static constexpr bool is_exact = true;
-    static constexpr bool has_infinity = false;
-    static constexpr bool has_quiet_NaN = false;
-    static constexpr bool has_signaling_NaN = false;
-    static constexpr std::float_denorm_style has_denorm = std::denorm_absent;
-    static constexpr bool has_denorm_loss = false;
-    static constexpr std::float_round_style round_style = std::round_toward_zero;
-    static constexpr bool is_iec559 = false;
-    static constexpr bool is_bounded = true;
-    static constexpr bool is_modulo = true;
-    static constexpr int digits = std::numeric_limits<UInt64>::digits * 2;
-    static constexpr int digits10 = digits * 0.30103 /*std::log10(2)*/;
-    static constexpr int max_digits10 = 0;
-    static constexpr int radix = 2;
-    static constexpr int min_exponent = 0;
-    static constexpr int min_exponent10 = 0;
-    static constexpr int max_exponent = 0;
-    static constexpr int max_exponent10 = 0;
-    static constexpr bool traps = true;
-    static constexpr bool tinyness_before = false;
-
-    static constexpr DB::UInt128 min() noexcept { return DB::UInt128(0, 0); }
-
-    static constexpr DB::UInt128 max() noexcept
-    {
-        return DB::UInt128(std::numeric_limits<UInt64>::max(), std::numeric_limits<UInt64>::max());
-    }
-
-    static constexpr DB::UInt128 lowest() noexcept { return min(); }
-};
-
-}
diff --git a/src/Common/Volnitsky.h b/src/Common/Volnitsky.h
index c674015fba9..13cef28ddcf 100644
--- a/src/Common/Volnitsky.h
+++ b/src/Common/Volnitsky.h
@@ -303,7 +303,7 @@ namespace VolnitskyTraits
                     {
                         /// ngram for Ul
                         chars.c0 = c0u;
-                        chars.c1 = c1l;
+                        chars.c1 = c1l; //-V1048
                         putNGramBase(n, offset);
                     }
 
diff --git a/src/Common/ZooKeeper/TestKeeper.cpp b/src/Common/ZooKeeper/TestKeeper.cpp
index 36c875fe325..49eb7ad764d 100644
--- a/src/Common/ZooKeeper/TestKeeper.cpp
+++ b/src/Common/ZooKeeper/TestKeeper.cpp
@@ -198,7 +198,7 @@ std::pair<ResponsePtr, Undo> TestKeeperCreateRequest::process(TestKeeper::Contai
         else
         {
             TestKeeper::Node created_node;
-            created_node.seq_num = 0;
+            created_node.seq_num = 0; //-V1048
             created_node.stat.czxid = zxid;
             created_node.stat.mzxid = zxid;
             created_node.stat.ctime = std::chrono::system_clock::now().time_since_epoch() / std::chrono::milliseconds(1);
@@ -271,7 +271,7 @@ std::pair<ResponsePtr, Undo> TestKeeperRemoveRequest::process(TestKeeper::Contai
         auto & parent = container.at(parentPath(path));
         --parent.stat.numChildren;
         ++parent.stat.cversion;
-        response.error = Error::ZOK;
+        response.error = Error::ZOK; //-V1048
 
         undo = [prev_node, &container, path = path]
         {
@@ -293,7 +293,7 @@ std::pair<ResponsePtr, Undo> TestKeeperExistsRequest::process(TestKeeper::Contai
     if (it != container.end())
     {
         response.stat = it->second.stat;
-        response.error = Error::ZOK;
+        response.error = Error::ZOK; //-V1048
     }
     else
     {
@@ -316,7 +316,7 @@ std::pair<ResponsePtr, Undo> TestKeeperGetRequest::process(TestKeeper::Container
     {
         response.stat = it->second.stat;
         response.data = it->second.data;
-        response.error = Error::ZOK;
+        response.error = Error::ZOK; //-V1048
     }
 
     return { std::make_shared<GetResponse>(response), {} };
@@ -343,7 +343,7 @@ std::pair<ResponsePtr, Undo> TestKeeperSetRequest::process(TestKeeper::Container
         it->second.data = data;
         ++container.at(parentPath(path)).stat.cversion;
         response.stat = it->second.stat;
-        response.error = Error::ZOK;
+        response.error = Error::ZOK; //-V1048
 
         undo = [prev_node, &container, path = path]
         {
@@ -387,7 +387,7 @@ std::pair<ResponsePtr, Undo> TestKeeperListRequest::process(TestKeeper::Containe
         }
 
         response.stat = it->second.stat;
-        response.error = Error::ZOK;
+        response.error = Error::ZOK; //-V1048
     }
 
     return { std::make_shared<ListResponse>(response), {} };
@@ -407,7 +407,7 @@ std::pair<ResponsePtr, Undo> TestKeeperCheckRequest::process(TestKeeper::Contain
     }
     else
     {
-        response.error = Error::ZOK;
+        response.error = Error::ZOK; //-V1048
     }
 
     return { std::make_shared<CheckResponse>(response), {} };
@@ -422,7 +422,7 @@ std::pair<ResponsePtr, Undo> TestKeeperMultiRequest::process(TestKeeper::Contain
     try
     {
         auto request_it = requests.begin();
-        response.error = Error::ZOK;
+        response.error = Error::ZOK; //-V1048
         while (request_it != requests.end())
         {
             const TestKeeperRequest & concrete_request = dynamic_cast<const TestKeeperRequest &>(**request_it);
diff --git a/src/Common/ZooKeeper/ZooKeeperCommon.h b/src/Common/ZooKeeper/ZooKeeperCommon.h
index dd95eaa6b67..2a317da2622 100644
--- a/src/Common/ZooKeeper/ZooKeeperCommon.h
+++ b/src/Common/ZooKeeper/ZooKeeperCommon.h
@@ -25,7 +25,7 @@ namespace Coordination
 struct ZooKeeperResponse : virtual Response
 {
     XID xid = 0;
-    int64_t zxid;
+    int64_t zxid = 0;
 
     virtual ~ZooKeeperResponse() override = default;
     virtual void readImpl(ReadBuffer &) = 0;
diff --git a/src/Common/config.h.in b/src/Common/config.h.in
index ee2bfe3df53..28a21ea7764 100644
--- a/src/Common/config.h.in
+++ b/src/Common/config.h.in
@@ -15,3 +15,4 @@
 #cmakedefine01 USE_GRPC
 #cmakedefine01 USE_STATS
 #cmakedefine01 CLICKHOUSE_SPLIT_BINARY
+#cmakedefine01 USE_DATASKETCHES
diff --git a/src/Common/examples/arena_with_free_lists.cpp b/src/Common/examples/arena_with_free_lists.cpp
index d02fadca794..207fcd7dba2 100644
--- a/src/Common/examples/arena_with_free_lists.cpp
+++ b/src/Common/examples/arena_with_free_lists.cpp
@@ -172,17 +172,17 @@ struct Dictionary
     {
         switch (attribute.type)
         {
-            case AttributeUnderlyingType::utUInt8: std::get<ContainerPtrType<UInt8>>(attribute.arrays)[idx] = value.get<UInt64>(); break;
-            case AttributeUnderlyingType::utUInt16: std::get<ContainerPtrType<UInt16>>(attribute.arrays)[idx] = value.get<UInt64>(); break;
-            case AttributeUnderlyingType::utUInt32: std::get<ContainerPtrType<UInt32>>(attribute.arrays)[idx] = value.get<UInt64>(); break;
-            case AttributeUnderlyingType::utUInt64: std::get<ContainerPtrType<UInt64>>(attribute.arrays)[idx] = value.get<UInt64>(); break;
-            case AttributeUnderlyingType::utInt8: std::get<ContainerPtrType<Int8>>(attribute.arrays)[idx] = value.get<Int64>(); break;
-            case AttributeUnderlyingType::utInt16: std::get<ContainerPtrType<Int16>>(attribute.arrays)[idx] = value.get<Int64>(); break;
-            case AttributeUnderlyingType::utInt32: std::get<ContainerPtrType<Int32>>(attribute.arrays)[idx] = value.get<Int64>(); break;
-            case AttributeUnderlyingType::utInt64: std::get<ContainerPtrType<Int64>>(attribute.arrays)[idx] = value.get<Int64>(); break;
-            case AttributeUnderlyingType::utFloat32: std::get<ContainerPtrType<Float32>>(attribute.arrays)[idx] = value.get<Float64>(); break;
-            case AttributeUnderlyingType::utFloat64: std::get<ContainerPtrType<Float64>>(attribute.arrays)[idx] = value.get<Float64>(); break;
-            case AttributeUnderlyingType::utString:
+            case AttributeUnderlyingType::UInt8: std::get<ContainerPtrType<UInt8>>(attribute.arrays)[idx] = value.get<UInt64>(); break;
+            case AttributeUnderlyingType::UInt16: std::get<ContainerPtrType<UInt16>>(attribute.arrays)[idx] = value.get<UInt64>(); break;
+            case AttributeUnderlyingType::UInt32: std::get<ContainerPtrType<UInt32>>(attribute.arrays)[idx] = value.get<UInt64>(); break;
+            case AttributeUnderlyingType::UInt64: std::get<ContainerPtrType<UInt64>>(attribute.arrays)[idx] = value.get<UInt64>(); break;
+            case AttributeUnderlyingType::Int8: std::get<ContainerPtrType<Int8>>(attribute.arrays)[idx] = value.get<Int64>(); break;
+            case AttributeUnderlyingType::Int16: std::get<ContainerPtrType<Int16>>(attribute.arrays)[idx] = value.get<Int64>(); break;
+            case AttributeUnderlyingType::Int32: std::get<ContainerPtrType<Int32>>(attribute.arrays)[idx] = value.get<Int64>(); break;
+            case AttributeUnderlyingType::Int64: std::get<ContainerPtrType<Int64>>(attribute.arrays)[idx] = value.get<Int64>(); break;
+            case AttributeUnderlyingType::Float32: std::get<ContainerPtrType<Float32>>(attribute.arrays)[idx] = value.get<Float64>(); break;
+            case AttributeUnderlyingType::Float64: std::get<ContainerPtrType<Float64>>(attribute.arrays)[idx] = value.get<Float64>(); break;
+            case AttributeUnderlyingType::String:
             {
                 const auto & string = value.get<String>();
                 auto & string_ref = std::get<ContainerPtrType<StringRef>>(attribute.arrays)[idx];
@@ -308,7 +308,7 @@ int main(int argc, char ** argv)
     constexpr size_t cache_size = 1024;
 
     Dictionary::Attribute attr;
-    attr.type = Dictionary::AttributeUnderlyingType::utString;
+    attr.type = Dictionary::AttributeUnderlyingType::String;
     std::get<Dictionary::ContainerPtrType<StringRef>>(attr.arrays).reset(new StringRef[cache_size]{});  // NOLINT
 
     while (true)
diff --git a/src/Common/filesystemHelpers.cpp b/src/Common/filesystemHelpers.cpp
index bfcb75235c0..835668dfa1c 100644
--- a/src/Common/filesystemHelpers.cpp
+++ b/src/Common/filesystemHelpers.cpp
@@ -81,7 +81,6 @@ std::filesystem::path getMountPoint(std::filesystem::path absolute_path)
         if (device_id != parent_device_id)
             return absolute_path;
         absolute_path = parent;
-        device_id = parent_device_id;
     }
 
     return absolute_path;
diff --git a/src/Common/getHashOfLoadedBinary.cpp b/src/Common/getHashOfLoadedBinary.cpp
index d401b0311be..dcf483b4fa8 100644
--- a/src/Common/getHashOfLoadedBinary.cpp
+++ b/src/Common/getHashOfLoadedBinary.cpp
@@ -38,7 +38,7 @@ std::string getHashOfLoadedBinaryHex()
 {
     SipHash hash = getHashOfLoadedBinary();
     std::array<UInt64, 2> checksum;
-    hash.get128(checksum[0], checksum[1]);
+    hash.get128(checksum);
     return getHexUIntUppercase(checksum);
 }
 
diff --git a/src/Common/intExp.h b/src/Common/intExp.h
index bc977a41d33..b2d704e58b2 100644
--- a/src/Common/intExp.h
+++ b/src/Common/intExp.h
@@ -138,9 +138,9 @@ constexpr inline Int128 exp10_i128(int x)
 }
 
 
-inline wInt256 exp10_i256(int x)
+inline Int256 exp10_i256(int x)
 {
-    using Int256 = wInt256;
+    using Int256 = Int256;
     static constexpr Int256 i10e18{1000000000000000000ll};
     static const Int256 values[] = {
         static_cast<Int256>(1ll),
diff --git a/src/Common/tests/gtest_hash_table.cpp b/src/Common/tests/gtest_hash_table.cpp
index 1c673166ca9..35fb471f07c 100644
--- a/src/Common/tests/gtest_hash_table.cpp
+++ b/src/Common/tests/gtest_hash_table.cpp
@@ -5,11 +5,17 @@
 
 #include <Common/HashTable/HashMap.h>
 #include <Common/HashTable/HashSet.h>
+#include <Common/HashTable/Hash.h>
 
 #include <IO/ReadBufferFromString.h>
+#include <IO/WriteHelpers.h>
 
 #include <gtest/gtest.h>
 
+
+using namespace DB;
+
+
 /// To test dump functionality without using other hashes that can change
 template <typename T>
 struct DummyHash
@@ -18,12 +24,12 @@ struct DummyHash
 };
 
 template<typename HashTable>
-std::set<typename HashTable::value_type> convertToSet(const HashTable& table)
+std::set<std::string> convertToSet(const HashTable & table)
 {
-    std::set<typename HashTable::value_type> result;
+    std::set<std::string> result;
 
     for (auto v: table)
-        result.emplace(v.getValue());
+        result.emplace(toString(v.getValue()));
 
     return result;
 }
@@ -91,8 +97,8 @@ TEST(HashTable, Iteration)
     cont.insert(2);
     cont.insert(3);
 
-    std::set<int> expected = {1, 2, 3};
-    std::set<int> actual = convertToSet(cont);
+    std::set<std::string> expected = {"1", "2", "3"};
+    std::set<std::string> actual = convertToSet(cont);
 
     ASSERT_EQ(actual, expected);
 }
@@ -251,14 +257,14 @@ TEST(HashTable, SerializationDeserialization)
         cont.insert(2);
         cont.insert(3);
 
-        DB::WriteBufferFromOwnString wb;
+        WriteBufferFromOwnString wb;
         cont.writeText(wb);
 
         std::string expected = "3,1,2,3";
 
         ASSERT_EQ(wb.str(), expected);
 
-        DB::ReadBufferFromString rb(expected);
+        ReadBufferFromString rb(expected);
 
         Cont deserialized;
         deserialized.readText(rb);
@@ -273,10 +279,10 @@ TEST(HashTable, SerializationDeserialization)
         cont.insert(2);
         cont.insert(3);
 
-        DB::WriteBufferFromOwnString wb;
+        WriteBufferFromOwnString wb;
         cont.write(wb);
 
-        DB::ReadBufferFromString rb(wb.str());
+        ReadBufferFromString rb(wb.str());
 
         Cont deserialized;
         deserialized.read(rb);
@@ -286,23 +292,23 @@ TEST(HashTable, SerializationDeserialization)
         using Cont = HashSet<int, DummyHash<int>, HashTableGrower<1>>;
         Cont cont;
 
-        DB::WriteBufferFromOwnString wb;
+        WriteBufferFromOwnString wb;
         cont.writeText(wb);
 
         std::string expected = "0";
         ASSERT_EQ(wb.str(), expected);
 
-        DB::ReadBufferFromString rb(expected);
+        ReadBufferFromString rb(expected);
 
         Cont deserialized;
         deserialized.readText(rb);
         ASSERT_EQ(convertToSet(cont), convertToSet(deserialized));
     }
     {
-        using Cont = HashSet<DB::UInt128, DB::UInt128TrivialHash>;
+        using Cont = HashSet<UInt128, UInt128TrivialHash>;
         Cont cont;
 
-        DB::WriteBufferFromOwnString wb;
+        WriteBufferFromOwnString wb;
         cont.write(wb);
 
         std::string expected;
@@ -310,7 +316,7 @@ TEST(HashTable, SerializationDeserialization)
 
         ASSERT_EQ(wb.str(), expected);
 
-        DB::ReadBufferFromString rb(expected);
+        ReadBufferFromString rb(expected);
 
         Cont deserialized;
         deserialized.read(rb);
@@ -359,8 +365,8 @@ TEST(HashTable, Resize)
         cont.insert(3);
         cont.insert(1);
 
-        std::set<int> expected = {1, 3};
-        std::set<int> actual = convertToSet(cont);
+        std::set<std::string> expected = {"1", "3"};
+        std::set<std::string> actual = convertToSet(cont);
 
         ASSERT_EQ(actual, expected);
     }
diff --git a/src/Common/tests/gtest_pod_array.cpp b/src/Common/tests/gtest_pod_array.cpp
index 2f41f641b09..74fbf447f29 100644
--- a/src/Common/tests/gtest_pod_array.cpp
+++ b/src/Common/tests/gtest_pod_array.cpp
@@ -459,18 +459,6 @@ TEST(Common, PODArrayInsertFromItself)
     }
 }
 
-TEST(Common, PODPushBackRawMany)
-{
-    PODArray<char> chars;
-    chars.push_back_raw_many(5, "first");
-    EXPECT_EQ(std::string("first"), std::string(chars.data(), chars.size()));
-    EXPECT_EQ(5, chars.size());
-    EXPECT_LE(chars.capacity() - chars.size(), 10);
-    chars.push_back_raw_many(10, "0123456789");
-    EXPECT_EQ(15, chars.size());
-    EXPECT_EQ(std::string("first0123456789"), std::string(chars.data(), chars.size()));
-}
-
 TEST(Common, PODNoOverallocation)
 {
     /// Check that PaddedPODArray allocates for smaller number of elements than the power of two due to padding.
diff --git a/src/Common/tests/gtest_wide_integer.cpp b/src/Common/tests/gtest_wide_integer.cpp
new file mode 100644
index 00000000000..982bbee804e
--- /dev/null
+++ b/src/Common/tests/gtest_wide_integer.cpp
@@ -0,0 +1,281 @@
+#include <gtest/gtest.h>
+
+#include <cstdint>
+#include <limits>
+#include <type_traits>
+#include <initializer_list>
+
+#include <Core/Types.h>
+#include <IO/WriteHelpers.h>
+#include <IO/ReadHelpers.h>
+#include <common/demangle.h>
+
+
+static_assert(is_signed_v<Int128>);
+static_assert(!is_unsigned_v<Int128>);
+static_assert(is_integer_v<Int128>);
+static_assert(sizeof(Int128) == 16);
+
+static_assert(is_signed_v<Int256>);
+static_assert(!is_unsigned_v<Int256>);
+static_assert(is_integer_v<Int256>);
+static_assert(sizeof(Int256) == 32);
+
+static_assert(!is_signed_v<UInt128>);
+static_assert(is_unsigned_v<UInt128>);
+static_assert(is_integer_v<UInt128>);
+static_assert(sizeof(UInt128) == 16);
+
+static_assert(!is_signed_v<UInt256>);
+static_assert(is_unsigned_v<UInt256>);
+static_assert(is_integer_v<UInt256>);
+static_assert(sizeof(UInt256) == 32);
+
+
+using namespace DB;
+
+
+GTEST_TEST(WideInteger, Conversions)
+{
+    ASSERT_EQ(toString(UInt128(12345678901234567890ULL)), "12345678901234567890");
+    ASSERT_EQ(toString(UInt256(12345678901234567890ULL)), "12345678901234567890");
+
+    Int128 minus_one = -1;
+    ASSERT_EQ(minus_one.items[0], -1);
+    ASSERT_EQ(minus_one.items[1], -1);
+
+    ASSERT_EQ(0, memcmp(&minus_one, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF", sizeof(minus_one)));
+
+    ASSERT_EQ(minus_one, -1);
+    ASSERT_EQ(minus_one, -1LL);
+    ASSERT_EQ(minus_one, Int8(-1));
+    ASSERT_EQ(minus_one, Int16(-1));
+    ASSERT_EQ(minus_one, Int32(-1));
+    ASSERT_EQ(minus_one, Int64(-1));
+
+    ASSERT_LT(minus_one, 0);
+
+    Int128 zero = 0;
+    zero += -1;
+    ASSERT_EQ(zero, -1);
+    ASSERT_EQ(zero, minus_one);
+
+    zero += minus_one;
+    ASSERT_EQ(0, memcmp(&zero, "\xFE\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF", sizeof(zero)));
+
+    zero += 2;
+    ASSERT_EQ(zero, 0);
+
+    ASSERT_EQ(toString(Int128(-1)), "-1");
+    ASSERT_EQ(toString(Int256(-1)), "-1");
+
+    ASSERT_EQ(toString(Int128(-1LL)), "-1");
+    ASSERT_EQ(toString(Int256(-1LL)), "-1");
+
+    ASSERT_EQ(toString(Int128(-1234567890123456789LL)), "-1234567890123456789");
+    ASSERT_EQ(toString(Int256(-1234567890123456789LL)), "-1234567890123456789");
+
+    ASSERT_EQ(UInt64(UInt128(12345678901234567890ULL)), 12345678901234567890ULL);
+    ASSERT_EQ(UInt64(UInt256(12345678901234567890ULL)), 12345678901234567890ULL);
+
+    ASSERT_EQ(__uint128_t(UInt128(12345678901234567890ULL)), 12345678901234567890ULL);
+    ASSERT_EQ(__uint128_t(UInt256(12345678901234567890ULL)), 12345678901234567890ULL);
+
+    ASSERT_EQ(__int128_t(Int128(-1234567890123456789LL)), -1234567890123456789LL);
+    ASSERT_EQ(__int128_t(Int256(-1234567890123456789LL)), -1234567890123456789LL);
+
+    ASSERT_EQ(toString(Int128(-1)), "-1");
+    ASSERT_EQ(toString(Int256(-1)), "-1");
+
+    ASSERT_EQ(toString(UInt128(123.456)), "123");
+    ASSERT_EQ(toString(UInt256(123.456)), "123");
+    ASSERT_EQ(toString(Int128(-123.456)), "-123");
+    ASSERT_EQ(toString(Int256(-123.456)), "-123");
+
+    ASSERT_EQ(toString(UInt128(123.456f)), "123");
+    ASSERT_EQ(toString(UInt256(123.456f)), "123");
+    ASSERT_EQ(toString(Int128(-123.456f)), "-123");
+    ASSERT_EQ(toString(Int256(-123.456f)), "-123");
+
+    ASSERT_EQ(toString(UInt128(1) * 1000000000 * 1000000000 * 1000000000 * 1000000000), "1000000000000000000000000000000000000");
+    ASSERT_EQ(Float64(UInt128(1) * 1000000000 * 1000000000 * 1000000000 * 1000000000), 1e36);
+
+    ASSERT_EQ(toString(UInt256(1) * 1000000000 * 1000000000 * 1000000000 * 1000000000 * 1000000000 * 1000000000 * 1000000000 * 1000000000),
+        "1000000000000000000000000000000000000000000000000000000000000000000000000");
+    ASSERT_EQ(Float64(UInt256(1) * 1000000000 * 1000000000 * 1000000000 * 1000000000 * 1000000000 * 1000000000 * 1000000000 * 1000000000), 1e72);
+
+    EXPECT_EQ(toString(parse<Int128>("148873535527910577765226390751398592640")), "148873535527910577765226390751398592640");
+    EXPECT_EQ(toString(parse<UInt128>("148873535527910577765226390751398592640")), "148873535527910577765226390751398592640");
+}
+
+
+template <typename T>
+static T divide(T & numerator, T && denominator)
+{
+    if (!denominator)
+        throwError("Division by zero");
+
+    T & n = numerator;
+    T & d = denominator;
+    T x = 1;
+    T quotient = 0;
+
+    /// Multiply d to the power of two until it will be greater than n.
+    /// The factor will be collected in x.
+    while (d <= n && ((d >> (sizeof(T) * 8 - 1)) & 1) == 0)
+    {
+        x <<= 1;
+        d <<= 1;
+    }
+
+    std::cerr << toString(x) << ", " << toString(d) << "\n";
+
+    while (x)
+    {
+        if (d <= n)
+        {
+            n -= d;
+            quotient |= x;
+        }
+
+        x >>= 1;
+        d >>= 1;
+    }
+
+    return quotient;
+}
+
+
+GTEST_TEST(WideInteger, Arithmetic)
+{
+    Int128 minus_one = -1;
+    Int128 zero = 0;
+
+    zero += -1;
+    ASSERT_EQ(zero, -1);
+    ASSERT_EQ(zero, minus_one);
+
+    zero += minus_one;
+    ASSERT_EQ(0, memcmp(&zero, "\xFE\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF", sizeof(zero)));
+
+    zero += 2;
+    ASSERT_EQ(zero, 0);
+
+    ASSERT_EQ(UInt256(12345678901234567890ULL) * 12345678901234567890ULL / 12345678901234567890ULL, 12345678901234567890ULL);
+    ASSERT_EQ(UInt256(12345678901234567890ULL) * UInt256(12345678901234567890ULL) / 12345678901234567890ULL, 12345678901234567890ULL);
+    ASSERT_EQ(UInt256(12345678901234567890ULL) * 12345678901234567890ULL / UInt256(12345678901234567890ULL), 12345678901234567890ULL);
+    ASSERT_EQ(UInt256(12345678901234567890ULL) * 12345678901234567890ULL / 12345678901234567890ULL, UInt256(12345678901234567890ULL));
+    ASSERT_EQ(UInt128(12345678901234567890ULL) * 12345678901234567890ULL / UInt128(12345678901234567890ULL), 12345678901234567890ULL);
+    ASSERT_EQ(UInt256(12345678901234567890ULL) * UInt128(12345678901234567890ULL) / 12345678901234567890ULL, 12345678901234567890ULL);
+
+    ASSERT_EQ(Int128(0) + Int32(-1), Int128(-1));
+
+    Int128 x(parse<Int128>("148873535527910577765226390751398592640"));
+    Int128 dividend = x / 10;
+    ASSERT_EQ(toString(dividend), "14887353552791057776522639075139859264");
+}
+
+
+GTEST_TEST(WideInteger, DecimalArithmetic)
+{
+    Decimal128 zero{};
+    Decimal32 addend = -1000;
+
+    zero += Decimal128(addend);
+    ASSERT_EQ(zero.value, -1000);
+
+    zero += addend;
+    ASSERT_EQ(zero.value, -2000);
+}
+
+
+GTEST_TEST(WideInteger, FromDouble)
+{
+    /// Check that we are being able to convert double to big integer without the help of floating point instructions.
+    /// (a prototype of a function that we may need)
+
+    double f = -123.456;
+    UInt64 u;
+    memcpy(&u, &f, sizeof(f));
+
+    bool is_negative = u >> 63;
+    uint16_t exponent = (u >> 52) & (((1ull << 12) - 1) >> 1);
+    int16_t normalized_exponent = exponent - 1023;
+    UInt64 mantissa = u & ((1ull << 52) - 1);
+
+    // std::cerr << is_negative << ", " << normalized_exponent << ", " << mantissa << "\n";
+
+    /// x = sign * (2 ^ normalized_exponent + mantissa * 2 ^ (normalized_exponent - mantissa_bits))
+
+    Int128 res = 0;
+
+    if (normalized_exponent >= 128)
+    {
+    }
+    else
+    {
+        res = mantissa;
+        if (normalized_exponent > 52)
+            res <<= (normalized_exponent - 52);
+        else
+            res >>= (52 - normalized_exponent);
+
+        if (normalized_exponent > 0)
+            res += Int128(1) << normalized_exponent;
+    }
+
+    if (is_negative)
+        res = -res;
+
+    ASSERT_EQ(toString(res), "-123");
+}
+
+
+GTEST_TEST(WideInteger, Shift)
+{
+    Int128 x = 1;
+
+    auto y = x << 64;
+    ASSERT_EQ(0, memcmp(&y, "\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00", sizeof(Int128)));
+
+    auto z = y << 11;
+    ASSERT_EQ(toString(z), "37778931862957161709568");
+
+    auto a = x << 11;
+    ASSERT_EQ(a, 2048);
+
+    z >>= 64;
+    ASSERT_EQ(z, a);
+
+    x = -1;
+    y = x << 16;
+
+    ASSERT_EQ(0, memcmp(&y, "\x00\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF", sizeof(Int128)));
+
+    y >>= 16;
+    ASSERT_EQ(0, memcmp(&y, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF", sizeof(Int128)));
+
+    y <<= 64;
+    ASSERT_EQ(0, memcmp(&y, "\x00\x00\x00\x00\x00\x00\x00\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF", sizeof(Int128)));
+
+    y >>= 32;
+    ASSERT_EQ(0, memcmp(&y, "\x00\x00\x00\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF", sizeof(Int128)));
+
+    y <<= 64;
+    ASSERT_EQ(0, memcmp(&y, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xFF\xFF\xFF\xFF", sizeof(Int128)));
+}
+
+
+GTEST_TEST(WideInteger, DecimalFormatting)
+{
+    Decimal128 x(parse<Int128>("148873535527910577765226390751398592640"));
+
+    EXPECT_EQ(toString(x.value), "148873535527910577765226390751398592640");
+    EXPECT_EQ(toString(x.value / 10), "14887353552791057776522639075139859264");
+    EXPECT_EQ(toString(x.value % 10), "0");
+
+    Int128 fractional = DecimalUtils::getFractionalPart(x, 2);
+
+    EXPECT_EQ(fractional, 40);
+    EXPECT_EQ(decimalFractional(fractional, 2), "40");
+}
diff --git a/src/Compression/getCompressionCodecForFile.cpp b/src/Compression/getCompressionCodecForFile.cpp
index 05dd49f3939..1557985ff66 100644
--- a/src/Compression/getCompressionCodecForFile.cpp
+++ b/src/Compression/getCompressionCodecForFile.cpp
@@ -6,8 +6,6 @@
 #include <Common/PODArray.h>
 #include <common/logger_useful.h>
 
-#include <Common/UInt128.h>
-
 namespace DB
 {
 
diff --git a/src/Compression/tests/gtest_compressionCodec.cpp b/src/Compression/tests/gtest_compressionCodec.cpp
index 0acd15e48c3..20fe5476807 100644
--- a/src/Compression/tests/gtest_compressionCodec.cpp
+++ b/src/Compression/tests/gtest_compressionCodec.cpp
@@ -35,29 +35,6 @@
 
 using namespace DB;
 
-namespace std
-{
-template <typename T>
-std::ostream & operator<<(std::ostream & ostr, const std::optional<T> & opt)
-{
-    if (!opt)
-    {
-        return ostr << "<empty optional>";
-    }
-
-    return ostr << *opt;
-}
-
-template <typename T>
-std::vector<T> operator+(std::vector<T> && left, std::vector<T> && right)
-{
-    std::vector<T> result(std::move(left));
-    std::move(std::begin(right), std::end(right), std::back_inserter(result));
-
-    return result;
-}
-
-}
 
 namespace
 {
@@ -337,6 +314,14 @@ CodecTestSequence operator+(CodecTestSequence && left, const CodecTestSequence &
     return left.append(right);
 }
 
+std::vector<CodecTestSequence> operator+(const std::vector<CodecTestSequence> & left, const std::vector<CodecTestSequence> & right)
+{
+    std::vector<CodecTestSequence> result(std::move(left));
+    std::move(std::begin(right), std::end(right), std::back_inserter(result));
+
+    return result;
+}
+
 template <typename T>
 CodecTestSequence operator*(CodecTestSequence && left, T times)
 {
@@ -362,7 +347,7 @@ std::ostream & operator<<(std::ostream & ostr, const Codec & codec)
 {
     return ostr << "Codec{"
                 << "name: " << codec.codec_statement
-                << ", expected_compression_ratio: " << codec.expected_compression_ratio
+                << ", expected_compression_ratio: " << *codec.expected_compression_ratio
                 << "}";
 }
 
@@ -775,15 +760,13 @@ auto FFand0Generator = []()
     return [step = 0](auto i) mutable
     {
         decltype(i) result;
-        if (step++ % 2 == 0)
-        {
-            memset(&result, 0, sizeof(result));
-        }
-        else
-        {
-            memset(&result, 0xFF, sizeof(result));
-        }
 
+        if (step % 2 == 0)
+            memset(&result, 0, sizeof(result));
+        else
+            memset(&result, 0xFF, sizeof(result));
+
+        ++step;
         return result;
     };
 };
@@ -1129,7 +1112,7 @@ template <typename ValueType>
 auto DDCompatibilityTestSequence()
 {
     // Generates sequences with double delta in given range.
-    auto dd_generator = [prev_delta = static_cast<Int64>(0), prev = static_cast<Int64>(0)](auto dd) mutable
+    auto dd_generator = [prev_delta = static_cast<Int64>(0), prev = static_cast<Int64>(0)](auto dd) mutable //-V788
     {
         const auto curr = dd + prev + prev_delta;
         prev = curr;
diff --git a/src/Coordination/Changelog.h b/src/Coordination/Changelog.h
index d669f56aded..a50b734c5b4 100644
--- a/src/Coordination/Changelog.h
+++ b/src/Coordination/Changelog.h
@@ -30,10 +30,10 @@ static constexpr auto CURRENT_CHANGELOG_VERSION = ChangelogVersion::V0;
 struct ChangelogRecordHeader
 {
     ChangelogVersion version = CURRENT_CHANGELOG_VERSION;
-    uint64_t index; /// entry log number
-    uint64_t term;
-    nuraft::log_val_type value_type;
-    uint64_t blob_size;
+    uint64_t index = 0; /// entry log number
+    uint64_t term = 0;
+    nuraft::log_val_type value_type{};
+    uint64_t blob_size = 0;
 };
 
 /// Changelog record on disk
diff --git a/src/Coordination/KeeperStorage.cpp b/src/Coordination/KeeperStorage.cpp
index 197cc4323cf..5f2d6141be9 100644
--- a/src/Coordination/KeeperStorage.cpp
+++ b/src/Coordination/KeeperStorage.cpp
@@ -103,7 +103,8 @@ struct KeeperStorageSyncRequest final : public KeeperStorageRequest
     std::pair<Coordination::ZooKeeperResponsePtr, Undo> process(KeeperStorage::Container & /* container */, KeeperStorage::Ephemerals & /* ephemerals */, int64_t /* zxid */, int64_t /* session_id */) const override
     {
         auto response = zk_request->makeResponse();
-        dynamic_cast<Coordination::ZooKeeperSyncResponse *>(response.get())->path = dynamic_cast<Coordination::ZooKeeperSyncRequest *>(zk_request.get())->path;
+        dynamic_cast<Coordination::ZooKeeperSyncResponse &>(*response).path
+            = dynamic_cast<Coordination::ZooKeeperSyncRequest &>(*zk_request).path;
         return {response, {}};
     }
 };
diff --git a/src/Coordination/tests/gtest_for_build.cpp b/src/Coordination/tests/gtest_for_build.cpp
index 515565a3b9f..a0313651c21 100644
--- a/src/Coordination/tests/gtest_for_build.cpp
+++ b/src/Coordination/tests/gtest_for_build.cpp
@@ -64,7 +64,7 @@ TEST(CoordinationTest, BufferSerde)
 {
     Coordination::ZooKeeperRequestPtr request = Coordination::ZooKeeperRequestFactory::instance().get(Coordination::OpNum::Get);
     request->xid = 3;
-    dynamic_cast<Coordination::ZooKeeperGetRequest *>(request.get())->path = "/path/value";
+    dynamic_cast<Coordination::ZooKeeperGetRequest &>(*request).path = "/path/value";
 
     DB::WriteBufferFromNuraftBuffer wbuf;
     request->write(wbuf);
@@ -90,7 +90,7 @@ TEST(CoordinationTest, BufferSerde)
 
     EXPECT_EQ(request_read->getOpNum(), Coordination::OpNum::Get);
     EXPECT_EQ(request_read->xid, 3);
-    EXPECT_EQ(dynamic_cast<Coordination::ZooKeeperGetRequest *>(request_read.get())->path, "/path/value");
+    EXPECT_EQ(dynamic_cast<Coordination::ZooKeeperGetRequest &>(*request_read).path, "/path/value");
 }
 
 template <typename StateMachine>
diff --git a/src/Core/AccurateComparison.h b/src/Core/AccurateComparison.h
index 1e45dbe23dc..29088cbf1b5 100644
--- a/src/Core/AccurateComparison.h
+++ b/src/Core/AccurateComparison.h
@@ -2,11 +2,11 @@
 
 #include <cmath>
 #include <limits>
-#include "Defines.h"
-#include "Types.h"
+#include <common/DecomposedFloat.h>
+#include <Core/Defines.h>
+#include <Core/Types.h>
 #include <common/extended_types.h>
 #include <Common/NaNUtils.h>
-#include <Common/UInt128.h>
 
 /** Preceptually-correct number comparisons.
   * Example: Int8(-1) != UInt8(255)
@@ -15,504 +15,142 @@
 namespace accurate
 {
 
-using DB::UInt64;
+using namespace DB;
 
-/** Cases:
-    1) Safe conversion (in case of default C++ operators)
-        a) int vs any int
-        b) uint vs any uint
-        c) float vs any float
-    2) int vs uint
-        a) sizeof(int) <= sizeof(uint). Accurate comparison with MAX_INT tresholds
-        b) sizeof(int)  > sizeof(uint). Casting to int
-    3) integral_type vs floating_type
-        a) sizeof(integral_type) <= 4. Comparison via casting arguments to Float64
-        b) sizeof(integral_type) == 8. Accurate comparison. Consider 3 sets of intervals:
-            1) interval between adjacent floats less or equal 1
-            2) interval between adjacent floats greater then 2
-            3) float is outside [MIN_INT64; MAX_INT64]
-*/
 
-// Case 1. Is pair of floats or pair of ints or pair of uints
 template <typename A, typename B>
-constexpr bool is_safe_conversion = (std::is_floating_point_v<A> && std::is_floating_point_v<B>)
-    || (is_integer_v<A> && is_integer_v<B> && !(is_signed_v<A> ^ is_signed_v<B>));
+bool lessOp(A a, B b)
+{
+    if constexpr (std::is_same_v<A, B>)
+        return a < b;
+
+    /// float vs float
+    if constexpr (std::is_floating_point_v<A> && std::is_floating_point_v<B>)
+        return a < b;
+
+    /// anything vs NaN
+    if (isNaN(a) || isNaN(b))
+        return false;
+
+    /// int vs int
+    if constexpr (is_integer_v<A> && is_integer_v<B>)
+    {
+        /// same signedness
+        if constexpr (is_signed_v<A> == is_signed_v<B>)
+            return a < b;
+
+        /// different signedness
+
+        if constexpr (is_signed_v<A> && !is_signed_v<B>)
+            return a < 0 || static_cast<make_unsigned_t<A>>(a) < b;
+
+        if constexpr (!is_signed_v<A> && is_signed_v<B>)
+            return b >= 0 && a < static_cast<make_unsigned_t<B>>(b);
+    }
+
+    /// int vs float
+    if constexpr (is_integer_v<A> && std::is_floating_point_v<B>)
+    {
+        if constexpr (sizeof(A) <= 4)
+            return static_cast<double>(a) < static_cast<double>(b);
+
+        return DecomposedFloat<B>(b).greater(a);
+    }
+
+    if constexpr (std::is_floating_point_v<A> && is_integer_v<B>)
+    {
+        if constexpr (sizeof(B) <= 4)
+            return static_cast<double>(a) < static_cast<double>(b);
+
+        return DecomposedFloat<A>(a).less(b);
+    }
+
+    static_assert(is_integer_v<A> || std::is_floating_point_v<A>);
+    static_assert(is_integer_v<B> || std::is_floating_point_v<B>);
+    __builtin_unreachable();
+}
+
 template <typename A, typename B>
-using bool_if_safe_conversion = std::enable_if_t<is_safe_conversion<A, B>, bool>;
+bool greaterOp(A a, B b)
+{
+    return lessOp(b, a);
+}
+
 template <typename A, typename B>
-using bool_if_not_safe_conversion = std::enable_if_t<!is_safe_conversion<A, B>, bool>;
-
-
-/// Case 2. Are params IntXX and UIntYY ?
-template <typename TInt, typename TUInt>
-constexpr bool is_any_int_vs_uint
-    = is_integer_v<TInt> && is_integer_v<TUInt> && is_signed_v<TInt> && is_unsigned_v<TUInt>;
-
-// Case 2a. Are params IntXX and UIntYY and sizeof(IntXX) >= sizeof(UIntYY) (in such case will use accurate compare)
-template <typename TInt, typename TUInt>
-constexpr bool is_le_int_vs_uint = is_any_int_vs_uint<TInt, TUInt> && (sizeof(TInt) <= sizeof(TUInt));
-
-static_assert(is_le_int_vs_uint<Int128, DB::UInt128>);
-static_assert(is_le_int_vs_uint<Int128, DB::UInt256>);
-
-template <typename TInt, typename TUInt>
-using bool_if_le_int_vs_uint_t = std::enable_if_t<is_le_int_vs_uint<TInt, TUInt>, bool>;
-
-template <typename TInt, typename TUInt>
-inline bool_if_le_int_vs_uint_t<TInt, TUInt> greaterOpTmpl(TInt a, TUInt b)
+bool greaterOrEqualsOp(A a, B b)
 {
-    return static_cast<TUInt>(a) > b && a >= 0 && b <= static_cast<TUInt>(std::numeric_limits<TInt>::max());
+    if (isNaN(a) || isNaN(b))
+        return false;
+
+    return !lessOp(a, b);
 }
 
-template <typename TUInt, typename TInt>
-inline bool_if_le_int_vs_uint_t<TInt, TUInt> greaterOpTmpl(TUInt a, TInt b)
+template <typename A, typename B>
+bool lessOrEqualsOp(A a, B b)
 {
-    return a > static_cast<TUInt>(b) || b < 0 || a > static_cast<TUInt>(std::numeric_limits<TInt>::max());
+    if (isNaN(a) || isNaN(b))
+        return false;
+
+    return !lessOp(b, a);
 }
 
-template <typename TInt, typename TUInt>
-inline bool_if_le_int_vs_uint_t<TInt, TUInt> equalsOpTmpl(TInt a, TUInt b)
+template <typename A, typename B>
+bool equalsOp(A a, B b)
 {
-    return static_cast<TUInt>(a) == b && a >= 0 && b <= static_cast<TUInt>(std::numeric_limits<TInt>::max());
-}
+    if constexpr (std::is_same_v<A, B>)
+        return a == b;
 
-template <typename TUInt, typename TInt>
-inline bool_if_le_int_vs_uint_t<TInt, TUInt> equalsOpTmpl(TUInt a, TInt b)
-{
-    return a == static_cast<TUInt>(b) && b >= 0 && a <= static_cast<TUInt>(std::numeric_limits<TInt>::max());
-}
+    /// float vs float
+    if constexpr (std::is_floating_point_v<A> && std::is_floating_point_v<B>)
+        return a == b;
 
+    /// anything vs NaN
+    if (isNaN(a) || isNaN(b))
+        return false;
 
-// Case 2b. Are params IntXX and UIntYY and sizeof(IntXX) > sizeof(UIntYY) (in such case will cast UIntYY to IntXX and compare)
-template <typename TInt, typename TUInt>
-constexpr bool is_gt_int_vs_uint = is_any_int_vs_uint<TInt, TUInt> && (sizeof(TInt) > sizeof(TUInt));
+    /// int vs int
+    if constexpr (is_integer_v<A> && is_integer_v<B>)
+    {
+        /// same signedness
+        if constexpr (is_signed_v<A> == is_signed_v<B>)
+            return a == b;
 
-template <typename TInt, typename TUInt>
-using bool_if_gt_int_vs_uint = std::enable_if_t<is_gt_int_vs_uint<TInt, TUInt>, bool>;
+        /// different signedness
 
-template <typename TInt, typename TUInt>
-inline bool_if_gt_int_vs_uint<TInt, TUInt> greaterOpTmpl(TInt a, TUInt b)
-{
-    return static_cast<TInt>(a) > static_cast<TInt>(b);
-}
+        if constexpr (is_signed_v<A> && !is_signed_v<B>)
+            return a >= 0 && static_cast<make_unsigned_t<A>>(a) == b;
 
-template <typename TInt, typename TUInt>
-inline bool_if_gt_int_vs_uint<TInt, TUInt> greaterOpTmpl(TUInt a, TInt b)
-{
-    using CastA = std::conditional_t<is_big_int_v<TInt> && std::is_same_v<TUInt, DB::UInt128>, DB::UInt256, TInt>;
+        if constexpr (!is_signed_v<A> && is_signed_v<B>)
+            return b >= 0 && a == static_cast<make_unsigned_t<B>>(b);
+    }
 
-    return static_cast<CastA>(a) > b;
-}
+    /// int vs float
+    if constexpr (is_integer_v<A> && std::is_floating_point_v<B>)
+    {
+        if constexpr (sizeof(A) <= 4)
+            return static_cast<double>(a) == static_cast<double>(b);
 
-template <typename TInt, typename TUInt>
-inline bool_if_gt_int_vs_uint<TInt, TUInt> equalsOpTmpl(TInt a, TUInt b)
-{
-    return static_cast<TInt>(a) == static_cast<TInt>(b);
-}
+        return DecomposedFloat<B>(b).equals(a);
+    }
 
-template <typename TInt, typename TUInt>
-inline bool_if_gt_int_vs_uint<TInt, TUInt> equalsOpTmpl(TUInt a, TInt b)
-{
-    return static_cast<TInt>(a) == static_cast<TInt>(b);
-}
+    if constexpr (std::is_floating_point_v<A> && is_integer_v<B>)
+    {
+        if constexpr (sizeof(B) <= 4)
+            return static_cast<double>(a) == static_cast<double>(b);
 
+        return DecomposedFloat<A>(a).equals(b);
+    }
 
-// Case 3a. Comparison via conversion to double.
-template <typename TAInt, typename TAFloat>
-using bool_if_double_can_be_used
-    = std::enable_if_t<is_integer_v<TAInt> && (sizeof(TAInt) <= 4) && std::is_floating_point_v<TAFloat>, bool>;
-
-template <typename TAInt, typename TAFloat>
-inline bool_if_double_can_be_used<TAInt, TAFloat> greaterOpTmpl(TAInt a, TAFloat b)
-{
-    return static_cast<double>(a) > static_cast<double>(b);
-}
-
-template <typename TAInt, typename TAFloat>
-inline bool_if_double_can_be_used<TAInt, TAFloat> greaterOpTmpl(TAFloat a, TAInt b)
-{
-    return static_cast<double>(a) > static_cast<double>(b);
-}
-
-template <typename TAInt, typename TAFloat>
-inline bool_if_double_can_be_used<TAInt, TAFloat> equalsOpTmpl(TAInt a, TAFloat b)
-{
-    return static_cast<double>(a) == static_cast<double>(b);
-}
-
-template <typename TAInt, typename TAFloat>
-inline bool_if_double_can_be_used<TAInt, TAFloat> equalsOpTmpl(TAFloat a, TAInt b)
-{
-    return static_cast<double>(a) == static_cast<double>(b);
-}
-
-// Big integers vs Float (not equal in any case for now, until big floats are introduced?)
-template <typename TABigInt, typename TAFloat>
-constexpr bool if_big_int_vs_float = (is_big_int_v<TABigInt> && std::is_floating_point_v<TAFloat>);
-
-template <typename TABigInt, typename TAFloat>
-using bool_if_big_int_vs_float = std::enable_if_t<if_big_int_vs_float<TABigInt, TAFloat>, bool>;
-
-template <typename TABigInt, typename TAFloat>
-inline bool_if_big_int_vs_float<TABigInt, TAFloat> greaterOpTmpl(TAFloat, TABigInt)
-{
+    /// e.g comparing UUID with integer.
     return false;
 }
 
-template <typename TABigInt, typename TAFloat>
-inline bool_if_big_int_vs_float<TABigInt, TAFloat> greaterOpTmpl(TABigInt, TAFloat)
-{
-    return false;
-}
-
-template <typename TABigInt, typename TAFloat>
-inline bool_if_big_int_vs_float<TABigInt, TAFloat> equalsOpTmpl(TAFloat, TABigInt)
-{
-    return false;
-}
-
-template <typename TABigInt, typename TAFloat>
-inline bool_if_big_int_vs_float<TABigInt, TAFloat> equalsOpTmpl(TABigInt, TAFloat)
-{
-    return false;
-}
-
-/* Final implementations */
-
-
 template <typename A, typename B>
-inline bool_if_not_safe_conversion<A, B> greaterOp(A a, B b)
-{
-    return greaterOpTmpl(a, b);
-}
-
-template <typename A, typename B>
-inline bool_if_safe_conversion<A, B> greaterOp(A a, B b)
-{
-    using CastA1 = std::conditional_t<is_big_int_v<B> && std::is_same_v<A, UInt8>, uint8_t, A>;
-    using CastB1 = std::conditional_t<is_big_int_v<A> && std::is_same_v<B, UInt8>, uint8_t, B>;
-
-    using CastA = std::conditional_t<is_big_int_v<B> && std::is_same_v<A, DB::UInt128>, B, CastA1>;
-    using CastB = std::conditional_t<is_big_int_v<A> && std::is_same_v<B, DB::UInt128>, A, CastB1>;
-
-    if constexpr (is_big_int_v<A> || is_big_int_v<B>)
-        return static_cast<CastA>(a) > static_cast<CastB>(b);
-    else
-        return a > b;
-}
-
-// Case 3b. 64-bit integers vs floats comparison.
-// See hint at https://github.com/JuliaLang/julia/issues/257 (but it doesn't work properly for -2**63)
-
-constexpr DB::Int64 MAX_INT64_WITH_EXACT_FLOAT64_REPR = 9007199254740992LL; // 2^53
-
-template <>
-inline bool greaterOp<DB::Float64, DB::Int64>(DB::Float64 f, DB::Int64 i)
-{
-    if (-MAX_INT64_WITH_EXACT_FLOAT64_REPR <= i && i <= MAX_INT64_WITH_EXACT_FLOAT64_REPR)
-        return f > static_cast<DB::Float64>(i);
-
-    return (f >= static_cast<DB::Float64>(std::numeric_limits<DB::Int64>::max())) // rhs is 2**63 (not 2^63 - 1)
-            || (f > static_cast<DB::Float64>(std::numeric_limits<DB::Int64>::min()) && static_cast<DB::Int64>(f) > i);
-}
-
-template <>
-inline bool greaterOp<DB::Int64, DB::Float64>(DB::Int64 i, DB::Float64 f)
-{
-    if (-MAX_INT64_WITH_EXACT_FLOAT64_REPR <= i && i <= MAX_INT64_WITH_EXACT_FLOAT64_REPR)
-        return f < static_cast<DB::Float64>(i);
-
-    return (f < static_cast<DB::Float64>(std::numeric_limits<DB::Int64>::min()))
-            || (f < static_cast<DB::Float64>(std::numeric_limits<DB::Int64>::max()) && i > static_cast<DB::Int64>(f));
-}
-
-template <>
-inline bool greaterOp<DB::Float64, DB::UInt64>(DB::Float64 f, DB::UInt64 u)
-{
-    if (u <= static_cast<DB::UInt64>(MAX_INT64_WITH_EXACT_FLOAT64_REPR))
-        return f > static_cast<DB::Float64>(u);
-
-    return (f >= static_cast<DB::Float64>(std::numeric_limits<DB::UInt64>::max()))
-            || (f >= 0 && static_cast<DB::UInt64>(f) > u);
-}
-
-template <>
-inline bool greaterOp<DB::UInt64, DB::Float64>(DB::UInt64 u, DB::Float64 f)
-{
-    if (u <= static_cast<DB::UInt64>(MAX_INT64_WITH_EXACT_FLOAT64_REPR))
-        return static_cast<DB::Float64>(u) > f;
-
-    return (f < 0)
-            || (f < static_cast<DB::Float64>(std::numeric_limits<DB::UInt64>::max()) && u > static_cast<UInt64>(f));
-}
-
-// Case 3b for float32
-template <>
-inline bool greaterOp<DB::Float32, DB::Int64>(DB::Float32 f, DB::Int64 i)
-{
-    return greaterOp(static_cast<DB::Float64>(f), i);
-}
-
-template <>
-inline bool greaterOp<DB::Int64, DB::Float32>(DB::Int64 i, DB::Float32 f)
-{
-    return greaterOp(i, static_cast<DB::Float64>(f));
-}
-
-template <>
-inline bool greaterOp<DB::Float32, DB::UInt64>(DB::Float32 f, DB::UInt64 u)
-{
-    return greaterOp(static_cast<DB::Float64>(f), u);
-}
-
-template <>
-inline bool greaterOp<DB::UInt64, DB::Float32>(DB::UInt64 u, DB::Float32 f)
-{
-    return greaterOp(u, static_cast<DB::Float64>(f));
-}
-
-template <>
-inline bool greaterOp<DB::Float64, DB::UInt128>(DB::Float64 f, DB::UInt128 u)
-{
-    /// TODO: This is wrong.
-    return u.low == 0 && greaterOp(f, u.high);
-}
-
-template <>
-inline bool greaterOp<DB::UInt128, DB::Float64>(DB::UInt128 u, DB::Float64 f)
-{
-    /// TODO: This is wrong.
-    return u.low != 0 || greaterOp(u.high, f);
-}
-
-template <>
-inline bool greaterOp<DB::Float32, DB::UInt128>(DB::Float32 f, DB::UInt128 u)
-{
-    return greaterOp(static_cast<DB::Float64>(f), u);
-}
-
-template <>
-inline bool greaterOp<DB::UInt128, DB::Float32>(DB::UInt128 u, DB::Float32 f)
-{
-    return greaterOp(u, static_cast<DB::Float64>(f));
-}
-
-template <typename A, typename B>
-inline bool_if_not_safe_conversion<A, B> equalsOp(A a, B b)
-{
-    return equalsOpTmpl(a, b);
-}
-
-template <typename A, typename B>
-inline bool_if_safe_conversion<A, B> equalsOp(A a, B b)
-{
-    using LargestType = std::conditional_t<(sizeof(A) > sizeof(B)) || ((sizeof(A) == sizeof(B)) && !std::is_same_v<A, DB::UInt128>), A, B>;
-
-    return static_cast<LargestType>(a) == static_cast<LargestType>(b);
-}
-
-template <>
-inline bool equalsOp<DB::Float64, DB::UInt64>(DB::Float64 f, DB::UInt64 u)
-{
-    /// Maximum exactly representable integer.
-    return u <= (1ULL << std::numeric_limits<DB::Float64>::digits)
-        && f == static_cast<DB::Float64>(u);
-}
-
-template <>
-inline bool equalsOp<DB::UInt64, DB::Float64>(DB::UInt64 u, DB::Float64 f)
-{
-    return equalsOp(f, u);
-}
-
-template <>
-inline bool equalsOp<DB::Float64, DB::Int64>(DB::Float64 f, DB::Int64 u)
-{
-    return u <= (1LL << std::numeric_limits<DB::Float64>::digits)
-        && u >= -(1LL << std::numeric_limits<DB::Float64>::digits)
-        && f == static_cast<DB::Float64>(u);
-}
-
-template <>
-inline bool equalsOp<DB::Int64, DB::Float64>(DB::Int64 u, DB::Float64 f)
-{
-    return equalsOp(f, u);
-}
-
-template <>
-inline bool equalsOp<DB::Float32, DB::UInt64>(DB::Float32 f, DB::UInt64 u)
-{
-    return u <= (1ULL << std::numeric_limits<DB::Float32>::digits)
-        && f == static_cast<DB::Float32>(u);
-}
-
-template <>
-inline bool equalsOp<DB::UInt64, DB::Float32>(DB::UInt64 u, DB::Float32 f)
-{
-    return equalsOp(f, u);
-}
-
-template <>
-inline bool equalsOp<DB::Float32, DB::Int64>(DB::Float32 f, DB::Int64 u)
-{
-    return u <= (1LL << std::numeric_limits<DB::Float32>::digits)
-        && u >= -(1LL << std::numeric_limits<DB::Float32>::digits)
-        && f == static_cast<DB::Float32>(u);
-}
-
-template <>
-inline bool equalsOp<DB::Int64, DB::Float32>(DB::Int64 u, DB::Float32 f)
-{
-    return equalsOp(f, u);
-}
-
-template <>
-inline bool equalsOp<DB::UInt128, DB::Float64>(DB::UInt128 u, DB::Float64 f)
-{
-    /// TODO: This is wrong.
-    return u.low == 0 && equalsOp(static_cast<UInt64>(u.high), f);
-}
-
-template <>
-inline bool equalsOp<DB::UInt128, DB::Float32>(DB::UInt128 u, DB::Float32 f)
-{
-    return equalsOp(u, static_cast<DB::Float64>(f));
-}
-
-template <>
-inline bool equalsOp<DB::Float64, DB::UInt128>(DB::Float64 f, DB::UInt128 u)
-{
-    return equalsOp(u, f);
-}
-
-template <>
-inline bool equalsOp<DB::Float32, DB::UInt128>(DB::Float32 f, DB::UInt128 u)
-{
-    return equalsOp(static_cast<DB::Float64>(f), u);
-}
-
-inline bool NO_SANITIZE_UNDEFINED greaterOp(DB::Int128 i, DB::Float64 f)
-{
-    static constexpr Int128 min_int128 = minInt128();
-    static constexpr Int128 max_int128 = maxInt128();
-
-    if (-MAX_INT64_WITH_EXACT_FLOAT64_REPR <= i && i <= MAX_INT64_WITH_EXACT_FLOAT64_REPR)
-        return static_cast<DB::Float64>(i) > f;
-
-    return (f < static_cast<DB::Float64>(min_int128))
-        || (f < static_cast<DB::Float64>(max_int128) && i > static_cast<DB::Int128>(f));
-}
-
-inline bool NO_SANITIZE_UNDEFINED greaterOp(DB::Float64 f, DB::Int128 i)
-{
-    static constexpr Int128 min_int128 = minInt128();
-    static constexpr Int128 max_int128 = maxInt128();
-
-    if (-MAX_INT64_WITH_EXACT_FLOAT64_REPR <= i && i <= MAX_INT64_WITH_EXACT_FLOAT64_REPR)
-        return f > static_cast<DB::Float64>(i);
-
-    return (f >= static_cast<DB::Float64>(max_int128))
-        || (f > static_cast<DB::Float64>(min_int128) && static_cast<DB::Int128>(f) > i);
-}
-
-inline bool greaterOp(DB::Int128 i, DB::Float32 f) { return greaterOp(i, static_cast<DB::Float64>(f)); }
-inline bool greaterOp(DB::Float32 f, DB::Int128 i) { return greaterOp(static_cast<DB::Float64>(f), i); }
-
-inline bool NO_SANITIZE_UNDEFINED equalsOp(DB::Int128 i, DB::Float64 f) { return i == static_cast<DB::Int128>(f) && static_cast<DB::Float64>(i) == f; }
-inline bool NO_SANITIZE_UNDEFINED equalsOp(DB::Int128 i, DB::Float32 f) { return i == static_cast<DB::Int128>(f) && static_cast<DB::Float32>(i) == f; }
-inline bool equalsOp(DB::Float64 f, DB::Int128 i) { return equalsOp(i, f); }
-inline bool equalsOp(DB::Float32 f, DB::Int128 i) { return equalsOp(i, f); }
-
-template <typename A, typename B>
-inline bool_if_not_safe_conversion<A, B> notEqualsOp(A a, B b)
+bool notEqualsOp(A a, B b)
 {
     return !equalsOp(a, b);
 }
 
-template <typename A, typename B>
-inline bool_if_safe_conversion<A, B> notEqualsOp(A a, B b)
-{
-    using CastA1 = std::conditional_t<is_big_int_v<B> && std::is_same_v<A, UInt8>, uint8_t, A>;
-    using CastB1 = std::conditional_t<is_big_int_v<A> && std::is_same_v<B, UInt8>, uint8_t, B>;
-
-    using CastA = std::conditional_t<is_big_int_v<B> && std::is_same_v<A, DB::UInt128>, B, CastA1>;
-    using CastB = std::conditional_t<is_big_int_v<A> && std::is_same_v<B, DB::UInt128>, A, CastB1>;
-
-    if constexpr (is_big_int_v<A> || is_big_int_v<B>)
-        return static_cast<CastA>(a) != static_cast<CastB>(b);
-    else
-        return a != b;
-}
-
-
-template <typename A, typename B>
-inline bool_if_not_safe_conversion<A, B> lessOp(A a, B b)
-{
-    return greaterOp(b, a);
-}
-
-template <typename A, typename B>
-inline bool_if_safe_conversion<A, B> lessOp(A a, B b)
-{
-    using CastA1 = std::conditional_t<is_big_int_v<B> && std::is_same_v<A, UInt8>, uint8_t, A>;
-    using CastB1 = std::conditional_t<is_big_int_v<A> && std::is_same_v<B, UInt8>, uint8_t, B>;
-
-    using CastA = std::conditional_t<is_big_int_v<B> && std::is_same_v<A, DB::UInt128>, B, CastA1>;
-    using CastB = std::conditional_t<is_big_int_v<A> && std::is_same_v<B, DB::UInt128>, A, CastB1>;
-
-    if constexpr (is_big_int_v<A> || is_big_int_v<B>)
-        return static_cast<CastA>(a) < static_cast<CastB>(b);
-    else
-        return a < b;
-}
-
-
-template <typename A, typename B>
-inline bool_if_not_safe_conversion<A, B> lessOrEqualsOp(A a, B b)
-{
-    if (isNaN(a) || isNaN(b))
-        return false;
-    return !greaterOp(a, b);
-}
-
-template <typename A, typename B>
-inline bool_if_safe_conversion<A, B> lessOrEqualsOp(A a, B b)
-{
-    using CastA1 = std::conditional_t<is_big_int_v<B> && std::is_same_v<A, UInt8>, uint8_t, A>;
-    using CastB1 = std::conditional_t<is_big_int_v<A> && std::is_same_v<B, UInt8>, uint8_t, B>;
-
-    using CastA = std::conditional_t<is_big_int_v<B> && std::is_same_v<A, DB::UInt128>, B, CastA1>;
-    using CastB = std::conditional_t<is_big_int_v<A> && std::is_same_v<B, DB::UInt128>, A, CastB1>;
-
-    if constexpr (is_big_int_v<A> || is_big_int_v<B>)
-        return static_cast<CastA>(a) <= static_cast<CastB>(b);
-    else
-        return a <= b;
-}
-
-
-template <typename A, typename B>
-inline bool_if_not_safe_conversion<A, B> greaterOrEqualsOp(A a, B b)
-{
-    if (isNaN(a) || isNaN(b))
-        return false;
-    return !greaterOp(b, a);
-}
-
-template <typename A, typename B>
-inline bool_if_safe_conversion<A, B> greaterOrEqualsOp(A a, B b)
-{
-    using CastA1 = std::conditional_t<is_big_int_v<B> && std::is_same_v<A, UInt8>, uint8_t, A>;
-    using CastB1 = std::conditional_t<is_big_int_v<A> && std::is_same_v<B, UInt8>, uint8_t, B>;
-
-    using CastA = std::conditional_t<is_big_int_v<B> && std::is_same_v<A, DB::UInt128>, B, CastA1>;
-    using CastB = std::conditional_t<is_big_int_v<A> && std::is_same_v<B, DB::UInt128>, A, CastB1>;
-
-    if constexpr (is_big_int_v<A> || is_big_int_v<B>)
-        return static_cast<CastA>(a) >= static_cast<CastB>(b);
-    else
-        return a >= b;
-}
 
 /// Converts numeric to an equal numeric of other type.
 template <typename From, typename To>
@@ -547,8 +185,8 @@ inline bool NO_SANITIZE_UNDEFINED convertNumeric(From value, To & result)
         }
     }
 
-    if (accurate::greaterOp(value, std::numeric_limits<To>::max())
-        || accurate::greaterOp(std::numeric_limits<To>::lowest(), value))
+    if (greaterOp(value, std::numeric_limits<To>::max())
+        || lessOp(value, std::numeric_limits<To>::lowest()))
     {
         return false;
     }
diff --git a/src/Core/BaseSettings.h b/src/Core/BaseSettings.h
index b193fdd4c93..3b6cc61d1eb 100644
--- a/src/Core/BaseSettings.h
+++ b/src/Core/BaseSettings.h
@@ -2,7 +2,6 @@
 
 #include <Core/SettingsFields.h>
 #include <Common/SettingsChanges.h>
-#include <Common/FieldVisitors.h>
 #include <ext/range.h>
 #include <boost/blank.hpp>
 #include <unordered_map>
diff --git a/src/Core/DecimalComparison.h b/src/Core/DecimalComparison.h
index 486c2c1f8f4..5b017cd4634 100644
--- a/src/Core/DecimalComparison.h
+++ b/src/Core/DecimalComparison.h
@@ -36,10 +36,13 @@ inline bool allowDecimalComparison(const DataTypePtr & left_type, const DataType
     return false;
 }
 
-template <size_t > struct ConstructDecInt { using Type = Int32; };
+template <size_t> struct ConstructDecInt;
+template <> struct ConstructDecInt<1> { using Type = Int32; };
+template <> struct ConstructDecInt<2> { using Type = Int32; };
+template <> struct ConstructDecInt<4> { using Type = Int32; };
 template <> struct ConstructDecInt<8> { using Type = Int64; };
 template <> struct ConstructDecInt<16> { using Type = Int128; };
-template <> struct ConstructDecInt<48> { using Type = Int256; };
+template <> struct ConstructDecInt<32> { using Type = Int256; };
 
 template <typename T, typename U>
 struct DecCompareInt
@@ -249,7 +252,7 @@ private:
                 overflow |= common::mulOverflow(y, scale, y);
 
             if (overflow)
-                throw Exception("Can't compare", ErrorCodes::DECIMAL_OVERFLOW);
+                throw Exception("Can't compare decimal number due to overflow", ErrorCodes::DECIMAL_OVERFLOW);
         }
         else
         {
diff --git a/src/Core/DecimalFunctions.h b/src/Core/DecimalFunctions.h
index 2131a6e3c33..0e399210088 100644
--- a/src/Core/DecimalFunctions.h
+++ b/src/Core/DecimalFunctions.h
@@ -276,9 +276,7 @@ template <typename To, typename DecimalType>
 To convertTo(const DecimalType & decimal, size_t scale)
 {
     To result;
-
     convertToImpl<To, DecimalType, void>(decimal, scale, result);
-
     return result;
 }
 
diff --git a/src/Core/Field.cpp b/src/Core/Field.cpp
index 8aa79b0bbe1..9dec8563d36 100644
--- a/src/Core/Field.cpp
+++ b/src/Core/Field.cpp
@@ -238,6 +238,13 @@ Field Field::restoreFromDump(const std::string_view & dump_)
         return value;
     }
 
+    prefix = std::string_view{"UInt128_"};
+    if (dump.starts_with(prefix))
+    {
+        UInt128 value = parseFromString<UInt128>(dump.substr(prefix.length()));
+        return value;
+    }
+
     prefix = std::string_view{"Int256_"};
     if (dump.starts_with(prefix))
     {
@@ -295,15 +302,6 @@ Field Field::restoreFromDump(const std::string_view & dump_)
         return decimal;
     }
 
-    prefix = std::string_view{"UUID_"};
-    if (dump.starts_with(prefix))
-    {
-        UUID uuid;
-        ReadBufferFromString buf{dump.substr(prefix.length())};
-        readQuoted(uuid, buf);
-        return uuid;
-    }
-
     if (dump.starts_with("\'"))
     {
         String str;
@@ -410,45 +408,45 @@ Field Field::restoreFromDump(const std::string_view & dump_)
 
 
 template <typename T>
-static bool decEqual(T x, T y, UInt32 x_scale, UInt32 y_scale)
+bool decimalEqual(T x, T y, UInt32 x_scale, UInt32 y_scale)
 {
     using Comparator = DecimalComparison<T, T, EqualsOp>;
     return Comparator::compare(x, y, x_scale, y_scale);
 }
 
 template <typename T>
-static bool decLess(T x, T y, UInt32 x_scale, UInt32 y_scale)
+bool decimalLess(T x, T y, UInt32 x_scale, UInt32 y_scale)
 {
     using Comparator = DecimalComparison<T, T, LessOp>;
     return Comparator::compare(x, y, x_scale, y_scale);
 }
 
 template <typename T>
-static bool decLessOrEqual(T x, T y, UInt32 x_scale, UInt32 y_scale)
+bool decimalLessOrEqual(T x, T y, UInt32 x_scale, UInt32 y_scale)
 {
     using Comparator = DecimalComparison<T, T, LessOrEqualsOp>;
     return Comparator::compare(x, y, x_scale, y_scale);
 }
 
-template <> bool decimalEqual(Decimal32 x, Decimal32 y, UInt32 x_scale, UInt32 y_scale) { return decEqual(x, y, x_scale, y_scale); }
-template <> bool decimalLess(Decimal32 x, Decimal32 y, UInt32 x_scale, UInt32 y_scale) { return decLess(x, y, x_scale, y_scale); }
-template <> bool decimalLessOrEqual(Decimal32 x, Decimal32 y, UInt32 x_scale, UInt32 y_scale) { return decLessOrEqual(x, y, x_scale, y_scale); }
 
-template <> bool decimalEqual(Decimal64 x, Decimal64 y, UInt32 x_scale, UInt32 y_scale) { return decEqual(x, y, x_scale, y_scale); }
-template <> bool decimalLess(Decimal64 x, Decimal64 y, UInt32 x_scale, UInt32 y_scale) { return decLess(x, y, x_scale, y_scale); }
-template <> bool decimalLessOrEqual(Decimal64 x, Decimal64 y, UInt32 x_scale, UInt32 y_scale) { return decLessOrEqual(x, y, x_scale, y_scale); }
+template bool decimalEqual<Decimal32>(Decimal32 x, Decimal32 y, UInt32 x_scale, UInt32 y_scale);
+template bool decimalEqual<Decimal64>(Decimal64 x, Decimal64 y, UInt32 x_scale, UInt32 y_scale);
+template bool decimalEqual<Decimal128>(Decimal128 x, Decimal128 y, UInt32 x_scale, UInt32 y_scale);
+template bool decimalEqual<Decimal256>(Decimal256 x, Decimal256 y, UInt32 x_scale, UInt32 y_scale);
+template bool decimalEqual<DateTime64>(DateTime64 x, DateTime64 y, UInt32 x_scale, UInt32 y_scale);
 
-template <> bool decimalEqual(Decimal128 x, Decimal128 y, UInt32 x_scale, UInt32 y_scale) { return decEqual(x, y, x_scale, y_scale); }
-template <> bool decimalLess(Decimal128 x, Decimal128 y, UInt32 x_scale, UInt32 y_scale) { return decLess(x, y, x_scale, y_scale); }
-template <> bool decimalLessOrEqual(Decimal128 x, Decimal128 y, UInt32 x_scale, UInt32 y_scale) { return decLessOrEqual(x, y, x_scale, y_scale); }
+template bool decimalLess<Decimal32>(Decimal32 x, Decimal32 y, UInt32 x_scale, UInt32 y_scale);
+template bool decimalLess<Decimal64>(Decimal64 x, Decimal64 y, UInt32 x_scale, UInt32 y_scale);
+template bool decimalLess<Decimal128>(Decimal128 x, Decimal128 y, UInt32 x_scale, UInt32 y_scale);
+template bool decimalLess<Decimal256>(Decimal256 x, Decimal256 y, UInt32 x_scale, UInt32 y_scale);
+template bool decimalLess<DateTime64>(DateTime64 x, DateTime64 y, UInt32 x_scale, UInt32 y_scale);
 
-template <> bool decimalEqual(Decimal256 x, Decimal256 y, UInt32 x_scale, UInt32 y_scale) { return decEqual(x, y, x_scale, y_scale); }
-template <> bool decimalLess(Decimal256 x, Decimal256 y, UInt32 x_scale, UInt32 y_scale) { return decLess(x, y, x_scale, y_scale); }
-template <> bool decimalLessOrEqual(Decimal256 x, Decimal256 y, UInt32 x_scale, UInt32 y_scale) { return decLessOrEqual(x, y, x_scale, y_scale); }
+template bool decimalLessOrEqual<Decimal32>(Decimal32 x, Decimal32 y, UInt32 x_scale, UInt32 y_scale);
+template bool decimalLessOrEqual<Decimal64>(Decimal64 x, Decimal64 y, UInt32 x_scale, UInt32 y_scale);
+template bool decimalLessOrEqual<Decimal128>(Decimal128 x, Decimal128 y, UInt32 x_scale, UInt32 y_scale);
+template bool decimalLessOrEqual<Decimal256>(Decimal256 x, Decimal256 y, UInt32 x_scale, UInt32 y_scale);
+template bool decimalLessOrEqual<DateTime64>(DateTime64 x, DateTime64 y, UInt32 x_scale, UInt32 y_scale);
 
-template <> bool decimalEqual(DateTime64 x, DateTime64 y, UInt32 x_scale, UInt32 y_scale) { return decEqual(x, y, x_scale, y_scale); }
-template <> bool decimalLess(DateTime64 x, DateTime64 y, UInt32 x_scale, UInt32 y_scale) { return decLess(x, y, x_scale, y_scale); }
-template <> bool decimalLessOrEqual(DateTime64 x, DateTime64 y, UInt32 x_scale, UInt32 y_scale) { return decLessOrEqual(x, y, x_scale, y_scale); }
 
 inline void writeText(const Null &, WriteBuffer & buf)
 {
diff --git a/src/Core/Field.h b/src/Core/Field.h
index 2c3ca1310e4..fb9f811ddf3 100644
--- a/src/Core/Field.h
+++ b/src/Core/Field.h
@@ -7,7 +7,6 @@
 #include <functional>
 
 #include <Common/Exception.h>
-#include <Common/UInt128.h>
 #include <Common/AllocatorWithMemoryTracking.h>
 #include <Core/Types.h>
 #include <Core/Defines.h>
@@ -177,8 +176,7 @@ template <> struct NearestFieldTypeImpl<UInt16> { using Type = UInt64; };
 template <> struct NearestFieldTypeImpl<UInt32> { using Type = UInt64; };
 
 template <> struct NearestFieldTypeImpl<DayNum> { using Type = UInt64; };
-template <> struct NearestFieldTypeImpl<UInt128> { using Type = UInt128; };
-template <> struct NearestFieldTypeImpl<UUID> { using Type = UInt128; };
+template <> struct NearestFieldTypeImpl<UUID> { using Type = UUID; };
 template <> struct NearestFieldTypeImpl<Int16> { using Type = Int64; };
 template <> struct NearestFieldTypeImpl<Int32> { using Type = Int64; };
 
@@ -191,8 +189,9 @@ template <> struct NearestFieldTypeImpl<unsigned long long> { using Type = UInt6
 
 template <> struct NearestFieldTypeImpl<UInt256> { using Type = UInt256; };
 template <> struct NearestFieldTypeImpl<Int256> { using Type = Int256; };
-
+template <> struct NearestFieldTypeImpl<UInt128> { using Type = UInt128; };
 template <> struct NearestFieldTypeImpl<Int128> { using Type = Int128; };
+
 template <> struct NearestFieldTypeImpl<Decimal32> { using Type = DecimalField<Decimal32>; };
 template <> struct NearestFieldTypeImpl<Decimal64> { using Type = DecimalField<Decimal64>; };
 template <> struct NearestFieldTypeImpl<Decimal128> { using Type = DecimalField<Decimal128>; };
@@ -235,7 +234,7 @@ struct NearestFieldTypeImpl<T, std::enable_if_t<std::is_enum_v<T>>>
   *  but somewhat more efficient, and simpler.
   *
   * Used to represent a single value of one of several types in memory.
-  * Warning! Prefer to use chunks of columns instead of single values. See Column.h
+  * Warning! Prefer to use chunks of columns instead of single values. See IColumn.h
   */
 class Field
 {
@@ -252,8 +251,6 @@ public:
             UInt128 = 4,
             Int128  = 5,
 
-            /// Non-POD types.
-
             String  = 16,
             Array   = 17,
             Tuple   = 18,
@@ -265,10 +262,9 @@ public:
             UInt256 = 24,
             Int256  = 25,
             Map = 26,
+            UUID = 27,
         };
 
-        static const int MIN_NON_POD = 16;
-
         static const char * toString(Which which)
         {
             switch (which)
@@ -276,8 +272,11 @@ public:
                 case Null:    return "Null";
                 case UInt64:  return "UInt64";
                 case UInt128: return "UInt128";
+                case UInt256: return "UInt256";
                 case Int64:   return "Int64";
                 case Int128:  return "Int128";
+                case Int256:  return "Int256";
+                case UUID:    return "UUID";
                 case Float64: return "Float64";
                 case String:  return "String";
                 case Array:   return "Array";
@@ -288,8 +287,6 @@ public:
                 case Decimal128: return "Decimal128";
                 case Decimal256: return "Decimal256";
                 case AggregateFunctionState: return "AggregateFunctionState";
-                case UInt256: return "UInt256";
-                case Int256:  return "Int256";
             }
 
             throw Exception("Bad type of Field", ErrorCodes::BAD_TYPE_OF_FIELD);
@@ -303,12 +300,17 @@ public:
 
     static bool IsDecimal(Types::Which which)
     {
-        return (which >= Types::Decimal32 && which <= Types::Decimal128) || which == Types::Decimal256;
+        return which == Types::Decimal32
+            || which == Types::Decimal64
+            || which == Types::Decimal128
+            || which == Types::Decimal256;
     }
 
     /// Templates to avoid ambiguity.
     template <typename T, typename Z = void *>
-    using enable_if_not_field_or_stringlike_t = std::enable_if_t<!std::is_same_v<std::decay_t<T>, Field> && !std::is_same_v<NearestFieldType<std::decay_t<T>>, String>, Z>;
+    using enable_if_not_field_or_stringlike_t = std::enable_if_t<
+        !std::is_same_v<std::decay_t<T>, Field>
+        && !std::is_same_v<NearestFieldType<std::decay_t<T>>, String>, Z>;
 
     Field() //-V730
         : which(Types::Null)
@@ -382,10 +384,10 @@ public:
     enable_if_not_field_or_stringlike_t<T, Field> &
     operator=(T && rhs);
 
-    Field & operator =(const std::string_view & str);
-    Field & operator =(const String & str) { return *this = std::string_view{str}; }
-    Field & operator =(String && str);
-    Field & operator =(const char * str) { return *this = std::string_view{str}; }
+    Field & operator= (const std::string_view & str);
+    Field & operator= (const String & str) { return *this = std::string_view{str}; }
+    Field & operator= (String && str);
+    Field & operator= (const char * str) { return *this = std::string_view{str}; }
 
     ~Field()
     {
@@ -454,8 +456,11 @@ public:
             case Types::Null:    return false;
             case Types::UInt64:  return get<UInt64>()  < rhs.get<UInt64>();
             case Types::UInt128: return get<UInt128>() < rhs.get<UInt128>();
+            case Types::UInt256: return get<UInt256>() < rhs.get<UInt256>();
             case Types::Int64:   return get<Int64>()   < rhs.get<Int64>();
             case Types::Int128:  return get<Int128>()  < rhs.get<Int128>();
+            case Types::Int256:  return get<Int256>()  < rhs.get<Int256>();
+            case Types::UUID:    return get<UUID>()    < rhs.get<UUID>();
             case Types::Float64: return get<Float64>() < rhs.get<Float64>();
             case Types::String:  return get<String>()  < rhs.get<String>();
             case Types::Array:   return get<Array>()   < rhs.get<Array>();
@@ -466,8 +471,6 @@ public:
             case Types::Decimal128: return get<DecimalField<Decimal128>>() < rhs.get<DecimalField<Decimal128>>();
             case Types::Decimal256: return get<DecimalField<Decimal256>>() < rhs.get<DecimalField<Decimal256>>();
             case Types::AggregateFunctionState:  return get<AggregateFunctionStateData>() < rhs.get<AggregateFunctionStateData>();
-            case Types::UInt256: return get<UInt256>() < rhs.get<UInt256>();
-            case Types::Int256: return get<Int256>() < rhs.get<Int256>();
         }
 
         throw Exception("Bad type of Field", ErrorCodes::BAD_TYPE_OF_FIELD);
@@ -490,8 +493,11 @@ public:
             case Types::Null:    return true;
             case Types::UInt64:  return get<UInt64>()  <= rhs.get<UInt64>();
             case Types::UInt128: return get<UInt128>() <= rhs.get<UInt128>();
+            case Types::UInt256: return get<UInt256>() <= rhs.get<UInt256>();
             case Types::Int64:   return get<Int64>()   <= rhs.get<Int64>();
             case Types::Int128:  return get<Int128>()  <= rhs.get<Int128>();
+            case Types::Int256:  return get<Int256>()  <= rhs.get<Int256>();
+            case Types::UUID:    return get<UUID>().toUnderType() <= rhs.get<UUID>().toUnderType();
             case Types::Float64: return get<Float64>() <= rhs.get<Float64>();
             case Types::String:  return get<String>()  <= rhs.get<String>();
             case Types::Array:   return get<Array>()   <= rhs.get<Array>();
@@ -502,8 +508,6 @@ public:
             case Types::Decimal128: return get<DecimalField<Decimal128>>() <= rhs.get<DecimalField<Decimal128>>();
             case Types::Decimal256: return get<DecimalField<Decimal256>>() <= rhs.get<DecimalField<Decimal256>>();
             case Types::AggregateFunctionState:  return get<AggregateFunctionStateData>() <= rhs.get<AggregateFunctionStateData>();
-            case Types::UInt256: return get<UInt256>() <= rhs.get<UInt256>();
-            case Types::Int256: return get<Int256>() <= rhs.get<Int256>();
         }
 
         throw Exception("Bad type of Field", ErrorCodes::BAD_TYPE_OF_FIELD);
@@ -531,19 +535,20 @@ public:
                 // Compare as UInt64 so that NaNs compare as equal.
                 return reinterpret<UInt64>() == rhs.reinterpret<UInt64>();
             }
+            case Types::UUID:    return get<UUID>()    == rhs.get<UUID>();
             case Types::String:  return get<String>()  == rhs.get<String>();
             case Types::Array:   return get<Array>()   == rhs.get<Array>();
             case Types::Tuple:   return get<Tuple>()   == rhs.get<Tuple>();
             case Types::Map:     return get<Map>()     == rhs.get<Map>();
             case Types::UInt128: return get<UInt128>() == rhs.get<UInt128>();
+            case Types::UInt256: return get<UInt256>() == rhs.get<UInt256>();
             case Types::Int128:  return get<Int128>()  == rhs.get<Int128>();
+            case Types::Int256:  return get<Int256>()  == rhs.get<Int256>();
             case Types::Decimal32:  return get<DecimalField<Decimal32>>()  == rhs.get<DecimalField<Decimal32>>();
             case Types::Decimal64:  return get<DecimalField<Decimal64>>()  == rhs.get<DecimalField<Decimal64>>();
             case Types::Decimal128: return get<DecimalField<Decimal128>>() == rhs.get<DecimalField<Decimal128>>();
             case Types::Decimal256: return get<DecimalField<Decimal256>>() == rhs.get<DecimalField<Decimal256>>();
             case Types::AggregateFunctionState:  return get<AggregateFunctionStateData>() == rhs.get<AggregateFunctionStateData>();
-            case Types::UInt256: return get<UInt256>() == rhs.get<UInt256>();
-            case Types::Int256:  return get<Int256>()  == rhs.get<Int256>();
         }
 
         throw Exception("Bad type of Field", ErrorCodes::BAD_TYPE_OF_FIELD);
@@ -569,7 +574,11 @@ public:
 #endif
             case Types::UInt64:  return f(field.template get<UInt64>());
             case Types::UInt128: return f(field.template get<UInt128>());
+            case Types::UInt256: return f(field.template get<UInt256>());
             case Types::Int64:   return f(field.template get<Int64>());
+            case Types::Int128:  return f(field.template get<Int128>());
+            case Types::Int256:  return f(field.template get<Int256>());
+            case Types::UUID:    return f(field.template get<UUID>());
             case Types::Float64: return f(field.template get<Float64>());
             case Types::String:  return f(field.template get<String>());
             case Types::Array:   return f(field.template get<Array>());
@@ -580,19 +589,12 @@ public:
             case Types::Decimal128: return f(field.template get<DecimalField<Decimal128>>());
             case Types::Decimal256: return f(field.template get<DecimalField<Decimal256>>());
             case Types::AggregateFunctionState: return f(field.template get<AggregateFunctionStateData>());
-            case Types::Int128: return f(field.template get<Int128>());
-            case Types::UInt256: return f(field.template get<UInt256>());
-            case Types::Int256: return f(field.template get<Int256>());
 #if !defined(__clang__)
 #pragma GCC diagnostic pop
 #endif
         }
 
-        // GCC 9 complains that control reaches the end, despite that we handle
-        // all the cases above (maybe because of throw?). Return something to
-        // silence it.
-        Null null{};
-        return f(null);
+        __builtin_unreachable();
     }
 
     String dump() const;
@@ -600,10 +602,9 @@ public:
 
 private:
     std::aligned_union_t<DBMS_MIN_FIELD_SIZE - sizeof(Types::Which),
-        Null, UInt64, UInt128, Int64, Int128, Float64, String, Array, Tuple, Map,
+        Null, UInt64, UInt128, UInt256, Int64, Int128, Int256, UUID, Float64, String, Array, Tuple, Map,
         DecimalField<Decimal32>, DecimalField<Decimal64>, DecimalField<Decimal128>, DecimalField<Decimal256>,
-        AggregateFunctionStateData,
-        UInt256, Int256
+        AggregateFunctionStateData
         > storage;
 
     Types::Which which;
@@ -685,9 +686,6 @@ private:
 
     ALWAYS_INLINE void destroy()
     {
-        if (which < Types::MIN_NON_POD)
-            return;
-
         switch (which)
         {
             case Types::String:
@@ -726,8 +724,11 @@ private:
 template <> struct Field::TypeToEnum<Null>    { static const Types::Which value = Types::Null; };
 template <> struct Field::TypeToEnum<UInt64>  { static const Types::Which value = Types::UInt64; };
 template <> struct Field::TypeToEnum<UInt128> { static const Types::Which value = Types::UInt128; };
+template <> struct Field::TypeToEnum<UInt256> { static const Types::Which value = Types::UInt256; };
 template <> struct Field::TypeToEnum<Int64>   { static const Types::Which value = Types::Int64; };
 template <> struct Field::TypeToEnum<Int128>  { static const Types::Which value = Types::Int128; };
+template <> struct Field::TypeToEnum<Int256>  { static const Types::Which value = Types::Int256; };
+template <> struct Field::TypeToEnum<UUID>    { static const Types::Which value = Types::UUID; };
 template <> struct Field::TypeToEnum<Float64> { static const Types::Which value = Types::Float64; };
 template <> struct Field::TypeToEnum<String>  { static const Types::Which value = Types::String; };
 template <> struct Field::TypeToEnum<Array>   { static const Types::Which value = Types::Array; };
@@ -739,14 +740,15 @@ template <> struct Field::TypeToEnum<DecimalField<Decimal128>>{ static const Typ
 template <> struct Field::TypeToEnum<DecimalField<Decimal256>>{ static const Types::Which value = Types::Decimal256; };
 template <> struct Field::TypeToEnum<DecimalField<DateTime64>>{ static const Types::Which value = Types::Decimal64; };
 template <> struct Field::TypeToEnum<AggregateFunctionStateData>{ static const Types::Which value = Types::AggregateFunctionState; };
-template <> struct Field::TypeToEnum<UInt256> { static const Types::Which value = Types::UInt256; };
-template <> struct Field::TypeToEnum<Int256> { static const Types::Which value = Types::Int256; };
 
 template <> struct Field::EnumToType<Field::Types::Null>    { using Type = Null; };
 template <> struct Field::EnumToType<Field::Types::UInt64>  { using Type = UInt64; };
 template <> struct Field::EnumToType<Field::Types::UInt128> { using Type = UInt128; };
+template <> struct Field::EnumToType<Field::Types::UInt256> { using Type = UInt256; };
 template <> struct Field::EnumToType<Field::Types::Int64>   { using Type = Int64; };
 template <> struct Field::EnumToType<Field::Types::Int128>  { using Type = Int128; };
+template <> struct Field::EnumToType<Field::Types::Int256>  { using Type = Int256; };
+template <> struct Field::EnumToType<Field::Types::UUID>    { using Type = UUID; };
 template <> struct Field::EnumToType<Field::Types::Float64> { using Type = Float64; };
 template <> struct Field::EnumToType<Field::Types::String>  { using Type = String; };
 template <> struct Field::EnumToType<Field::Types::Array>   { using Type = Array; };
@@ -757,10 +759,8 @@ template <> struct Field::EnumToType<Field::Types::Decimal64> { using Type = Dec
 template <> struct Field::EnumToType<Field::Types::Decimal128> { using Type = DecimalField<Decimal128>; };
 template <> struct Field::EnumToType<Field::Types::Decimal256> { using Type = DecimalField<Decimal256>; };
 template <> struct Field::EnumToType<Field::Types::AggregateFunctionState> { using Type = DecimalField<AggregateFunctionStateData>; };
-template <> struct Field::EnumToType<Field::Types::UInt256> { using Type = UInt256; };
-template <> struct Field::EnumToType<Field::Types::Int256>  { using Type = Int256; };
 
-inline constexpr bool isInt64FieldType(Field::Types::Which t)
+inline constexpr bool isInt64OrUInt64FieldType(Field::Types::Which t)
 {
     return t == Field::Types::Int64
         || t == Field::Types::UInt64;
@@ -782,7 +782,7 @@ NearestFieldType<std::decay_t<T>> & Field::get()
     // Disregard signedness when converting between int64 types.
     constexpr Field::Types::Which target = TypeToEnum<StoredType>::value;
     if (target != which
-           && (!isInt64FieldType(target) || !isInt64FieldType(which)))
+           && (!isInt64OrUInt64FieldType(target) || !isInt64OrUInt64FieldType(which)))
         throw Exception(ErrorCodes::LOGICAL_ERROR, "Invalid Field get from type {} to type {}", Types::toString(which), Types::toString(target));
 #endif
 
@@ -834,11 +834,11 @@ T safeGet(Field & field)
     return field.template safeGet<T>();
 }
 
+template <> inline constexpr const char * TypeName<Array> = "Array";
+template <> inline constexpr const char * TypeName<Tuple> = "Tuple";
+template <> inline constexpr const char * TypeName<Map> = "Map";
+template <> inline constexpr const char * TypeName<AggregateFunctionStateData> = "AggregateFunctionState";
 
-template <> struct TypeName<Array> { static std::string get() { return "Array"; } };
-template <> struct TypeName<Tuple> { static std::string get() { return "Tuple"; } };
-template <> struct TypeName<Map>   { static std::string get() { return "Map"; } };
-template <> struct TypeName<AggregateFunctionStateData> { static std::string get() { return "AggregateFunctionState"; } };
 
 template <typename T>
 decltype(auto) castToNearestFieldType(T && x)
@@ -965,7 +965,7 @@ struct fmt::formatter<DB::Field>
 
         /// Only support {}.
         if (it != end && *it != '}')
-            throw format_error("invalid format");
+            throw format_error("Invalid format");
 
         return it;
     }
diff --git a/src/Core/MySQL/MySQLGtid.cpp b/src/Core/MySQL/MySQLGtid.cpp
index 13dc6e0fd69..a441bccb076 100644
--- a/src/Core/MySQL/MySQLGtid.cpp
+++ b/src/Core/MySQL/MySQLGtid.cpp
@@ -1,6 +1,7 @@
 #include "MySQLGtid.h"
-
 #include <boost/algorithm/string.hpp>
+#include <IO/ReadHelpers.h>
+
 
 namespace DB
 {
@@ -38,7 +39,7 @@ void GTIDSets::parse(const String gtid_format)
         boost::split(server_ids, gset, [](char c) { return c == ':'; });
 
         GTIDSet set;
-        set.uuid = stringToUUID(server_ids[0]);
+        set.uuid = DB::parse<UUID>(server_ids[0]);
 
         for (size_t k = 1; k < server_ids.size(); k++)
         {
@@ -174,8 +175,8 @@ String GTIDSets::toPayload() const
     for (const auto & set : sets)
     {
         // MySQL UUID is big-endian.
-        writeBinaryBigEndian(set.uuid.toUnderType().low, buffer);
-        writeBinaryBigEndian(set.uuid.toUnderType().high, buffer);
+        writeBinaryBigEndian(set.uuid.toUnderType().items[0], buffer);
+        writeBinaryBigEndian(set.uuid.toUnderType().items[1], buffer);
 
         UInt64 intervals_size = set.intervals.size();
         buffer.write(reinterpret_cast<const char *>(&intervals_size), 8);
diff --git a/src/Core/MySQL/MySQLReplication.cpp b/src/Core/MySQL/MySQLReplication.cpp
index 7e3f68983be..e326d5e5b32 100644
--- a/src/Core/MySQL/MySQLReplication.cpp
+++ b/src/Core/MySQL/MySQLReplication.cpp
@@ -474,19 +474,19 @@ namespace MySQLReplication
                     }
                     case MYSQL_TYPE_NEWDECIMAL:
                     {
-                        const auto & dispatch = [](const size_t & precision, const size_t & scale, const auto & function) -> Field
+                        const auto & dispatch = [](size_t precision, size_t scale, const auto & function) -> Field
                         {
                             if (precision <= DecimalUtils::max_precision<Decimal32>)
                                 return Field(function(precision, scale, Decimal32()));
-                            else if (precision <= DecimalUtils::max_precision<Decimal64>)
+                            else if (precision <= DecimalUtils::max_precision<Decimal64>) //-V547
                                 return Field(function(precision, scale, Decimal64()));
-                            else if (precision <= DecimalUtils::max_precision<Decimal128>)
+                            else if (precision <= DecimalUtils::max_precision<Decimal128>) //-V547
                                 return Field(function(precision, scale, Decimal128()));
 
                             return Field(function(precision, scale, Decimal256()));
                         };
 
-                        const auto & read_decimal = [&](const size_t & precision, const size_t & scale, auto decimal)
+                        const auto & read_decimal = [&](size_t precision, size_t scale, auto decimal)
                         {
                             using DecimalType = decltype(decimal);
                             static constexpr size_t digits_per_integer = 9;
@@ -543,7 +543,7 @@ namespace MySQLReplication
                                     UInt32 val = 0;
                                     size_t to_read = compressed_bytes_map[compressed_decimals];
 
-                                    if (to_read)
+                                    if (to_read) //-V547
                                     {
                                         readBigEndianStrict(payload, reinterpret_cast<char *>(&val), to_read);
                                         res *= intExp10OfSize<DecimalType>(compressed_decimals);
@@ -658,12 +658,13 @@ namespace MySQLReplication
         payload.readStrict(reinterpret_cast<char *>(&commit_flag), 1);
 
         // MySQL UUID is big-endian.
-        UInt64 high = 0UL, low = 0UL;
+        UInt64 high = 0UL;
+        UInt64 low = 0UL;
         readBigEndianStrict(payload, reinterpret_cast<char *>(&low), 8);
-        gtid.uuid.toUnderType().low = low;
+        gtid.uuid.toUnderType().items[0] = low;
 
         readBigEndianStrict(payload, reinterpret_cast<char *>(&high), 8);
-        gtid.uuid.toUnderType().high = high;
+        gtid.uuid.toUnderType().items[1] = high;
 
         payload.readStrict(reinterpret_cast<char *>(&gtid.seq_no), 8);
 
diff --git a/src/Core/PostgreSQLProtocol.h b/src/Core/PostgreSQLProtocol.h
index 4c41ead7a02..9e1afcd187c 100644
--- a/src/Core/PostgreSQLProtocol.h
+++ b/src/Core/PostgreSQLProtocol.h
@@ -257,6 +257,7 @@ class FirstMessage : public FrontMessage
 {
 public:
     Int32 payload_size;
+
     FirstMessage() = delete;
     FirstMessage(int payload_size_) : payload_size(payload_size_) {}
 };
@@ -264,8 +265,9 @@ public:
 class CancelRequest : public FirstMessage
 {
 public:
-    Int32 process_id;
-    Int32 secret_key;
+    Int32 process_id = 0;
+    Int32 secret_key = 0;
+
     CancelRequest(int payload_size_) : FirstMessage(payload_size_) {}
 
     void deserialize(ReadBuffer & in) override
diff --git a/src/Core/Settings.h b/src/Core/Settings.h
index 5cf0f562626..453ec78aeee 100644
--- a/src/Core/Settings.h
+++ b/src/Core/Settings.h
@@ -101,7 +101,7 @@ class IColumn;
     M(Float, totals_auto_threshold, 0.5, "The threshold for totals_mode = 'auto'.", 0) \
     \
     M(Bool, allow_suspicious_low_cardinality_types, false, "In CREATE TABLE statement allows specifying LowCardinality modifier for types of small fixed size (8 or less). Enabling this may increase merge times and memory consumption.", 0) \
-    M(Bool, compile_expressions, false, "Compile some scalar functions and operators to native code.", 0) \
+    M(Bool, compile_expressions, true, "Compile some scalar functions and operators to native code.", 0) \
     M(UInt64, min_count_to_compile_expression, 3, "The number of identical expressions before they are JIT-compiled", 0) \
     M(UInt64, group_by_two_level_threshold, 100000, "From what number of keys, a two-level aggregation starts. 0 - the threshold is not set.", 0) \
     M(UInt64, group_by_two_level_threshold_bytes, 100000000, "From what size of the aggregation state in bytes, a two-level aggregation begins to be used. 0 - the threshold is not set. Two-level aggregation is used when at least one of the thresholds is triggered.", 0) \
diff --git a/src/Core/SettingsQuirks.cpp b/src/Core/SettingsQuirks.cpp
index 3bf9047af3a..6d584fe8906 100644
--- a/src/Core/SettingsQuirks.cpp
+++ b/src/Core/SettingsQuirks.cpp
@@ -4,9 +4,7 @@
 
 #ifdef __linux__
 #include <linux/version.h>
-#endif
 
-#ifdef __linux__
 /// Detect does epoll_wait with nested epoll fds works correctly.
 /// Polling nested epoll fds from epoll_wait is required for async_socket_for_remote and use_hedged_requests.
 ///
@@ -16,21 +14,15 @@
 ///   [2]: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=0c54a6a44bf3
 bool nestedEpollWorks(Poco::Logger * log)
 {
-    bool nested_epoll_works =
 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 5, 0)) && (LINUX_VERSION_CODE < KERNEL_VERSION(5, 6, 13))
         /// the check is correct since there will be no more 5.5.x releases.
-        false
-#else
-        true
-#endif
-    ;
-
-    if (!nested_epoll_works)
-    {
         if (log)
             LOG_WARNING(log, "Nested epoll_wait has some issues on kernels [5.5.0, 5.6.13). You should upgrade it to avoid possible issues.");
-    }
-    return nested_epoll_works;
+        return false;
+#else
+        (void)log;
+        return true;
+#endif
 }
 #else
 bool nestedEpollWorks(Poco::Logger *) { return true; }
diff --git a/src/Core/SortCursor.h b/src/Core/SortCursor.h
index 79730e9697e..dd804bd4675 100644
--- a/src/Core/SortCursor.h
+++ b/src/Core/SortCursor.h
@@ -126,7 +126,7 @@ struct SortCursorImpl
 
 /// Prevent using pos instead of getRow()
 private:
-    size_t pos;
+    size_t pos = 0;
 };
 
 using SortCursorImpls = std::vector<SortCursorImpl>;
diff --git a/src/Core/TypeListNumber.h b/src/Core/TypeListNumber.h
index 9b7c33a6007..b65bdef4e46 100644
--- a/src/Core/TypeListNumber.h
+++ b/src/Core/TypeListNumber.h
@@ -1,20 +1,18 @@
 #pragma once
 
 #include <Core/Types.h>
-#include <Common/UInt128.h>
 #include <Common/TypeList.h>
 
 namespace DB
 {
 
 using TypeListNativeNumbers = TypeList<UInt8, UInt16, UInt32, UInt64, Int8, Int16, Int32, Int64, Float32, Float64>;
-using TypeListExtendedNumbers = TypeList<Int128, UInt256, Int256>;
+using TypeListExtendedNumbers = TypeList<UInt128, Int128, UInt256, Int256>;
 using TypeListDecimalNumbers = TypeList<Decimal32, Decimal64, Decimal128, Decimal256>;
 
 using TypeListGeneralNumbers = typename TypeListConcat<TypeListNativeNumbers, TypeListExtendedNumbers>::Type;
 using TypeListNumbers = typename TypeListConcat<TypeListGeneralNumbers, TypeListDecimalNumbers>::Type;
 
-/// Currently separate because UInt128 cannot be used in every context where other numbers can be used.
-using TypeListNumbersAndUInt128 = typename AppendToTypeList<UInt128, TypeListNumbers>::Type;
+using TypeListNumbersAndUUID = typename TypeListConcat<TypeListNumbers, TypeList<UUID>>::Type;
 
 }
diff --git a/src/Core/Types.h b/src/Core/Types.h
index b9ecda4a46d..151d9bdcf5a 100644
--- a/src/Core/Types.h
+++ b/src/Core/Types.h
@@ -3,6 +3,7 @@
 #include <cstdint>
 #include <string>
 #include <vector>
+#include <common/strong_typedef.h>
 #include <common/extended_types.h>
 #include <common/defines.h>
 
@@ -63,60 +64,52 @@ enum class TypeIndex
 #pragma GCC diagnostic pop
 #endif
 
-/// Other int defines are in common/types.h
-using UInt256 = ::wUInt256;
+
+using UInt128 = ::UInt128;
+using UInt256 = ::UInt256;
 using Int128 = ::Int128;
-using Int256 = ::wInt256;
+using Int256 = ::Int256;
 
-/** Note that for types not used in DB, IsNumber is false.
-  */
-template <typename T> constexpr bool IsNumber = false;
+STRONG_TYPEDEF(UInt128, UUID)
 
-template <> inline constexpr bool IsNumber<UInt8> = true;
-template <> inline constexpr bool IsNumber<UInt16> = true;
-template <> inline constexpr bool IsNumber<UInt32> = true;
-template <> inline constexpr bool IsNumber<UInt64> = true;
-template <> inline constexpr bool IsNumber<UInt256> = true;
-template <> inline constexpr bool IsNumber<Int8> = true;
-template <> inline constexpr bool IsNumber<Int16> = true;
-template <> inline constexpr bool IsNumber<Int32> = true;
-template <> inline constexpr bool IsNumber<Int64> = true;
-template <> inline constexpr bool IsNumber<Int128> = true;
-template <> inline constexpr bool IsNumber<Int256> = true;
-template <> inline constexpr bool IsNumber<Float32> = true;
-template <> inline constexpr bool IsNumber<Float64> = true;
 
-template <typename T> struct TypeName;
+template <typename T> constexpr const char * TypeName = "";
 
-template <> struct TypeName<UInt8>   { static constexpr const char * get() { return "UInt8";   } };
-template <> struct TypeName<UInt16>  { static constexpr const char * get() { return "UInt16";  } };
-template <> struct TypeName<UInt32>  { static constexpr const char * get() { return "UInt32";  } };
-template <> struct TypeName<UInt64>  { static constexpr const char * get() { return "UInt64";  } };
-template <> struct TypeName<UInt256> { static constexpr const char * get() { return "UInt256"; } };
-template <> struct TypeName<Int8>    { static constexpr const char * get() { return "Int8";    } };
-template <> struct TypeName<Int16>   { static constexpr const char * get() { return "Int16";   } };
-template <> struct TypeName<Int32>   { static constexpr const char * get() { return "Int32";   } };
-template <> struct TypeName<Int64>   { static constexpr const char * get() { return "Int64";   } };
-template <> struct TypeName<Int128>  { static constexpr const char * get() { return "Int128";  } };
-template <> struct TypeName<Int256> { static constexpr const char * get() { return "Int256";  } };
-template <> struct TypeName<Float32> { static constexpr const char * get() { return "Float32"; } };
-template <> struct TypeName<Float64> { static constexpr const char * get() { return "Float64"; } };
-template <> struct TypeName<String>  { static constexpr const char * get() { return "String";  } };
+template <> inline constexpr const char * TypeName<UInt8> = "UInt8";
+template <> inline constexpr const char * TypeName<UInt16> = "UInt16";
+template <> inline constexpr const char * TypeName<UInt32> = "UInt32";
+template <> inline constexpr const char * TypeName<UInt64> = "UInt64";
+template <> inline constexpr const char * TypeName<UInt128> = "UInt128";
+template <> inline constexpr const char * TypeName<UInt256> = "UInt256";
+template <> inline constexpr const char * TypeName<Int8> = "Int8";
+template <> inline constexpr const char * TypeName<Int16> = "Int16";
+template <> inline constexpr const char * TypeName<Int32> = "Int32";
+template <> inline constexpr const char * TypeName<Int64> = "Int64";
+template <> inline constexpr const char * TypeName<Int128> = "Int128";
+template <> inline constexpr const char * TypeName<Int256> = "Int256";
+template <> inline constexpr const char * TypeName<Float32> = "Float32";
+template <> inline constexpr const char * TypeName<Float64> = "Float64";
+template <> inline constexpr const char * TypeName<String> = "String";
+template <> inline constexpr const char * TypeName<UUID> = "UUID";
+
+/// TODO Try to remove it.
+template <typename T> constexpr TypeIndex TypeId = TypeIndex::Nothing;
+template <> inline constexpr TypeIndex TypeId<UInt8> = TypeIndex::UInt8;
+template <> inline constexpr TypeIndex TypeId<UInt16> = TypeIndex::UInt16;
+template <> inline constexpr TypeIndex TypeId<UInt32> = TypeIndex::UInt32;
+template <> inline constexpr TypeIndex TypeId<UInt64> = TypeIndex::UInt64;
+template <> inline constexpr TypeIndex TypeId<UInt128> = TypeIndex::UInt128;
+template <> inline constexpr TypeIndex TypeId<UInt256> = TypeIndex::UInt256;
+template <> inline constexpr TypeIndex TypeId<Int8> = TypeIndex::Int8;
+template <> inline constexpr TypeIndex TypeId<Int16> = TypeIndex::Int16;
+template <> inline constexpr TypeIndex TypeId<Int32> = TypeIndex::Int32;
+template <> inline constexpr TypeIndex TypeId<Int64> = TypeIndex::Int64;
+template <> inline constexpr TypeIndex TypeId<Int128> = TypeIndex::Int128;
+template <> inline constexpr TypeIndex TypeId<Int256> = TypeIndex::Int256;
+template <> inline constexpr TypeIndex TypeId<Float32> = TypeIndex::Float32;
+template <> inline constexpr TypeIndex TypeId<Float64> = TypeIndex::Float64;
+template <> inline constexpr TypeIndex TypeId<UUID> = TypeIndex::UUID;
 
-template <typename T> struct TypeId;
-template <> struct TypeId<UInt8>    { static constexpr const TypeIndex value = TypeIndex::UInt8;  };
-template <> struct TypeId<UInt16>   { static constexpr const TypeIndex value = TypeIndex::UInt16;  };
-template <> struct TypeId<UInt32>   { static constexpr const TypeIndex value = TypeIndex::UInt32;  };
-template <> struct TypeId<UInt64>   { static constexpr const TypeIndex value = TypeIndex::UInt64;  };
-template <> struct TypeId<UInt256>  { static constexpr const TypeIndex value = TypeIndex::UInt256; };
-template <> struct TypeId<Int8>     { static constexpr const TypeIndex value = TypeIndex::Int8;  };
-template <> struct TypeId<Int16>    { static constexpr const TypeIndex value = TypeIndex::Int16; };
-template <> struct TypeId<Int32>    { static constexpr const TypeIndex value = TypeIndex::Int32; };
-template <> struct TypeId<Int64>    { static constexpr const TypeIndex value = TypeIndex::Int64; };
-template <> struct TypeId<Int128>   { static constexpr const TypeIndex value = TypeIndex::Int128; };
-template <> struct TypeId<Int256>   { static constexpr const TypeIndex value = TypeIndex::Int256; };
-template <> struct TypeId<Float32>  { static constexpr const TypeIndex value = TypeIndex::Float32;  };
-template <> struct TypeId<Float64>  { static constexpr const TypeIndex value = TypeIndex::Float64;  };
 
 /// Not a data type in database, defined just for convenience.
 using Strings = std::vector<String>;
@@ -167,6 +160,12 @@ struct Decimal
     const Decimal<T> & operator /= (const T & x) { value /= x; return *this; }
     const Decimal<T> & operator %= (const T & x) { value %= x; return *this; }
 
+    template <typename U> const Decimal<T> & operator += (const Decimal<U> & x) { value += x.value; return *this; }
+    template <typename U> const Decimal<T> & operator -= (const Decimal<U> & x) { value -= x.value; return *this; }
+    template <typename U> const Decimal<T> & operator *= (const Decimal<U> & x) { value *= x.value; return *this; }
+    template <typename U> const Decimal<T> & operator /= (const Decimal<U> & x) { value /= x.value; return *this; }
+    template <typename U> const Decimal<T> & operator %= (const Decimal<U> & x) { value %= x.value; return *this; }
+
     /// This is to avoid UB for sumWithOverflow()
     void NO_SANITIZE_UNDEFINED addOverflow(const T & x) { value += x; }
 
@@ -175,6 +174,8 @@ struct Decimal
 
 template <typename T> inline bool operator< (const Decimal<T> & x, const Decimal<T> & y) { return x.value < y.value; }
 template <typename T> inline bool operator> (const Decimal<T> & x, const Decimal<T> & y) { return x.value > y.value; }
+template <typename T> inline bool operator<= (const Decimal<T> & x, const Decimal<T> & y) { return x.value <= y.value; }
+template <typename T> inline bool operator>= (const Decimal<T> & x, const Decimal<T> & y) { return x.value >= y.value; }
 template <typename T> inline bool operator== (const Decimal<T> & x, const Decimal<T> & y) { return x.value == y.value; }
 template <typename T> inline bool operator!= (const Decimal<T> & x, const Decimal<T> & y) { return x.value != y.value; }
 
@@ -202,17 +203,17 @@ public:
     {}
 };
 
-template <> struct TypeName<Decimal32>   { static constexpr const char * get() { return "Decimal32";   } };
-template <> struct TypeName<Decimal64>   { static constexpr const char * get() { return "Decimal64";   } };
-template <> struct TypeName<Decimal128>  { static constexpr const char * get() { return "Decimal128";  } };
-template <> struct TypeName<Decimal256>  { static constexpr const char * get() { return "Decimal256";  } };
-template <> struct TypeName<DateTime64>  { static constexpr const char * get() { return "DateTime64";  } };
+template <> inline constexpr const char * TypeName<Decimal32> = "Decimal32";
+template <> inline constexpr const char * TypeName<Decimal64> = "Decimal64";
+template <> inline constexpr const char * TypeName<Decimal128> = "Decimal128";
+template <> inline constexpr const char * TypeName<Decimal256> = "Decimal256";
+template <> inline constexpr const char * TypeName<DateTime64> = "DateTime64";
 
-template <> struct TypeId<Decimal32>    { static constexpr const TypeIndex value = TypeIndex::Decimal32; };
-template <> struct TypeId<Decimal64>    { static constexpr const TypeIndex value = TypeIndex::Decimal64; };
-template <> struct TypeId<Decimal128>   { static constexpr const TypeIndex value = TypeIndex::Decimal128; };
-template <> struct TypeId<Decimal256>   { static constexpr const TypeIndex value = TypeIndex::Decimal256; };
-template <> struct TypeId<DateTime64>   { static constexpr const TypeIndex value = TypeIndex::DateTime64; };
+template <> inline constexpr TypeIndex TypeId<Decimal32> = TypeIndex::Decimal32;
+template <> inline constexpr TypeIndex TypeId<Decimal64> = TypeIndex::Decimal64;
+template <> inline constexpr TypeIndex TypeId<Decimal128> = TypeIndex::Decimal128;
+template <> inline constexpr TypeIndex TypeId<Decimal256> = TypeIndex::Decimal256;
+template <> inline constexpr TypeIndex TypeId<DateTime64> = TypeIndex::DateTime64;
 
 template <typename T> constexpr bool IsDecimalNumber = false;
 template <> inline constexpr bool IsDecimalNumber<Decimal32> = true;
@@ -229,8 +230,11 @@ template <> struct NativeType<Decimal256> { using Type = Int256; };
 template <> struct NativeType<DateTime64> { using Type = Int64; };
 
 template <typename T> constexpr bool OverBigInt = false;
+template <> inline constexpr bool OverBigInt<Int128> = true;
+template <> inline constexpr bool OverBigInt<UInt128> = true;
 template <> inline constexpr bool OverBigInt<Int256> = true;
 template <> inline constexpr bool OverBigInt<UInt256> = true;
+template <> inline constexpr bool OverBigInt<Decimal128> = true;
 template <> inline constexpr bool OverBigInt<Decimal256> = true;
 
 inline constexpr const char * getTypeName(TypeIndex idx)
@@ -238,31 +242,31 @@ inline constexpr const char * getTypeName(TypeIndex idx)
     switch (idx)
     {
         case TypeIndex::Nothing:    return "Nothing";
-        case TypeIndex::UInt8:      return TypeName<UInt8>::get();
-        case TypeIndex::UInt16:     return TypeName<UInt16>::get();
-        case TypeIndex::UInt32:     return TypeName<UInt32>::get();
-        case TypeIndex::UInt64:     return TypeName<UInt64>::get();
+        case TypeIndex::UInt8:      return "UInt8";
+        case TypeIndex::UInt16:     return "UInt16";
+        case TypeIndex::UInt32:     return "UInt32";
+        case TypeIndex::UInt64:     return "UInt64";
         case TypeIndex::UInt128:    return "UInt128";
-        case TypeIndex::UInt256:    return TypeName<UInt256>::get();
-        case TypeIndex::Int8:       return TypeName<Int8>::get();
-        case TypeIndex::Int16:      return TypeName<Int16>::get();
-        case TypeIndex::Int32:      return TypeName<Int32>::get();
-        case TypeIndex::Int64:      return TypeName<Int64>::get();
-        case TypeIndex::Int128:     return TypeName<Int128>::get();
-        case TypeIndex::Int256:     return TypeName<Int256>::get();
-        case TypeIndex::Float32:    return TypeName<Float32>::get();
-        case TypeIndex::Float64:    return TypeName<Float64>::get();
+        case TypeIndex::UInt256:    return "UInt256";
+        case TypeIndex::Int8:       return "Int8";
+        case TypeIndex::Int16:      return "Int16";
+        case TypeIndex::Int32:      return "Int32";
+        case TypeIndex::Int64:      return "Int64";
+        case TypeIndex::Int128:     return "Int128";
+        case TypeIndex::Int256:     return "Int256";
+        case TypeIndex::Float32:    return "Float32";
+        case TypeIndex::Float64:    return "Float64";
         case TypeIndex::Date:       return "Date";
         case TypeIndex::DateTime:   return "DateTime";
         case TypeIndex::DateTime64: return "DateTime64";
-        case TypeIndex::String:     return TypeName<String>::get();
+        case TypeIndex::String:     return "String";
         case TypeIndex::FixedString: return "FixedString";
         case TypeIndex::Enum8:      return "Enum8";
         case TypeIndex::Enum16:     return "Enum16";
-        case TypeIndex::Decimal32:  return TypeName<Decimal32>::get();
-        case TypeIndex::Decimal64:  return TypeName<Decimal64>::get();
-        case TypeIndex::Decimal128: return TypeName<Decimal128>::get();
-        case TypeIndex::Decimal256: return TypeName<Decimal256>::get();
+        case TypeIndex::Decimal32:  return "Decimal32";
+        case TypeIndex::Decimal64:  return "Decimal64";
+        case TypeIndex::Decimal128: return "Decimal128";
+        case TypeIndex::Decimal256: return "Decimal256";
         case TypeIndex::UUID:       return "UUID";
         case TypeIndex::Array:      return "Array";
         case TypeIndex::Tuple:      return "Tuple";
diff --git a/src/Core/UUID.cpp b/src/Core/UUID.cpp
new file mode 100644
index 00000000000..ef1e10f5063
--- /dev/null
+++ b/src/Core/UUID.cpp
@@ -0,0 +1,19 @@
+#include <Core/UUID.h>
+#include <Common/thread_local_rng.h>
+
+
+namespace DB
+{
+
+namespace UUIDHelpers
+{
+    UUID generateV4()
+    {
+        UInt128 res{thread_local_rng(), thread_local_rng()};
+        res.items[0] = (res.items[0] & 0xffffffffffff0fffull) | 0x0000000000004000ull;
+        res.items[1] = (res.items[1] & 0x3fffffffffffffffull) | 0x8000000000000000ull;
+        return UUID{res};
+    }
+}
+
+}
diff --git a/src/Core/UUID.h b/src/Core/UUID.h
index d5a6232a72b..a24dcebdc9e 100644
--- a/src/Core/UUID.h
+++ b/src/Core/UUID.h
@@ -1,25 +1,17 @@
 #pragma once
 
-#include <Common/UInt128.h>
-#include <common/strong_typedef.h>
-#include <Common/thread_local_rng.h>
+#include <Core/Types.h>
+
 
 namespace DB
 {
 
-STRONG_TYPEDEF(UInt128, UUID)
-
 namespace UUIDHelpers
 {
-    inline UUID generateV4()
-    {
-        UInt128 res{thread_local_rng(), thread_local_rng()};
-        res.low = (res.low & 0xffffffffffff0fffull) | 0x0000000000004000ull;
-        res.high = (res.high & 0x3fffffffffffffffull) | 0x8000000000000000ull;
-        return UUID{res};
-    }
+    /// Generate random UUID.
+    UUID generateV4();
 
-    const UUID Nil = UUID(UInt128(0, 0));
+    const UUID Nil{};
 }
 
 }
diff --git a/src/Core/callOnTypeIndex.h b/src/Core/callOnTypeIndex.h
index 2d6134ab9fc..520be263f9f 100644
--- a/src/Core/callOnTypeIndex.h
+++ b/src/Core/callOnTypeIndex.h
@@ -26,6 +26,7 @@ bool callOnBasicType(TypeIndex number, F && f)
             case TypeIndex::UInt16:       return f(TypePair<T, UInt16>());
             case TypeIndex::UInt32:       return f(TypePair<T, UInt32>());
             case TypeIndex::UInt64:       return f(TypePair<T, UInt64>());
+            case TypeIndex::UInt128:      return f(TypePair<T, UInt128>());
             case TypeIndex::UInt256:      return f(TypePair<T, UInt256>());
 
             case TypeIndex::Int8:         return f(TypePair<T, Int8>());
@@ -94,6 +95,7 @@ inline bool callOnBasicTypes(TypeIndex type_num1, TypeIndex type_num2, F && f)
             case TypeIndex::UInt16: return callOnBasicType<UInt16, _int, _float, _decimal, _datetime>(type_num2, std::forward<F>(f));
             case TypeIndex::UInt32: return callOnBasicType<UInt32, _int, _float, _decimal, _datetime>(type_num2, std::forward<F>(f));
             case TypeIndex::UInt64: return callOnBasicType<UInt64, _int, _float, _decimal, _datetime>(type_num2, std::forward<F>(f));
+            case TypeIndex::UInt128: return callOnBasicType<UInt128, _int, _float, _decimal, _datetime>(type_num2, std::forward<F>(f));
             case TypeIndex::UInt256: return callOnBasicType<UInt256, _int, _float, _decimal, _datetime>(type_num2, std::forward<F>(f));
 
             case TypeIndex::Int8: return callOnBasicType<Int8, _int, _float, _decimal, _datetime>(type_num2, std::forward<F>(f));
@@ -171,6 +173,7 @@ bool callOnIndexAndDataType(TypeIndex number, F && f, ExtraArgs && ... args)
         case TypeIndex::UInt16:         return f(TypePair<DataTypeNumber<UInt16>, T>(), std::forward<ExtraArgs>(args)...);
         case TypeIndex::UInt32:         return f(TypePair<DataTypeNumber<UInt32>, T>(), std::forward<ExtraArgs>(args)...);
         case TypeIndex::UInt64:         return f(TypePair<DataTypeNumber<UInt64>, T>(), std::forward<ExtraArgs>(args)...);
+        case TypeIndex::UInt128:        return f(TypePair<DataTypeNumber<UInt128>, T>(), std::forward<ExtraArgs>(args)...);
         case TypeIndex::UInt256:        return f(TypePair<DataTypeNumber<UInt256>, T>(), std::forward<ExtraArgs>(args)...);
 
         case TypeIndex::Int8:           return f(TypePair<DataTypeNumber<Int8>, T>(), std::forward<ExtraArgs>(args)...);
diff --git a/src/Core/tests/gtest_accurate_comparison.cpp b/src/Core/tests/gtest_accurate_comparison.cpp
new file mode 100644
index 00000000000..bac4ad3d72d
--- /dev/null
+++ b/src/Core/tests/gtest_accurate_comparison.cpp
@@ -0,0 +1,76 @@
+#include <gtest/gtest.h>
+#include <Core/AccurateComparison.h>
+
+using namespace DB;
+
+
+GTEST_TEST(AccurateComparison, Tests)
+{
+    /// Arbitrary assortion of cases.
+
+    ASSERT_TRUE(accurate::equalsOp(static_cast<Float32>(123), static_cast<UInt64>(123)));
+    ASSERT_TRUE(accurate::lessOp(static_cast<Float32>(123), static_cast<UInt64>(124)));
+    ASSERT_TRUE(accurate::lessOp(static_cast<Float32>(-1), static_cast<UInt64>(1)));
+    ASSERT_TRUE(accurate::lessOp(static_cast<Int64>(-1), static_cast<UInt64>(1)));
+    ASSERT_TRUE(!accurate::equalsOp(static_cast<Int64>(-1), static_cast<UInt64>(-1)));
+
+    ASSERT_TRUE(accurate::equalsOp(-0., 0));
+    ASSERT_TRUE(accurate::lessOp(-0., 1));
+    ASSERT_TRUE(accurate::lessOp(-0.5, 1));
+    ASSERT_TRUE(accurate::lessOp(0.5, 1));
+    ASSERT_TRUE(accurate::equalsOp(1.0, 1));
+    ASSERT_TRUE(accurate::greaterOp(1.1, 1));
+    ASSERT_TRUE(accurate::greaterOp(11.1, 1));
+    ASSERT_TRUE(accurate::greaterOp(11.1, 11));
+    ASSERT_TRUE(accurate::lessOp(-11.1, 11));
+    ASSERT_TRUE(accurate::lessOp(-11.1, -11));
+    ASSERT_TRUE(accurate::lessOp(-1.1, -1));
+    ASSERT_TRUE(accurate::greaterOp(-1.1, -2));
+    ASSERT_TRUE(accurate::greaterOp(1000., 100));
+    ASSERT_TRUE(accurate::greaterOp(-100., -1000));
+    ASSERT_TRUE(accurate::lessOp(100., 1000));
+    ASSERT_TRUE(accurate::lessOp(-1000., -100));
+
+    ASSERT_TRUE(accurate::lessOp(-std::numeric_limits<Float64>::infinity(), 0));
+    ASSERT_TRUE(accurate::lessOp(-std::numeric_limits<Float64>::infinity(), 1000));
+    ASSERT_TRUE(accurate::lessOp(-std::numeric_limits<Float64>::infinity(), -1000));
+    ASSERT_TRUE(accurate::greaterOp(std::numeric_limits<Float64>::infinity(), 0));
+    ASSERT_TRUE(accurate::greaterOp(std::numeric_limits<Float64>::infinity(), 1000));
+    ASSERT_TRUE(accurate::greaterOp(std::numeric_limits<Float64>::infinity(), -1000));
+
+    ASSERT_TRUE(accurate::lessOp(1, 1e100));
+    ASSERT_TRUE(accurate::lessOp(-1, 1e100));
+    ASSERT_TRUE(accurate::lessOp(-1e100, 1));
+    ASSERT_TRUE(accurate::lessOp(-1e100, -1));
+
+    /// Tricky cases with floats.
+
+    ASSERT_TRUE(accurate::equalsOp(static_cast<UInt64>(9223372036854775808ULL), static_cast<Float64>(9223372036854775808ULL)));
+    ASSERT_TRUE(accurate::equalsOp(static_cast<UInt64>(9223372036854775808ULL), static_cast<Float32>(9223372036854775808ULL)));
+
+    ASSERT_TRUE(accurate::greaterOp(static_cast<UInt64>(9223372036854776000ULL), static_cast<Float64>(9223372036854776000ULL)));
+    ASSERT_TRUE(accurate::lessOp(static_cast<UInt64>(9223372000000000000ULL), static_cast<Float32>(9223372000000000000ULL)));
+
+    ASSERT_TRUE(accurate::equalsOp(static_cast<Float32>(9223372036854775808ULL), static_cast<Float64>(9223372036854775808ULL)));
+
+    /// Integers
+
+    ASSERT_TRUE(accurate::lessOp(static_cast<UInt8>(255), 300));
+    ASSERT_TRUE(accurate::lessOp(static_cast<UInt8>(255), static_cast<Int16>(300)));
+    ASSERT_TRUE(accurate::notEqualsOp(static_cast<UInt8>(255), 44));
+    ASSERT_TRUE(accurate::notEqualsOp(static_cast<UInt8>(255), static_cast<Int16>(44)));
+
+
+/*    Float32 f = static_cast<Float32>(9223372000000000000ULL);
+    UInt64 u = static_cast<UInt64>(9223372000000000000ULL);
+    DecomposedFloat32 components(f);
+
+    std::cerr << std::fixed << std::setprecision(3) << f
+        << ", " << components.normalized_exponent()
+        << ", " << components.mantissa()
+        << ", " << (components.mantissa() << (components.normalized_exponent() - 23))
+        << ", " << (1ULL << components.normalized_exponent())
+        << ", " << (components.normalized_exponent() >= static_cast<int16_t>(8 * sizeof(UInt64) - is_signed_v<UInt64>))
+        << ": " << components.compare(u)
+        << "\n";*/
+}
diff --git a/src/DataStreams/IBlockInputStream.h b/src/DataStreams/IBlockInputStream.h
index b077f87e8a8..090ea394fd6 100644
--- a/src/DataStreams/IBlockInputStream.h
+++ b/src/DataStreams/IBlockInputStream.h
@@ -158,7 +158,7 @@ public:
 
     /** Set the approximate total number of rows to read.
       */
-    virtual void addTotalRowsApprox(size_t value) { total_rows_approx += value; }
+    void addTotalRowsApprox(size_t value) { total_rows_approx += value; }
 
 
     /** Ask to abort the receipt of data as soon as possible.
diff --git a/src/DataStreams/MongoDBBlockInputStream.cpp b/src/DataStreams/MongoDBBlockInputStream.cpp
index e4ddcd09ede..d740448e0cf 100644
--- a/src/DataStreams/MongoDBBlockInputStream.cpp
+++ b/src/DataStreams/MongoDBBlockInputStream.cpp
@@ -25,7 +25,6 @@
 // Poco/MongoDB/BSONWriter.h:54: void writeCString(const std::string & value);
 // src/IO/WriteHelpers.h:146 #define writeCString(s, buf)
 #include <IO/WriteHelpers.h>
-#include <Common/FieldVisitors.h>
 #include <ext/enumerate.h>
 
 namespace DB
@@ -290,7 +289,7 @@ namespace
                 if (value.type() == Poco::MongoDB::ElementTraits<String>::TypeId)
                 {
                     String string = static_cast<const Poco::MongoDB::ConcreteElement<String> &>(value).value();
-                    assert_cast<ColumnUInt128 &>(column).getData().push_back(parse<UUID>(string));
+                    assert_cast<ColumnUUID &>(column).getData().push_back(parse<UUID>(string));
                 }
                 else
                     throw Exception{"Type mismatch, expected String (UUID), got type id = " + toString(value.type()) + " for column "
diff --git a/src/DataStreams/NativeBlockOutputStream.cpp b/src/DataStreams/NativeBlockOutputStream.cpp
index 2a016c9a0c8..a5d8c15986b 100644
--- a/src/DataStreams/NativeBlockOutputStream.cpp
+++ b/src/DataStreams/NativeBlockOutputStream.cpp
@@ -51,7 +51,7 @@ static void writeData(const IDataType & type, const ColumnPtr & column, WriteBuf
     ISerialization::SerializeBinaryBulkSettings settings;
     settings.getter = [&ostr](ISerialization::SubstreamPath) -> WriteBuffer * { return &ostr; };
     settings.position_independent_encoding = false;
-    settings.low_cardinality_max_dictionary_size = 0;
+    settings.low_cardinality_max_dictionary_size = 0; //-V1048
 
     auto serialization = type.getDefaultSerialization();
 
diff --git a/src/DataStreams/PostgreSQLBlockInputStream.cpp b/src/DataStreams/PostgreSQLBlockInputStream.cpp
index f134ed0c693..63a8e9edb79 100644
--- a/src/DataStreams/PostgreSQLBlockInputStream.cpp
+++ b/src/DataStreams/PostgreSQLBlockInputStream.cpp
@@ -161,7 +161,7 @@ void PostgreSQLBlockInputStream::insertValue(IColumn & column, std::string_view
             assert_cast<ColumnString &>(column).insertData(value.data(), value.size());
             break;
         case ValueType::vtUUID:
-            assert_cast<ColumnUInt128 &>(column).insert(parse<UUID>(value.data(), value.size()));
+            assert_cast<ColumnUUID &>(column).insert(parse<UUID>(value.data(), value.size()));
             break;
         case ValueType::vtDate:
             assert_cast<ColumnUInt16 &>(column).insertValue(UInt16{LocalDate{std::string(value)}.getDayNum()});
@@ -210,7 +210,8 @@ void PostgreSQLBlockInputStream::insertValue(IColumn & column, std::string_view
                 {
                     max_dimension = std::max(max_dimension, dimension);
 
-                    if (--dimension == 0)
+                    --dimension;
+                    if (dimension == 0)
                         break;
 
                     dimensions[dimension].emplace_back(Array(dimensions[dimension + 1].begin(), dimensions[dimension + 1].end()));
diff --git a/src/DataStreams/PushingToViewsBlockOutputStream.cpp b/src/DataStreams/PushingToViewsBlockOutputStream.cpp
index 16baf4377e0..c09420cab6f 100644
--- a/src/DataStreams/PushingToViewsBlockOutputStream.cpp
+++ b/src/DataStreams/PushingToViewsBlockOutputStream.cpp
@@ -63,7 +63,7 @@ PushingToViewsBlockOutputStream::PushingToViewsBlockOutputStream(
 
         // Do not deduplicate insertions into MV if the main insertion is Ok
         if (disable_deduplication_for_children)
-            insert_context->setSetting("insert_deduplicate", false);
+            insert_context->setSetting("insert_deduplicate", Field{false});
 
         // Separate min_insert_block_size_rows/min_insert_block_size_bytes for children
         if (insert_settings.min_insert_block_size_rows_for_materialized_views)
diff --git a/src/DataTypes/DataTypeCustomSimpleAggregateFunction.h b/src/DataTypes/DataTypeCustomSimpleAggregateFunction.h
index 44b007ab07f..dc054144e14 100644
--- a/src/DataTypes/DataTypeCustomSimpleAggregateFunction.h
+++ b/src/DataTypes/DataTypeCustomSimpleAggregateFunction.h
@@ -2,7 +2,6 @@
 
 #include <DataTypes/DataTypeCustom.h>
 #include <AggregateFunctions/IAggregateFunction.h>
-#include <Common/FieldVisitors.h>
 
 #include <IO/ReadHelpers.h>
 
diff --git a/src/DataTypes/DataTypeDecimalBase.h b/src/DataTypes/DataTypeDecimalBase.h
index 9e44310a0ff..aea837f890f 100644
--- a/src/DataTypes/DataTypeDecimalBase.h
+++ b/src/DataTypes/DataTypeDecimalBase.h
@@ -76,7 +76,7 @@ public:
             throw Exception("Scale " + std::to_string(scale) + " is out of bounds", ErrorCodes::ARGUMENT_OUT_OF_BOUND);
     }
 
-    TypeIndex getTypeId() const override { return TypeId<T>::value; }
+    TypeIndex getTypeId() const override { return TypeId<T>; }
 
     Field getDefault() const override;
     MutableColumnPtr createColumn() const override;
@@ -113,15 +113,15 @@ public:
 
     T maxWholeValue() const { return getScaleMultiplier(precision - scale) - T(1); }
 
-    template<typename U>
+    template <typename U>
     bool canStoreWhole(U x) const
     {
-        static_assert(std::is_signed_v<typename T::NativeType>);
+        static_assert(is_signed_v<typename T::NativeType>);
         T max = maxWholeValue();
-        if constexpr (std::is_signed_v<U>)
-            return -max <= x && x <= max;
+        if constexpr (is_signed_v<U>)
+            return -max.value <= x && x <= max.value;
         else
-            return x <= static_cast<std::make_unsigned_t<typename T::NativeType>>(max.value);
+            return x <= static_cast<make_unsigned_t<typename T::NativeType>>(max.value);
     }
 
     /// @returns multiplier for U to become T with correct scale
diff --git a/src/DataTypes/DataTypeLowCardinality.cpp b/src/DataTypes/DataTypeLowCardinality.cpp
index 485083d67ee..95a5addf62a 100644
--- a/src/DataTypes/DataTypeLowCardinality.cpp
+++ b/src/DataTypes/DataTypeLowCardinality.cpp
@@ -79,6 +79,8 @@ MutableColumnUniquePtr DataTypeLowCardinality::createColumnUniqueImpl(const IDat
         return creator(static_cast<ColumnVector<UInt16> *>(nullptr));
     else if (which.isDateTime())
         return creator(static_cast<ColumnVector<UInt32> *>(nullptr));
+    else if (which.isUUID())
+        return creator(static_cast<ColumnVector<UUID> *>(nullptr));
     else if (which.isInt() || which.isUInt() || which.isFloat())
     {
         MutableColumnUniquePtr column;
diff --git a/src/DataTypes/DataTypeMap.cpp b/src/DataTypes/DataTypeMap.cpp
index 1d580761362..b09a5e9e590 100644
--- a/src/DataTypes/DataTypeMap.cpp
+++ b/src/DataTypes/DataTypeMap.cpp
@@ -55,9 +55,12 @@ DataTypeMap::DataTypeMap(const DataTypePtr & key_type_, const DataTypePtr & valu
 
 void DataTypeMap::assertKeyType() const
 {
-    if (!key_type->isValueRepresentedByInteger() && !isStringOrFixedString(*key_type) && !WhichDataType(key_type).isNothing())
+    if (!key_type->isValueRepresentedByInteger()
+        && !isStringOrFixedString(*key_type)
+        && !WhichDataType(key_type).isNothing()
+        && !WhichDataType(key_type).isUUID())
         throw Exception(ErrorCodes::BAD_ARGUMENTS,
-            "Type of Map key must be a type, that can be represented by integer or string,"
+            "Type of Map key must be a type, that can be represented by integer or string or UUID,"
             " but {} given", key_type->getName());
 }
 
diff --git a/src/DataTypes/DataTypeNumberBase.cpp b/src/DataTypes/DataTypeNumberBase.cpp
index a9df7db7334..12d1989a9d6 100644
--- a/src/DataTypes/DataTypeNumberBase.cpp
+++ b/src/DataTypes/DataTypeNumberBase.cpp
@@ -43,7 +43,7 @@ template class DataTypeNumberBase<UInt8>;
 template class DataTypeNumberBase<UInt16>;
 template class DataTypeNumberBase<UInt32>;
 template class DataTypeNumberBase<UInt64>;
-template class DataTypeNumberBase<UInt128>; // base for UUID
+template class DataTypeNumberBase<UInt128>;
 template class DataTypeNumberBase<UInt256>;
 template class DataTypeNumberBase<Int8>;
 template class DataTypeNumberBase<Int16>;
diff --git a/src/DataTypes/DataTypeNumberBase.h b/src/DataTypes/DataTypeNumberBase.h
index 97c3563b032..c24778691d9 100644
--- a/src/DataTypes/DataTypeNumberBase.h
+++ b/src/DataTypes/DataTypeNumberBase.h
@@ -1,6 +1,5 @@
 #pragma once
 
-#include <Common/UInt128.h>
 #include <DataTypes/IDataType.h>
 #include <DataTypes/Serializations/SerializationNumber.h>
 
@@ -16,19 +15,17 @@ class ColumnVector;
 template <typename T>
 class DataTypeNumberBase : public IDataType
 {
-    static_assert(IsNumber<T>);
+    static_assert(is_arithmetic_v<T>);
 
 public:
     static constexpr bool is_parametric = false;
+    static constexpr auto family_name = TypeName<T>;
 
     using FieldType = T;
-    static constexpr auto type_id = TypeId<T>::value;
-    static constexpr auto family_name = TypeName<T>::get();
-
     using ColumnType = ColumnVector<T>;
 
-    const char * getFamilyName() const override { return family_name; }
-    TypeIndex getTypeId() const override { return type_id; }
+    const char * getFamilyName() const override { return TypeName<T>; }
+    TypeIndex getTypeId() const override { return TypeId<T>; }
 
     Field getDefault() const override;
 
@@ -63,7 +60,7 @@ extern template class DataTypeNumberBase<UInt8>;
 extern template class DataTypeNumberBase<UInt16>;
 extern template class DataTypeNumberBase<UInt32>;
 extern template class DataTypeNumberBase<UInt64>;
-extern template class DataTypeNumberBase<UInt128>; // base for UUID
+extern template class DataTypeNumberBase<UInt128>;
 extern template class DataTypeNumberBase<UInt256>;
 extern template class DataTypeNumberBase<Int16>;
 extern template class DataTypeNumberBase<Int8>;
diff --git a/src/DataTypes/DataTypeUUID.cpp b/src/DataTypes/DataTypeUUID.cpp
index 387ccc56a71..44182a700b4 100644
--- a/src/DataTypes/DataTypeUUID.cpp
+++ b/src/DataTypes/DataTypeUUID.cpp
@@ -16,6 +16,16 @@ SerializationPtr DataTypeUUID::doGetDefaultSerialization() const
     return std::make_shared<SerializationUUID>();
 }
 
+Field DataTypeUUID::getDefault() const
+{
+    return UUID{};
+}
+
+MutableColumnPtr DataTypeUUID::createColumn() const
+{
+    return ColumnVector<UUID>::create();
+}
+
 void registerDataTypeUUID(DataTypeFactory & factory)
 {
     factory.registerSimpleDataType("UUID", [] { return DataTypePtr(std::make_shared<DataTypeUUID>()); });
diff --git a/src/DataTypes/DataTypeUUID.h b/src/DataTypes/DataTypeUUID.h
index 1546ca385a4..70104a03478 100644
--- a/src/DataTypes/DataTypeUUID.h
+++ b/src/DataTypes/DataTypeUUID.h
@@ -1,26 +1,44 @@
 #pragma once
 
-#include <Common/UInt128.h>
-#include <DataTypes/DataTypeNumberBase.h>
 #include <DataTypes/IDataType.h>
+#include <Columns/ColumnVector.h>
+#include <Core/UUID.h>
+
 
 namespace DB
 {
 
-class DataTypeUUID final : public DataTypeNumberBase<UInt128>
+class DataTypeUUID : public IDataType
 {
-
 public:
+    static constexpr bool is_parametric = false;
+
+    using FieldType = UUID;
+    using ColumnType = ColumnVector<UUID>;
+
     const char * getFamilyName() const override { return "UUID"; }
     TypeIndex getTypeId() const override { return TypeIndex::UUID; }
 
+    Field getDefault() const override;
+
+    MutableColumnPtr createColumn() const override;
+
+    bool isParametric() const override { return false; }
+    bool haveSubtypes() const override { return false; }
+
     bool equals(const IDataType & rhs) const override;
 
     bool canBeUsedInBitOperations() const override { return true; }
     bool canBeInsideNullable() const override { return true; }
-    bool canBeInsideLowCardinality() const override { return false; }
-
     bool canBePromoted() const override { return false; }
+    bool shouldAlignRightInPrettyFormats() const override { return false; }
+    bool textCanContainOnlyValidUTF8() const override { return true; }
+    bool isComparable() const override { return true; }
+    bool isValueUnambiguouslyRepresentedInContiguousMemoryRegion() const override { return true; }
+    bool haveMaximumSizeOfValue() const override { return true; }
+    size_t getSizeOfValueInMemory() const override { return sizeof(UUID); }
+    bool isCategorial() const override { return true; }
+    bool canBeInsideLowCardinality() const override { return true; }
 
     SerializationPtr doGetDefaultSerialization() const override;
 };
diff --git a/src/DataTypes/DataTypesDecimal.h b/src/DataTypes/DataTypesDecimal.h
index 5aeac78b2ef..f08bdb80d41 100644
--- a/src/DataTypes/DataTypesDecimal.h
+++ b/src/DataTypes/DataTypesDecimal.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <common/arithmeticOverflow.h>
+#include <common/extended_types.h>
 #include <Common/typeid_cast.h>
 #include <DataTypes/IDataType.h>
 #include <DataTypes/DataTypeDecimalBase.h>
@@ -38,7 +39,7 @@ public:
 
     const char * getFamilyName() const override { return family_name; }
     std::string doGetName() const override;
-    TypeIndex getTypeId() const override { return TypeId<T>::value; }
+    TypeIndex getTypeId() const override { return TypeId<T>; }
     bool canBePromoted() const override { return true; }
     DataTypePtr promoteNumericType() const override;
 
@@ -150,7 +151,7 @@ tryConvertDecimals(const typename FromDataType::FieldType & value, UInt32 scale_
 }
 
 template <typename FromDataType, typename ToDataType, typename ReturnType>
-inline std::enable_if_t<IsDataTypeDecimal<FromDataType> && IsNumber<typename ToDataType::FieldType>, ReturnType>
+inline std::enable_if_t<IsDataTypeDecimal<FromDataType> && is_arithmetic_v<typename ToDataType::FieldType>, ReturnType>
 convertFromDecimalImpl(const typename FromDataType::FieldType & value, UInt32 scale, typename ToDataType::FieldType& result)
 {
     using FromFieldType = typename FromDataType::FieldType;
@@ -160,7 +161,7 @@ convertFromDecimalImpl(const typename FromDataType::FieldType & value, UInt32 sc
 }
 
 template <typename FromDataType, typename ToDataType>
-inline std::enable_if_t<IsDataTypeDecimal<FromDataType> && IsNumber<typename ToDataType::FieldType>, typename ToDataType::FieldType>
+inline std::enable_if_t<IsDataTypeDecimal<FromDataType> && is_arithmetic_v<typename ToDataType::FieldType>, typename ToDataType::FieldType>
 convertFromDecimal(const typename FromDataType::FieldType & value, UInt32 scale)
 {
     typename ToDataType::FieldType result;
@@ -171,14 +172,14 @@ convertFromDecimal(const typename FromDataType::FieldType & value, UInt32 scale)
 }
 
 template <typename FromDataType, typename ToDataType>
-inline std::enable_if_t<IsDataTypeDecimal<FromDataType> && IsNumber<typename ToDataType::FieldType>, bool>
+inline std::enable_if_t<IsDataTypeDecimal<FromDataType> && is_arithmetic_v<typename ToDataType::FieldType>, bool>
 tryConvertFromDecimal(const typename FromDataType::FieldType & value, UInt32 scale, typename ToDataType::FieldType& result)
 {
     return convertFromDecimalImpl<FromDataType, ToDataType, bool>(value, scale, result);
 }
 
 template <typename FromDataType, typename ToDataType, typename ReturnType>
-inline std::enable_if_t<IsNumber<typename FromDataType::FieldType> && IsDataTypeDecimal<ToDataType>, ReturnType>
+inline std::enable_if_t<is_arithmetic_v<typename FromDataType::FieldType> && IsDataTypeDecimal<ToDataType>, ReturnType>
 convertToDecimalImpl(const typename FromDataType::FieldType & value, UInt32 scale, typename ToDataType::FieldType& result)
 {
     using FromFieldType = typename FromDataType::FieldType;
@@ -199,35 +200,18 @@ convertToDecimalImpl(const typename FromDataType::FieldType & value, UInt32 scal
         }
 
         auto out = value * static_cast<FromFieldType>(DecimalUtils::scaleMultiplier<ToNativeType>(scale));
-        if constexpr (std::is_same_v<ToNativeType, Int128>)
-        {
-            static constexpr Int128 min_int128 = minInt128();
-            static constexpr Int128 max_int128 = maxInt128();
 
-            if (out <= static_cast<ToNativeType>(min_int128) || out >= static_cast<ToNativeType>(max_int128))
-            {
-                if constexpr (throw_exception)
-                    throw Exception(std::string(ToDataType::family_name) + " convert overflow. Float is out of Decimal range",
-                                    ErrorCodes::DECIMAL_OVERFLOW);
-                else
-                    return ReturnType(false);
-            }
-        }
-        else
+        if (out <= static_cast<FromFieldType>(std::numeric_limits<ToNativeType>::min()) ||
+            out >= static_cast<FromFieldType>(std::numeric_limits<ToNativeType>::max()))
         {
-            if (out <= static_cast<FromFieldType>(std::numeric_limits<ToNativeType>::min()) ||
-                out >= static_cast<FromFieldType>(std::numeric_limits<ToNativeType>::max()))
-            {
-                if constexpr (throw_exception)
-                    throw Exception(std::string(ToDataType::family_name) + " convert overflow. Float is out of Decimal range",
-                                    ErrorCodes::DECIMAL_OVERFLOW);
-                else
-                    return ReturnType(false);
-            }
+            if constexpr (throw_exception)
+                throw Exception(std::string(ToDataType::family_name) + " convert overflow. Float is out of Decimal range",
+                                ErrorCodes::DECIMAL_OVERFLOW);
+            else
+                return ReturnType(false);
         }
 
         result = static_cast<ToNativeType>(out);
-
         return ReturnType(true);
     }
     else
@@ -235,25 +219,23 @@ convertToDecimalImpl(const typename FromDataType::FieldType & value, UInt32 scal
         if constexpr (is_big_int_v<FromFieldType>)
             return ReturnType(convertDecimalsImpl<DataTypeDecimal<Decimal256>, ToDataType, ReturnType>(static_cast<Int256>(value), 0, scale, result));
         else if constexpr (std::is_same_v<FromFieldType, UInt64>)
-            return ReturnType(convertDecimalsImpl<DataTypeDecimal<Decimal128>, ToDataType, ReturnType>(value, 0, scale, result));
+            return ReturnType(convertDecimalsImpl<DataTypeDecimal<Decimal128>, ToDataType, ReturnType>(static_cast<Int128>(value), 0, scale, result));
         else
-            return ReturnType(convertDecimalsImpl<DataTypeDecimal<Decimal64>, ToDataType, ReturnType>(value, 0, scale, result));
+            return ReturnType(convertDecimalsImpl<DataTypeDecimal<Decimal64>, ToDataType, ReturnType>(static_cast<Int64>(value), 0, scale, result));
     }
 }
 
 template <typename FromDataType, typename ToDataType>
-inline std::enable_if_t<IsNumber<typename FromDataType::FieldType> && IsDataTypeDecimal<ToDataType>, typename ToDataType::FieldType>
+inline std::enable_if_t<is_arithmetic_v<typename FromDataType::FieldType> && IsDataTypeDecimal<ToDataType>, typename ToDataType::FieldType>
 convertToDecimal(const typename FromDataType::FieldType & value, UInt32 scale)
 {
     typename ToDataType::FieldType result;
-
     convertToDecimalImpl<FromDataType, ToDataType, void>(value, scale, result);
-
     return result;
 }
 
 template <typename FromDataType, typename ToDataType>
-inline std::enable_if_t<IsNumber<typename FromDataType::FieldType> && IsDataTypeDecimal<ToDataType>, bool>
+inline std::enable_if_t<is_arithmetic_v<typename FromDataType::FieldType> && IsDataTypeDecimal<ToDataType>, bool>
 tryConvertToDecimal(const typename FromDataType::FieldType & value, UInt32 scale, typename ToDataType::FieldType& result)
 {
     return convertToDecimalImpl<FromDataType, ToDataType, bool>(value, scale, result);
diff --git a/src/DataTypes/DataTypesNumber.cpp b/src/DataTypes/DataTypesNumber.cpp
index 5cfffa878f2..6a1aed888c9 100644
--- a/src/DataTypes/DataTypesNumber.cpp
+++ b/src/DataTypes/DataTypesNumber.cpp
@@ -21,12 +21,12 @@ static DataTypePtr createNumericDataType(const ASTPtr & arguments)
         if (std::is_integral_v<T>)
         {
             if (arguments->children.size() > 1)
-                throw Exception(String(TypeName<T>::get()) + " data type family must not have more than one argument - display width", ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
+                throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH, "{} data type family must not have more than one argument - display width", TypeName<T>);
         }
         else
         {
             if (arguments->children.size() > 2)
-                throw Exception(String(TypeName<T>::get()) + " data type family must not have more than two arguments - total number of digits and number of digits following the decimal point", ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
+                throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH, "{} data type family must not have more than two arguments - total number of digits and number of digits following the decimal point", TypeName<T>);
         }
     }
     return std::make_shared<DataTypeNumber<T>>();
@@ -44,10 +44,13 @@ void registerDataTypeNumbers(DataTypeFactory & factory)
     factory.registerDataType("Int16", createNumericDataType<Int16>);
     factory.registerDataType("Int32", createNumericDataType<Int32>);
     factory.registerDataType("Int64", createNumericDataType<Int64>);
+
     factory.registerDataType("Float32", createNumericDataType<Float32>);
     factory.registerDataType("Float64", createNumericDataType<Float64>);
 
+    factory.registerSimpleDataType("UInt128", [] { return DataTypePtr(std::make_shared<DataTypeUInt128>()); });
     factory.registerSimpleDataType("UInt256", [] { return DataTypePtr(std::make_shared<DataTypeUInt256>()); });
+
     factory.registerSimpleDataType("Int128", [] { return DataTypePtr(std::make_shared<DataTypeInt128>()); });
     factory.registerSimpleDataType("Int256", [] { return DataTypePtr(std::make_shared<DataTypeInt256>()); });
 
diff --git a/src/DataTypes/DataTypesNumber.h b/src/DataTypes/DataTypesNumber.h
index 79272756465..9f026e06127 100644
--- a/src/DataTypes/DataTypesNumber.h
+++ b/src/DataTypes/DataTypesNumber.h
@@ -44,6 +44,7 @@ using DataTypeInt64 = DataTypeNumber<Int64>;
 using DataTypeFloat32 = DataTypeNumber<Float32>;
 using DataTypeFloat64 = DataTypeNumber<Float64>;
 
+using DataTypeUInt128 = DataTypeNumber<UInt128>;
 using DataTypeInt128 = DataTypeNumber<Int128>;
 using DataTypeUInt256 = DataTypeNumber<UInt256>;
 using DataTypeInt256 = DataTypeNumber<Int256>;
diff --git a/src/DataTypes/FieldToDataType.cpp b/src/DataTypes/FieldToDataType.cpp
index 95f03385121..a8d439612f5 100644
--- a/src/DataTypes/FieldToDataType.cpp
+++ b/src/DataTypes/FieldToDataType.cpp
@@ -1,4 +1,3 @@
-#include <Common/FieldVisitors.h>
 #include <DataTypes/FieldToDataType.h>
 #include <DataTypes/DataTypeTuple.h>
 #include <DataTypes/DataTypeMap.h>
@@ -8,6 +7,7 @@
 #include <DataTypes/DataTypeArray.h>
 #include <DataTypes/DataTypeNullable.h>
 #include <DataTypes/DataTypeNothing.h>
+#include <DataTypes/DataTypeUUID.h>
 #include <DataTypes/getLeastSupertype.h>
 #include <DataTypes/DataTypeFactory.h>
 #include <Common/Exception.h>
@@ -20,7 +20,6 @@ namespace DB
 namespace ErrorCodes
 {
     extern const int EMPTY_DATA_PASSED;
-    extern const int NOT_IMPLEMENTED;
 }
 
 
@@ -37,11 +36,6 @@ DataTypePtr FieldToDataType::operator() (const UInt64 & x) const
     return std::make_shared<DataTypeUInt64>();
 }
 
-DataTypePtr FieldToDataType::operator() (const UInt128 &) const
-{
-    throw Exception("There are no UInt128 literals in SQL", ErrorCodes::NOT_IMPLEMENTED);
-}
-
 DataTypePtr FieldToDataType::operator() (const Int64 & x) const
 {
     if (x <= std::numeric_limits<Int8>::max() && x >= std::numeric_limits<Int8>::min()) return std::make_shared<DataTypeInt8>();
@@ -50,20 +44,36 @@ DataTypePtr FieldToDataType::operator() (const Int64 & x) const
     return std::make_shared<DataTypeInt64>();
 }
 
-DataTypePtr FieldToDataType::operator() (const Int128 & x) const
-{
-    if (x <= std::numeric_limits<Int8>::max() && x >= std::numeric_limits<Int8>::min()) return std::make_shared<DataTypeInt8>();
-    if (x <= std::numeric_limits<Int16>::max() && x >= std::numeric_limits<Int16>::min()) return std::make_shared<DataTypeInt16>();
-    if (x <= std::numeric_limits<Int32>::max() && x >= std::numeric_limits<Int32>::min()) return std::make_shared<DataTypeInt32>();
-    if (x <= std::numeric_limits<Int64>::max() && x >= std::numeric_limits<Int64>::min()) return std::make_shared<DataTypeInt64>();
-    return std::make_shared<DataTypeInt128>();
-}
-
 DataTypePtr FieldToDataType::operator() (const Float64 &) const
 {
     return std::make_shared<DataTypeFloat64>();
 }
 
+DataTypePtr FieldToDataType::operator() (const UInt128 &) const
+{
+    return std::make_shared<DataTypeUInt128>();
+}
+
+DataTypePtr FieldToDataType::operator() (const Int128 &) const
+{
+    return std::make_shared<DataTypeInt128>();
+}
+
+DataTypePtr FieldToDataType::operator() (const UInt256 &) const
+{
+    return std::make_shared<DataTypeUInt256>();
+}
+
+DataTypePtr FieldToDataType::operator() (const Int256 &) const
+{
+    return std::make_shared<DataTypeInt256>();
+}
+
+DataTypePtr FieldToDataType::operator() (const UUID &) const
+{
+    return std::make_shared<DataTypeUUID>();
+}
+
 DataTypePtr FieldToDataType::operator() (const String &) const
 {
     return std::make_shared<DataTypeString>();
@@ -143,14 +153,4 @@ DataTypePtr FieldToDataType::operator() (const AggregateFunctionStateData & x) c
     return DataTypeFactory::instance().get(name);
 }
 
-DataTypePtr FieldToDataType::operator() (const UInt256 &) const
-{
-    throw Exception("There are no UInt256 literals in SQL", ErrorCodes::NOT_IMPLEMENTED);
-}
-
-DataTypePtr FieldToDataType::operator() (const Int256 &) const
-{
-    throw Exception("There are no Int256 literals in SQL", ErrorCodes::NOT_IMPLEMENTED);
-}
-
 }
diff --git a/src/DataTypes/FieldToDataType.h b/src/DataTypes/FieldToDataType.h
index 39457564a2f..ca83ce868fc 100644
--- a/src/DataTypes/FieldToDataType.h
+++ b/src/DataTypes/FieldToDataType.h
@@ -1,5 +1,8 @@
 #pragma once
 
+#include <memory>
+#include <Core/Types.h>
+#include <Core/Field.h>
 #include <Common/FieldVisitors.h>
 
 
@@ -20,8 +23,11 @@ public:
     DataTypePtr operator() (const Null & x) const;
     DataTypePtr operator() (const UInt64 & x) const;
     DataTypePtr operator() (const UInt128 & x) const;
+    DataTypePtr operator() (const UInt256 & x) const;
     DataTypePtr operator() (const Int64 & x) const;
     DataTypePtr operator() (const Int128 & x) const;
+    DataTypePtr operator() (const Int256 & x) const;
+    DataTypePtr operator() (const UUID & x) const;
     DataTypePtr operator() (const Float64 & x) const;
     DataTypePtr operator() (const String & x) const;
     DataTypePtr operator() (const Array & x) const;
@@ -32,8 +38,6 @@ public:
     DataTypePtr operator() (const DecimalField<Decimal128> & x) const;
     DataTypePtr operator() (const DecimalField<Decimal256> & x) const;
     DataTypePtr operator() (const AggregateFunctionStateData & x) const;
-    DataTypePtr operator() (const UInt256 & x) const;
-    DataTypePtr operator() (const Int256 & x) const;
 };
 
 }
diff --git a/src/DataTypes/IDataType.h b/src/DataTypes/IDataType.h
index 5a676819b77..4602083f488 100644
--- a/src/DataTypes/IDataType.h
+++ b/src/DataTypes/IDataType.h
@@ -342,7 +342,7 @@ struct WhichDataType
     constexpr bool isFunction() const { return idx == TypeIndex::Function; }
     constexpr bool isAggregateFunction() const { return idx == TypeIndex::AggregateFunction; }
 
-    constexpr bool IsBigIntOrDeimal() const { return isInt128() || isInt256() || isUInt256() || isDecimal256(); }
+    constexpr bool IsBigIntOrDeimal() const { return isInt128() || isUInt128() || isInt256() || isUInt256() || isDecimal256(); }
 };
 
 /// IDataType helpers (alternative for IDataType virtual methods with single point of truth)
@@ -430,7 +430,7 @@ template <typename T, typename DataType>
 inline bool isColumnedAsDecimalT(const DataType & data_type)
 {
     const WhichDataType which(data_type);
-    return (which.isDecimal() || which.isDateTime64()) && which.idx == TypeId<T>::value;
+    return (which.isDecimal() || which.isDateTime64()) && which.idx == TypeId<T>;
 }
 
 template <typename T>
@@ -469,19 +469,6 @@ inline bool isCompilableType(const DataTypePtr & data_type)
     return data_type->isValueRepresentedByNumber() && !isDecimal(data_type);
 }
 
-template <TypeIndex TYPE_IDX, typename DataType>
-inline bool isDataType(const DataType & data_type)
-{
-    WhichDataType which(data_type);
-    return which.idx == TYPE_IDX;
-}
-
-template <typename ExpectedDataType, typename DataType>
-inline bool isDataType(const DataType & data_type)
-{
-    return isDataType<ExpectedDataType::type_id>(data_type);
-}
-
 template <typename DataType> constexpr bool IsDataTypeDecimal = false;
 template <typename DataType> constexpr bool IsDataTypeNumber = false;
 template <typename DataType> constexpr bool IsDataTypeDateOrDateTime = false;
diff --git a/src/DataTypes/Native.h b/src/DataTypes/Native.h
index 754365dfc87..a31b0c7483c 100644
--- a/src/DataTypes/Native.h
+++ b/src/DataTypes/Native.h
@@ -5,15 +5,13 @@
 #endif
 
 #if USE_EMBEDDED_COMPILER
-#    include <DataTypes/DataTypeDate.h>
-#    include <DataTypes/DataTypeDateTime.h>
-#    include <DataTypes/DataTypeFixedString.h>
-#    include <DataTypes/DataTypeInterval.h>
-#    include <DataTypes/DataTypeNullable.h>
-#    include <DataTypes/DataTypeUUID.h>
-#    include <DataTypes/DataTypesNumber.h>
-#    include <Common/typeid_cast.h>
+#    include <Common/Exception.h>
 
+#    include <DataTypes/IDataType.h>
+#    include <DataTypes/DataTypeNullable.h>
+#    include <DataTypes/DataTypeFixedString.h>
+#    include <Columns/ColumnConst.h>
+#    include <Columns/ColumnNullable.h>
 #    pragma GCC diagnostic push
 #    pragma GCC diagnostic ignored "-Wunused-parameter"
 
@@ -29,60 +27,56 @@ namespace ErrorCodes
     extern const int NOT_IMPLEMENTED;
 }
 
-template <typename... Ts>
-static inline bool typeIsEither(const IDataType & type)
-{
-    return (typeid_cast<const Ts *>(&type) || ...);
-}
-
 static inline bool typeIsSigned(const IDataType & type)
 {
-    return typeIsEither<
-        DataTypeInt8, DataTypeInt16, DataTypeInt32, DataTypeInt64,
-        DataTypeFloat32, DataTypeFloat64, DataTypeInterval
-    >(type);
+    WhichDataType data_type(type);
+    return data_type.isNativeInt() || data_type.isFloat();
 }
 
 static inline llvm::Type * toNativeType(llvm::IRBuilderBase & builder, const IDataType & type)
 {
-    if (auto * nullable = typeid_cast<const DataTypeNullable *>(&type))
+    WhichDataType data_type(type);
+
+    if (data_type.isNullable())
     {
-        auto * wrapped = toNativeType(builder, *nullable->getNestedType());
+        const auto & data_type_nullable = static_cast<const DataTypeNullable&>(type);
+        auto * wrapped = toNativeType(builder, *data_type_nullable.getNestedType());
         return wrapped ? llvm::StructType::get(wrapped, /* is null = */ builder.getInt1Ty()) : nullptr;
     }
+
     /// LLVM doesn't have unsigned types, it has unsigned instructions.
-    if (typeIsEither<DataTypeInt8, DataTypeUInt8>(type))
+    if (data_type.isInt8() || data_type.isUInt8())
         return builder.getInt8Ty();
-    if (typeIsEither<DataTypeInt16, DataTypeUInt16, DataTypeDate>(type))
+    else if (data_type.isInt16() || data_type.isUInt16() || data_type.isDate())
         return builder.getInt16Ty();
-    if (typeIsEither<DataTypeInt32, DataTypeUInt32, DataTypeDateTime>(type))
+    else if (data_type.isInt32() || data_type.isUInt32() || data_type.isDateTime())
         return builder.getInt32Ty();
-    if (typeIsEither<DataTypeInt64, DataTypeUInt64, DataTypeInterval>(type))
+    else if (data_type.isInt64() || data_type.isUInt64())
         return builder.getInt64Ty();
-    if (typeIsEither<DataTypeUUID>(type))
-        return builder.getInt128Ty();
-    if (typeIsEither<DataTypeFloat32>(type))
+    else if (data_type.isFloat32())
         return builder.getFloatTy();
-    if (typeIsEither<DataTypeFloat64>(type))
+    else if (data_type.isFloat64())
         return builder.getDoubleTy();
-    if (auto * fixed_string = typeid_cast<const DataTypeFixedString *>(&type))
-        return llvm::VectorType::get(builder.getInt8Ty(), fixed_string->getN());
+    else if (data_type.isFixedString())
+    {
+        const auto & data_type_fixed_string = static_cast<const DataTypeFixedString &>(type);
+        return llvm::VectorType::get(builder.getInt8Ty(), data_type_fixed_string.getN());
+    }
+
     return nullptr;
 }
 
 static inline bool canBeNativeType(const IDataType & type)
 {
-    if (auto * nullable = typeid_cast<const DataTypeNullable *>(&type))
-        return canBeNativeType(*nullable->getNestedType());
+    WhichDataType data_type(type);
 
-    return typeIsEither<DataTypeInt8, DataTypeUInt8>(type)
-        || typeIsEither<DataTypeInt16, DataTypeUInt16, DataTypeDate>(type)
-        || typeIsEither<DataTypeInt32, DataTypeUInt32, DataTypeDateTime>(type)
-        || typeIsEither<DataTypeInt64, DataTypeUInt64, DataTypeInterval>(type)
-        || typeIsEither<DataTypeUUID>(type)
-        || typeIsEither<DataTypeFloat32>(type)
-        || typeIsEither<DataTypeFloat64>(type)
-        || typeid_cast<const DataTypeFixedString *>(&type);
+    if (data_type.isNullable())
+    {
+        const auto & data_type_nullable = static_cast<const DataTypeNullable&>(type);
+        return canBeNativeType(*data_type_nullable.getNestedType());
+    }
+
+    return data_type.isNativeInt() || data_type.isNativeUInt() || data_type.isFloat() || data_type.isFixedString() || data_type.isDate();
 }
 
 static inline llvm::Type * toNativeType(llvm::IRBuilderBase & builder, const DataTypePtr & type)
@@ -102,45 +96,98 @@ static inline llvm::Value * nativeBoolCast(llvm::IRBuilder<> & b, const DataType
         return b.CreateICmpNE(value, zero);
     if (value->getType()->isFloatingPointTy())
         return b.CreateFCmpONE(value, zero); /// QNaN is false
-    throw Exception("Cannot cast non-number " + from->getName() + " to bool", ErrorCodes::NOT_IMPLEMENTED);
+
+    throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Cannot cast non-number {} to bool", from->getName());
 }
 
 static inline llvm::Value * nativeCast(llvm::IRBuilder<> & b, const DataTypePtr & from, llvm::Value * value, llvm::Type * to)
 {
     auto * n_from = value->getType();
+
     if (n_from == to)
         return value;
-    if (n_from->isIntegerTy() && to->isFloatingPointTy())
+    else if (n_from->isIntegerTy() && to->isFloatingPointTy())
         return typeIsSigned(*from) ? b.CreateSIToFP(value, to) : b.CreateUIToFP(value, to);
-    if (n_from->isFloatingPointTy() && to->isIntegerTy())
+    else if (n_from->isFloatingPointTy() && to->isIntegerTy())
         return typeIsSigned(*from) ? b.CreateFPToSI(value, to) : b.CreateFPToUI(value, to);
-    if (n_from->isIntegerTy() && to->isIntegerTy())
+    else if (n_from->isIntegerTy() && to->isIntegerTy())
         return b.CreateIntCast(value, to, typeIsSigned(*from));
-    if (n_from->isFloatingPointTy() && to->isFloatingPointTy())
+    else if (n_from->isFloatingPointTy() && to->isFloatingPointTy())
         return b.CreateFPCast(value, to);
-    throw Exception("Cannot cast " + from->getName() + " to requested type", ErrorCodes::NOT_IMPLEMENTED);
+
+    throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Cannot cast {} to requested type", from->getName());
 }
 
 static inline llvm::Value * nativeCast(llvm::IRBuilder<> & b, const DataTypePtr & from, llvm::Value * value, const DataTypePtr & to)
 {
     auto * n_to = toNativeType(b, to);
+
     if (value->getType() == n_to)
+    {
         return value;
-    if (from->isNullable() && to->isNullable())
+    }
+    else if (from->isNullable() && to->isNullable())
     {
         auto * inner = nativeCast(b, removeNullable(from), b.CreateExtractValue(value, {0}), to);
         return b.CreateInsertValue(inner, b.CreateExtractValue(value, {1}), {1});
     }
-    if (from->isNullable())
+    else if (from->isNullable())
+    {
         return nativeCast(b, removeNullable(from), b.CreateExtractValue(value, {0}), to);
-    if (to->isNullable())
+    }
+    else if (to->isNullable())
     {
         auto * inner = nativeCast(b, from, value, removeNullable(to));
         return b.CreateInsertValue(llvm::Constant::getNullValue(n_to), inner, {0});
     }
+
     return nativeCast(b, from, value, n_to);
 }
 
+static inline llvm::Constant * getColumnNativeValue(llvm::IRBuilderBase & builder, const DataTypePtr & column_type, const IColumn & column, size_t index)
+{
+    if (const auto * constant = typeid_cast<const ColumnConst *>(&column))
+    {
+        return getColumnNativeValue(builder, column_type, constant->getDataColumn(), 0);
+    }
+
+    WhichDataType column_data_type(column_type);
+
+    auto * type = toNativeType(builder, column_type);
+
+    if (!type || column.size() <= index)
+        return nullptr;
+
+    if (column_data_type.isNullable())
+    {
+        const auto & nullable_data_type = assert_cast<const DataTypeNullable &>(*column_type);
+        const auto & nullable_column = assert_cast<const ColumnNullable &>(column);
+
+        auto * value = getColumnNativeValue(builder, nullable_data_type.getNestedType(), nullable_column.getNestedColumn(), index);
+        auto * is_null = llvm::ConstantInt::get(type->getContainedType(1), nullable_column.isNullAt(index));
+
+        return value ? llvm::ConstantStruct::get(static_cast<llvm::StructType *>(type), value, is_null) : nullptr;
+    }
+    else if (column_data_type.isFloat32())
+    {
+        return llvm::ConstantFP::get(type, assert_cast<const ColumnVector<Float32> &>(column).getElement(index));
+    }
+    else if (column_data_type.isFloat64())
+    {
+        return llvm::ConstantFP::get(type, assert_cast<const ColumnVector<Float64> &>(column).getElement(index));
+    }
+    else if (column_data_type.isNativeUInt() || column_data_type.isDateOrDateTime())
+    {
+        return llvm::ConstantInt::get(type, column.getUInt(index));
+    }
+    else if (column_data_type.isNativeInt())
+    {
+        return llvm::ConstantInt::get(type, column.getInt(index));
+    }
+
+    return nullptr;
+}
+
 }
 
 #endif
diff --git a/src/DataTypes/NumberTraits.h b/src/DataTypes/NumberTraits.h
index c3b0d956ef5..dc96f2db128 100644
--- a/src/DataTypes/NumberTraits.h
+++ b/src/DataTypes/NumberTraits.h
@@ -3,7 +3,6 @@
 #include <type_traits>
 
 #include <Core/Types.h>
-#include <Common/UInt128.h>
 
 
 namespace DB
@@ -47,7 +46,7 @@ template <> struct Construct<false, false, 1> { using Type = UInt8; };
 template <> struct Construct<false, false, 2> { using Type = UInt16; };
 template <> struct Construct<false, false, 4> { using Type = UInt32; };
 template <> struct Construct<false, false, 8> { using Type = UInt64; };
-template <> struct Construct<false, false, 16> { using Type = UInt256; }; /// TODO: we cannot use our UInt128 here
+template <> struct Construct<false, false, 16> { using Type = UInt128; };
 template <> struct Construct<false, false, 32> { using Type = UInt256; };
 template <> struct Construct<false, true, 1> { using Type = Float32; };
 template <> struct Construct<false, true, 2> { using Type = Float32; };
@@ -183,11 +182,12 @@ struct ResultOfIf
                 ? max(sizeof(A), sizeof(B)) * 2
                 : max(sizeof(A), sizeof(B))>::Type;
 
-    using ConstructedTypeWithoutUUID = std::conditional_t<std::is_same_v<A, UInt128> || std::is_same_v<B, UInt128>, Error, ConstructedType>;
-    using ConstructedWithUUID = std::conditional_t<std::is_same_v<A, UInt128> && std::is_same_v<B, UInt128>, A, ConstructedTypeWithoutUUID>;
-
-    using Type = std::conditional_t<!IsDecimalNumber<A> && !IsDecimalNumber<B>, ConstructedWithUUID,
-        std::conditional_t<IsDecimalNumber<A> && IsDecimalNumber<B>, std::conditional_t<(sizeof(A) > sizeof(B)), A, B>, Error>>;
+    using Type =
+        std::conditional_t<std::is_same_v<A, B>, A,
+        std::conditional_t<IsDecimalNumber<A> && IsDecimalNumber<B>,
+            std::conditional_t<(sizeof(A) > sizeof(B)), A, B>,
+        std::conditional_t<!IsDecimalNumber<A> && !IsDecimalNumber<B>,
+            ConstructedType, Error>>>;
 };
 
 /** Before applying operator `%` and bitwise operations, operands are casted to whole numbers. */
diff --git a/src/DataTypes/Serializations/SerializationLowCardinality.cpp b/src/DataTypes/Serializations/SerializationLowCardinality.cpp
index 41d9a4100e0..69a41d83138 100644
--- a/src/DataTypes/Serializations/SerializationLowCardinality.cpp
+++ b/src/DataTypes/Serializations/SerializationLowCardinality.cpp
@@ -160,7 +160,7 @@ struct IndexesSerializationType
             return std::make_shared<DataTypeUInt16>();
         if (type == TUInt32)
             return std::make_shared<DataTypeUInt32>();
-        if (type == TUInt64)
+        if (type == TUInt64) //-V547
             return std::make_shared<DataTypeUInt64>();
 
         throw Exception("Can't create DataType from IndexesSerializationType.", ErrorCodes::LOGICAL_ERROR);
diff --git a/src/DataTypes/Serializations/SerializationNumber.cpp b/src/DataTypes/Serializations/SerializationNumber.cpp
index 36cbd6a5ef8..347db5d0aa5 100644
--- a/src/DataTypes/Serializations/SerializationNumber.cpp
+++ b/src/DataTypes/Serializations/SerializationNumber.cpp
@@ -157,7 +157,7 @@ template class SerializationNumber<UInt8>;
 template class SerializationNumber<UInt16>;
 template class SerializationNumber<UInt32>;
 template class SerializationNumber<UInt64>;
-template class SerializationNumber<UInt128>; // base for UUID
+template class SerializationNumber<UInt128>;
 template class SerializationNumber<UInt256>;
 template class SerializationNumber<Int8>;
 template class SerializationNumber<Int16>;
diff --git a/src/DataTypes/Serializations/SerializationNumber.h b/src/DataTypes/Serializations/SerializationNumber.h
index 09976a4bc4f..cb40b6c5437 100644
--- a/src/DataTypes/Serializations/SerializationNumber.h
+++ b/src/DataTypes/Serializations/SerializationNumber.h
@@ -9,7 +9,7 @@ namespace DB
 template <typename T>
 class SerializationNumber : public SimpleTextSerialization
 {
-    static_assert(IsNumber<T>);
+    static_assert(is_arithmetic_v<T>);
 
 public:
     using FieldType = T;
diff --git a/src/DataTypes/Serializations/SerializationUUID.cpp b/src/DataTypes/Serializations/SerializationUUID.cpp
index 1a0640a5e69..3c1ba869466 100644
--- a/src/DataTypes/Serializations/SerializationUUID.cpp
+++ b/src/DataTypes/Serializations/SerializationUUID.cpp
@@ -6,19 +6,20 @@
 #include <IO/ReadHelpers.h>
 #include <Common/assert_cast.h>
 
+
 namespace DB
 {
 
 void SerializationUUID::serializeText(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings &) const
 {
-    writeText(UUID(assert_cast<const ColumnUInt128 &>(column).getData()[row_num]), ostr);
+    writeText(assert_cast<const ColumnUUID &>(column).getData()[row_num], ostr);
 }
 
 void SerializationUUID::deserializeText(IColumn & column, ReadBuffer & istr, const FormatSettings &) const
 {
     UUID x;
     readText(x, istr);
-    assert_cast<ColumnUInt128 &>(column).getData().push_back(x);
+    assert_cast<ColumnUUID &>(column).getData().push_back(x);
 }
 
 void SerializationUUID::deserializeTextEscaped(IColumn & column, ReadBuffer & istr, const FormatSettings & settings) const
@@ -44,7 +45,7 @@ void SerializationUUID::deserializeTextQuoted(IColumn & column, ReadBuffer & ist
     assertChar('\'', istr);
     readText(x, istr);
     assertChar('\'', istr);
-    assert_cast<ColumnUInt128 &>(column).getData().push_back(x);    /// It's important to do this at the end - for exception safety.
+    assert_cast<ColumnUUID &>(column).getData().push_back(x);    /// It's important to do this at the end - for exception safety.
 }
 
 void SerializationUUID::serializeTextJSON(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const
@@ -60,7 +61,7 @@ void SerializationUUID::deserializeTextJSON(IColumn & column, ReadBuffer & istr,
     assertChar('"', istr);
     readText(x, istr);
     assertChar('"', istr);
-    assert_cast<ColumnUInt128 &>(column).getData().push_back(x);
+    assert_cast<ColumnUUID &>(column).getData().push_back(x);
 }
 
 void SerializationUUID::serializeTextCSV(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const
@@ -74,7 +75,55 @@ void SerializationUUID::deserializeTextCSV(IColumn & column, ReadBuffer & istr,
 {
     UUID value;
     readCSV(value, istr);
-    assert_cast<ColumnUInt128 &>(column).getData().push_back(value);
+    assert_cast<ColumnUUID &>(column).getData().push_back(value);
+}
+
+
+void SerializationUUID::serializeBinary(const Field & field, WriteBuffer & ostr) const
+{
+    UUID x = get<UUID>(field);
+    writeBinary(x, ostr);
+}
+
+void SerializationUUID::deserializeBinary(Field & field, ReadBuffer & istr) const
+{
+    UUID x;
+    readBinary(x, istr);
+    field = NearestFieldType<UUID>(x);
+}
+
+void SerializationUUID::serializeBinary(const IColumn & column, size_t row_num, WriteBuffer & ostr) const
+{
+    writeBinary(assert_cast<const ColumnVector<UUID> &>(column).getData()[row_num], ostr);
+}
+
+void SerializationUUID::deserializeBinary(IColumn & column, ReadBuffer & istr) const
+{
+    UUID x;
+    readBinary(x, istr);
+    assert_cast<ColumnVector<UUID> &>(column).getData().push_back(x);
+}
+
+void SerializationUUID::serializeBinaryBulk(const IColumn & column, WriteBuffer & ostr, size_t offset, size_t limit) const
+{
+    const typename ColumnVector<UUID>::Container & x = typeid_cast<const ColumnVector<UUID> &>(column).getData();
+
+    size_t size = x.size();
+
+    if (limit == 0 || offset + limit > size)
+        limit = size - offset;
+
+    if (limit)
+        ostr.write(reinterpret_cast<const char *>(&x[offset]), sizeof(UUID) * limit);
+}
+
+void SerializationUUID::deserializeBinaryBulk(IColumn & column, ReadBuffer & istr, size_t limit, double /*avg_value_size_hint*/) const
+{
+    typename ColumnVector<UUID>::Container & x = typeid_cast<ColumnVector<UUID> &>(column).getData();
+    size_t initial_size = x.size();
+    x.resize(initial_size + limit);
+    size_t size = istr.readBig(reinterpret_cast<char*>(&x[initial_size]), sizeof(UUID) * limit);
+    x.resize(initial_size + size / sizeof(UUID));
 }
 
 }
diff --git a/src/DataTypes/Serializations/SerializationUUID.h b/src/DataTypes/Serializations/SerializationUUID.h
index 93bf166bbd9..3100e128848 100644
--- a/src/DataTypes/Serializations/SerializationUUID.h
+++ b/src/DataTypes/Serializations/SerializationUUID.h
@@ -5,7 +5,7 @@
 namespace DB
 {
 
-class SerializationUUID : public SerializationNumber<UInt128>
+class SerializationUUID : public SimpleTextSerialization
 {
 public:
     void serializeText(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings &) const override;
@@ -18,6 +18,13 @@ public:
     void deserializeTextJSON(IColumn & column, ReadBuffer & istr, const FormatSettings &) const override;
     void serializeTextCSV(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings &) const override;
     void deserializeTextCSV(IColumn & column, ReadBuffer & istr, const FormatSettings & settings) const override;
+
+    void serializeBinary(const Field & field, WriteBuffer & ostr) const override;
+    void deserializeBinary(Field & field, ReadBuffer & istr) const override;
+    void serializeBinary(const IColumn & column, size_t row_num, WriteBuffer & ostr) const override;
+    void deserializeBinary(IColumn & column, ReadBuffer & istr) const override;
+    void serializeBinaryBulk(const IColumn & column, WriteBuffer & ostr, size_t offset, size_t limit) const override;
+    void deserializeBinaryBulk(IColumn & column, ReadBuffer & istr, size_t limit, double avg_value_size_hint) const override;
 };
 
 }
diff --git a/src/DataTypes/convertMySQLDataType.cpp b/src/DataTypes/convertMySQLDataType.cpp
index 5684503e34a..bcccb58966a 100644
--- a/src/DataTypes/convertMySQLDataType.cpp
+++ b/src/DataTypes/convertMySQLDataType.cpp
@@ -105,9 +105,9 @@ DataTypePtr convertMySQLDataType(MultiEnum<MySQLDataTypesSupport> type_support,
     {
         if (precision <= DecimalUtils::max_precision<Decimal32>)
             res = std::make_shared<DataTypeDecimal<Decimal32>>(precision, scale);
-        else if (precision <= DecimalUtils::max_precision<Decimal64>)
+        else if (precision <= DecimalUtils::max_precision<Decimal64>) //-V547
             res = std::make_shared<DataTypeDecimal<Decimal64>>(precision, scale);
-        else if (precision <= DecimalUtils::max_precision<Decimal128>)
+        else if (precision <= DecimalUtils::max_precision<Decimal128>) //-V547
             res = std::make_shared<DataTypeDecimal<Decimal128>>(precision, scale);
     }
 
diff --git a/src/DataTypes/getLeastSupertype.cpp b/src/DataTypes/getLeastSupertype.cpp
index 6710313349b..a04d16ef7cd 100644
--- a/src/DataTypes/getLeastSupertype.cpp
+++ b/src/DataTypes/getLeastSupertype.cpp
@@ -390,6 +390,8 @@ DataTypePtr getLeastSupertype(const DataTypes & types)
                 maximize(max_bits_of_unsigned_integer, 32);
             else if (typeid_cast<const DataTypeUInt64 *>(type.get()))
                 maximize(max_bits_of_unsigned_integer, 64);
+            else if (typeid_cast<const DataTypeUInt128 *>(type.get()))
+                maximize(max_bits_of_unsigned_integer, 128);
             else if (typeid_cast<const DataTypeUInt256 *>(type.get()))
                 maximize(max_bits_of_unsigned_integer, 256);
             else if (typeid_cast<const DataTypeInt8 *>(type.get()) || typeid_cast<const DataTypeEnum8 *>(type.get()))
@@ -423,7 +425,7 @@ DataTypePtr getLeastSupertype(const DataTypes & types)
             size_t min_bit_width_of_integer = std::max(max_bits_of_signed_integer, max_bits_of_unsigned_integer);
 
             /// If unsigned is not covered by signed.
-            if (max_bits_of_signed_integer && max_bits_of_unsigned_integer >= max_bits_of_signed_integer)
+            if (max_bits_of_signed_integer && max_bits_of_unsigned_integer >= max_bits_of_signed_integer) //-V1051
             {
                 // Because 128 and 256 bit integers are significantly slower, we should not promote to them.
                 // But if we already have wide numbers, promotion is necessary.
@@ -482,6 +484,8 @@ DataTypePtr getLeastSupertype(const DataTypes & types)
                     return std::make_shared<DataTypeUInt32>();
                 else if (min_bit_width_of_integer <= 64)
                     return std::make_shared<DataTypeUInt64>();
+                else if (min_bit_width_of_integer <= 128)
+                    return std::make_shared<DataTypeUInt128>();
                 else if (min_bit_width_of_integer <= 256)
                     return std::make_shared<DataTypeUInt256>();
                 else
diff --git a/src/DataTypes/tests/gtest_DataType_deserializeAsText.cpp b/src/DataTypes/tests/gtest_DataType_deserializeAsText.cpp
index 9d8c32c92b6..675ecfbe6e7 100644
--- a/src/DataTypes/tests/gtest_DataType_deserializeAsText.cpp
+++ b/src/DataTypes/tests/gtest_DataType_deserializeAsText.cpp
@@ -15,8 +15,6 @@
 
 #include <Core/iostream_debug_helpers.h>
 
-namespace std
-{
 
 template <typename T>
 inline std::ostream& operator<<(std::ostream & ostr, const std::vector<T> & v)
@@ -29,8 +27,6 @@ inline std::ostream& operator<<(std::ostream & ostr, const std::vector<T> & v)
     return ostr << "] (" << v.size() << ") items";
 }
 
-}
-
 using namespace DB;
 
 struct ParseDataTypeTestCase
diff --git a/src/DataTypes/tests/gtest_data_type_get_common_type.cpp b/src/DataTypes/tests/gtest_data_type_get_common_type.cpp
index 5c258f0b42e..2a77237e982 100644
--- a/src/DataTypes/tests/gtest_data_type_get_common_type.cpp
+++ b/src/DataTypes/tests/gtest_data_type_get_common_type.cpp
@@ -37,7 +37,7 @@ static auto typesFromString(const std::string & str)
 
 struct TypesTestCase
 {
-    const char * from_types;
+    const char * from_types = nullptr;
     const char * expected_type = nullptr;
 };
 
diff --git a/src/Databases/DatabaseAtomic.cpp b/src/Databases/DatabaseAtomic.cpp
index 0dae31ac906..b69af842978 100644
--- a/src/Databases/DatabaseAtomic.cpp
+++ b/src/Databases/DatabaseAtomic.cpp
@@ -102,7 +102,7 @@ StoragePtr DatabaseAtomic::detachTable(const String & name)
     auto table = DatabaseOrdinary::detachTableUnlocked(name, lock);
     table_name_to_path.erase(name);
     detached_tables.emplace(table->getStorageID().uuid, table);
-    not_in_use = cleanupDetachedTables();
+    not_in_use = cleanupDetachedTables(); //-V1001
     return table;
 }
 
diff --git a/src/Databases/PostgreSQL/fetchPostgreSQLTableStructure.cpp b/src/Databases/PostgreSQL/fetchPostgreSQLTableStructure.cpp
index a1dd74e0a73..2eb10bf273f 100644
--- a/src/Databases/PostgreSQL/fetchPostgreSQLTableStructure.cpp
+++ b/src/Databases/PostgreSQL/fetchPostgreSQLTableStructure.cpp
@@ -67,11 +67,11 @@ static DataTypePtr convertPostgreSQLDataType(String & type, bool is_nullable, ui
 
             if (precision <= DecimalUtils::max_precision<Decimal32>)
                 res = std::make_shared<DataTypeDecimal<Decimal32>>(precision, scale);
-            else if (precision <= DecimalUtils::max_precision<Decimal64>)
+            else if (precision <= DecimalUtils::max_precision<Decimal64>) //-V547
                 res = std::make_shared<DataTypeDecimal<Decimal64>>(precision, scale);
-            else if (precision <= DecimalUtils::max_precision<Decimal128>)
+            else if (precision <= DecimalUtils::max_precision<Decimal128>) //-V547
                 res = std::make_shared<DataTypeDecimal<Decimal128>>(precision, scale);
-            else if (precision <= DecimalUtils::max_precision<Decimal256>)
+            else if (precision <= DecimalUtils::max_precision<Decimal256>) //-V547
                 res = std::make_shared<DataTypeDecimal<Decimal256>>(precision, scale);
             else
                 throw Exception(ErrorCodes::BAD_ARGUMENTS, "Precision {} and scale {} are too big and not supported", precision, scale);
diff --git a/src/Dictionaries/CacheDictionary.cpp b/src/Dictionaries/CacheDictionary.cpp
index 916631a961d..9bb8b34e74e 100644
--- a/src/Dictionaries/CacheDictionary.cpp
+++ b/src/Dictionaries/CacheDictionary.cpp
@@ -176,8 +176,9 @@ Columns CacheDictionary<dictionary_key_type>::getColumns(
     ProfileEvents::increment(ProfileEvents::DictCacheKeysExpired, expired_keys_size);
     ProfileEvents::increment(ProfileEvents::DictCacheKeysNotFound, not_found_keys_size);
 
-    query_count.fetch_add(keys.size());
-    hit_count.fetch_add(found_keys_size);
+    query_count.fetch_add(keys.size(), std::memory_order_relaxed);
+    hit_count.fetch_add(found_keys_size, std::memory_order_relaxed);
+    found_count.fetch_add(found_keys_size, std::memory_order_relaxed);
 
     MutableColumns & fetched_columns_from_storage = result_of_fetch_from_storage.fetched_columns;
     const PaddedPODArray<KeyState> & key_index_to_state_from_storage = result_of_fetch_from_storage.key_index_to_state;
@@ -296,8 +297,9 @@ ColumnUInt8::Ptr CacheDictionary<dictionary_key_type>::hasKeys(const Columns & k
     ProfileEvents::increment(ProfileEvents::DictCacheKeysExpired, expired_keys_size);
     ProfileEvents::increment(ProfileEvents::DictCacheKeysNotFound, not_found_keys_size);
 
-    query_count.fetch_add(keys.size());
-    hit_count.fetch_add(found_keys_size);
+    query_count.fetch_add(keys.size(), std::memory_order_relaxed);
+    hit_count.fetch_add(found_keys_size, std::memory_order_relaxed);
+    found_count.fetch_add(found_keys_size, std::memory_order_relaxed);
 
     size_t keys_to_update_size = expired_keys_size + not_found_keys_size;
     auto update_unit = std::make_shared<CacheDictionaryUpdateUnit<dictionary_key_type>>(key_columns, result_of_fetch_from_storage.key_index_to_state, request, keys_to_update_size);
@@ -365,8 +367,10 @@ ColumnPtr CacheDictionary<dictionary_key_type>::getHierarchy(
 {
     if (dictionary_key_type == DictionaryKeyType::simple)
     {
-        auto result = getKeysHierarchyDefaultImplementation(this, key_column, key_type);
+        size_t keys_found;
+        auto result = getKeysHierarchyDefaultImplementation(this, key_column, key_type, keys_found);
         query_count.fetch_add(key_column->size(), std::memory_order_relaxed);
+        found_count.fetch_add(keys_found, std::memory_order_relaxed);
         return result;
     }
     else
@@ -381,8 +385,10 @@ ColumnUInt8::Ptr CacheDictionary<dictionary_key_type>::isInHierarchy(
 {
     if (dictionary_key_type == DictionaryKeyType::simple)
     {
-        auto result = getKeysIsInHierarchyDefaultImplementation(this, key_column, in_key_column, key_type);
+        size_t keys_found;
+        auto result = getKeysIsInHierarchyDefaultImplementation(this, key_column, in_key_column, key_type, keys_found);
         query_count.fetch_add(key_column->size(), std::memory_order_relaxed);
+        found_count.fetch_add(keys_found, std::memory_order_relaxed);
         return result;
     }
     else
@@ -668,6 +674,8 @@ void CacheDictionary<dictionary_key_type>::update(CacheDictionaryUpdateUnitPtr<d
         ProfileEvents::increment(ProfileEvents::DictCacheKeysRequestedMiss, requested_keys_size - found_keys_size);
         ProfileEvents::increment(ProfileEvents::DictCacheKeysRequestedFound, found_keys_size);
         ProfileEvents::increment(ProfileEvents::DictCacheRequests);
+
+        found_count.fetch_add(found_keys_size, std::memory_order_relaxed);
     }
     else
     {
diff --git a/src/Dictionaries/CacheDictionary.h b/src/Dictionaries/CacheDictionary.h
index 62cd509d006..baaf99d290b 100644
--- a/src/Dictionaries/CacheDictionary.h
+++ b/src/Dictionaries/CacheDictionary.h
@@ -75,9 +75,20 @@ public:
 
     size_t getQueryCount() const override { return query_count.load(std::memory_order_relaxed); }
 
+    double getFoundRate() const override
+    {
+        size_t queries = query_count.load(std::memory_order_relaxed);
+        if (!queries)
+            return 0;
+        return static_cast<double>(found_count.load(std::memory_order_relaxed)) / queries;
+    }
+
     double getHitRate() const override
     {
-        return static_cast<double>(hit_count.load(std::memory_order_acquire)) / query_count.load(std::memory_order_relaxed);
+        size_t queries = query_count.load(std::memory_order_relaxed);
+        if (!queries)
+            return 0;
+        return static_cast<double>(hit_count.load(std::memory_order_acquire)) / queries;
     }
 
     bool supportUpdates() const override { return false; }
@@ -204,6 +215,7 @@ private:
 
     mutable std::atomic<size_t> hit_count{0};
     mutable std::atomic<size_t> query_count{0};
+    mutable std::atomic<size_t> found_count{0};
 
 };
 
diff --git a/src/Dictionaries/CacheDictionaryStorage.h b/src/Dictionaries/CacheDictionaryStorage.h
index 720800e6357..a79d83eea05 100644
--- a/src/Dictionaries/CacheDictionaryStorage.h
+++ b/src/Dictionaries/CacheDictionaryStorage.h
@@ -594,16 +594,20 @@ private:
             PaddedPODArray<UInt32>,
             PaddedPODArray<UInt64>,
             PaddedPODArray<UInt128>,
+            PaddedPODArray<UInt256>,
             PaddedPODArray<Int8>,
             PaddedPODArray<Int16>,
             PaddedPODArray<Int32>,
             PaddedPODArray<Int64>,
+            PaddedPODArray<Int128>,
+            PaddedPODArray<Int256>,
             PaddedPODArray<Decimal32>,
             PaddedPODArray<Decimal64>,
             PaddedPODArray<Decimal128>,
             PaddedPODArray<Decimal256>,
             PaddedPODArray<Float32>,
             PaddedPODArray<Float64>,
+            PaddedPODArray<UUID>,
             PaddedPODArray<StringRef>,
             std::vector<Field>> attribute_container;
     };
diff --git a/src/Dictionaries/CassandraBlockInputStream.cpp b/src/Dictionaries/CassandraBlockInputStream.cpp
index 4e71c212451..9afc0069d48 100644
--- a/src/Dictionaries/CassandraBlockInputStream.cpp
+++ b/src/Dictionaries/CassandraBlockInputStream.cpp
@@ -138,7 +138,7 @@ void CassandraBlockInputStream::insertValue(IColumn & column, ValueType type, co
             cass_value_get_uuid(cass_value, &value);
             std::array<char, CASS_UUID_STRING_LENGTH> uuid_str;
             cass_uuid_string(value, uuid_str.data());
-            assert_cast<ColumnUInt128 &>(column).insert(parse<UUID>(uuid_str.data(), uuid_str.size()));
+            assert_cast<ColumnUUID &>(column).insert(parse<UUID>(uuid_str.data(), uuid_str.size()));
             break;
         }
         default:
diff --git a/src/Dictionaries/DictionaryHelpers.h b/src/Dictionaries/DictionaryHelpers.h
index c2071d8136a..6d459bab85f 100644
--- a/src/Dictionaries/DictionaryHelpers.h
+++ b/src/Dictionaries/DictionaryHelpers.h
@@ -243,13 +243,19 @@ public:
         {
             return ColumnType::create();
         }
-        if constexpr (IsDecimalNumber<DictionaryAttributeType>)
+        else if constexpr (std::is_same_v<DictionaryAttributeType, UUID>)
+        {
+            return ColumnType::create(size);
+        }
+        else if constexpr (IsDecimalNumber<DictionaryAttributeType>)
         {
             auto scale = getDecimalScale(*dictionary_attribute.nested_type);
             return ColumnType::create(size, scale);
         }
-        else if constexpr (IsNumber<DictionaryAttributeType>)
+        else if constexpr (is_arithmetic_v<DictionaryAttributeType>)
+        {
             return ColumnType::create(size);
+        }
         else
             throw Exception(ErrorCodes::TYPE_MISMATCH, "Unsupported attribute type.");
     }
@@ -563,7 +569,7 @@ static const PaddedPODArray<T> & getColumnVectorData(
         throw Exception(ErrorCodes::TYPE_MISMATCH,
             "{}: type mismatch: column has wrong type expected {}",
             dictionary->getDictionaryID().getNameForLogs(),
-            TypeName<T>::get());
+            TypeName<T>);
     }
 
     if (is_const_column)
diff --git a/src/Dictionaries/DictionaryStructure.cpp b/src/Dictionaries/DictionaryStructure.cpp
index dd53e31041b..c0d00d3ae40 100644
--- a/src/Dictionaries/DictionaryStructure.cpp
+++ b/src/Dictionaries/DictionaryStructure.cpp
@@ -14,6 +14,7 @@
 #include <unordered_set>
 #include <ext/range.h>
 
+
 namespace DB
 {
 namespace ErrorCodes
@@ -48,36 +49,39 @@ AttributeUnderlyingType getAttributeUnderlyingType(const DataTypePtr & type)
 
     switch (type_index)
     {
-        case TypeIndex::UInt8:          return AttributeUnderlyingType::utUInt8;
-        case TypeIndex::UInt16:         return AttributeUnderlyingType::utUInt16;
-        case TypeIndex::UInt32:         return AttributeUnderlyingType::utUInt32;
-        case TypeIndex::UInt64:         return AttributeUnderlyingType::utUInt64;
-        case TypeIndex::UInt128:        return AttributeUnderlyingType::utUInt128;
+        case TypeIndex::UInt8:          return AttributeUnderlyingType::UInt8;
+        case TypeIndex::UInt16:         return AttributeUnderlyingType::UInt16;
+        case TypeIndex::UInt32:         return AttributeUnderlyingType::UInt32;
+        case TypeIndex::UInt64:         return AttributeUnderlyingType::UInt64;
+        case TypeIndex::UInt128:        return AttributeUnderlyingType::UInt128;
+        case TypeIndex::UInt256:        return AttributeUnderlyingType::UInt256;
 
-        case TypeIndex::Int8:           return AttributeUnderlyingType::utInt8;
-        case TypeIndex::Int16:          return AttributeUnderlyingType::utInt16;
-        case TypeIndex::Int32:          return AttributeUnderlyingType::utInt32;
-        case TypeIndex::Int64:          return AttributeUnderlyingType::utInt64;
+        case TypeIndex::Int8:           return AttributeUnderlyingType::Int8;
+        case TypeIndex::Int16:          return AttributeUnderlyingType::Int16;
+        case TypeIndex::Int32:          return AttributeUnderlyingType::Int32;
+        case TypeIndex::Int64:          return AttributeUnderlyingType::Int64;
+        case TypeIndex::Int128:         return AttributeUnderlyingType::Int128;
+        case TypeIndex::Int256:         return AttributeUnderlyingType::Int256;
 
-        case TypeIndex::Float32:        return AttributeUnderlyingType::utFloat32;
-        case TypeIndex::Float64:        return AttributeUnderlyingType::utFloat64;
+        case TypeIndex::Float32:        return AttributeUnderlyingType::Float32;
+        case TypeIndex::Float64:        return AttributeUnderlyingType::Float64;
 
-        case TypeIndex::Decimal32:      return AttributeUnderlyingType::utDecimal32;
-        case TypeIndex::Decimal64:      return AttributeUnderlyingType::utDecimal64;
-        case TypeIndex::Decimal128:     return AttributeUnderlyingType::utDecimal128;
-        case TypeIndex::Decimal256:     return AttributeUnderlyingType::utDecimal256;
+        case TypeIndex::Decimal32:      return AttributeUnderlyingType::Decimal32;
+        case TypeIndex::Decimal64:      return AttributeUnderlyingType::Decimal64;
+        case TypeIndex::Decimal128:     return AttributeUnderlyingType::Decimal128;
+        case TypeIndex::Decimal256:     return AttributeUnderlyingType::Decimal256;
 
-        case TypeIndex::Date:           return AttributeUnderlyingType::utUInt16;
-        case TypeIndex::DateTime:       return AttributeUnderlyingType::utUInt32;
-        case TypeIndex::DateTime64:     return AttributeUnderlyingType::utUInt64;
+        case TypeIndex::Date:           return AttributeUnderlyingType::UInt16;
+        case TypeIndex::DateTime:       return AttributeUnderlyingType::UInt32;
+        case TypeIndex::DateTime64:     return AttributeUnderlyingType::UInt64;
 
-        case TypeIndex::UUID:           return AttributeUnderlyingType::utUInt128;
+        case TypeIndex::UUID:           return AttributeUnderlyingType::UUID;
 
-        case TypeIndex::String:         return AttributeUnderlyingType::utString;
+        case TypeIndex::String:         return AttributeUnderlyingType::String;
 
         // Temporary hack to allow arrays in keys, since they are never retrieved for polygon dictionaries.
         // TODO: This should be fixed by fully supporting arrays in dictionaries.
-        case TypeIndex::Array:          return AttributeUnderlyingType::utString;
+        case TypeIndex::Array:          return AttributeUnderlyingType::String;
 
         default: break;
     }
@@ -90,38 +94,9 @@ std::string toString(AttributeUnderlyingType type)
 {
     switch (type)
     {
-        case AttributeUnderlyingType::utUInt8:
-            return "UInt8";
-        case AttributeUnderlyingType::utUInt16:
-            return "UInt16";
-        case AttributeUnderlyingType::utUInt32:
-            return "UInt32";
-        case AttributeUnderlyingType::utUInt64:
-            return "UInt64";
-        case AttributeUnderlyingType::utUInt128:
-            return "UUID";
-        case AttributeUnderlyingType::utInt8:
-            return "Int8";
-        case AttributeUnderlyingType::utInt16:
-            return "Int16";
-        case AttributeUnderlyingType::utInt32:
-            return "Int32";
-        case AttributeUnderlyingType::utInt64:
-            return "Int64";
-        case AttributeUnderlyingType::utFloat32:
-            return "Float32";
-        case AttributeUnderlyingType::utFloat64:
-            return "Float64";
-        case AttributeUnderlyingType::utDecimal32:
-            return "Decimal32";
-        case AttributeUnderlyingType::utDecimal64:
-            return "Decimal64";
-        case AttributeUnderlyingType::utDecimal128:
-            return "Decimal128";
-        case AttributeUnderlyingType::utDecimal256:
-            return "Decimal256";
-        case AttributeUnderlyingType::utString:
-            return "String";
+#define M(TYPE) case AttributeUnderlyingType::TYPE: return #TYPE;
+    FOR_ATTRIBUTE_TYPES(M)
+#undef M
     }
 
     throw Exception(ErrorCodes::ARGUMENT_OUT_OF_BOUND, "Unknown dictionary attribute type {}", toString(static_cast<int>(type)));
@@ -208,7 +183,7 @@ DictionaryStructure::DictionaryStructure(const Poco::Util::AbstractConfiguration
 
         if (attribute.hierarchical)
         {
-            if (id && attribute.underlying_type != AttributeUnderlyingType::utUInt64)
+            if (id && attribute.underlying_type != AttributeUnderlyingType::UInt64)
                 throw Exception(ErrorCodes::TYPE_MISMATCH,
                     "Hierarchical attribute type for dictionary with simple key must be UInt64. Actual {}",
                     toString(attribute.underlying_type));
@@ -320,7 +295,7 @@ bool DictionaryStructure::isKeySizeFixed() const
         return true;
 
     for (const auto & key_i : *key)
-        if (key_i.underlying_type == AttributeUnderlyingType::utString)
+        if (key_i.underlying_type == AttributeUnderlyingType::String)
             return false;
 
     return true;
diff --git a/src/Dictionaries/DictionaryStructure.h b/src/Dictionaries/DictionaryStructure.h
index ce5dd3dd422..4815501b696 100644
--- a/src/Dictionaries/DictionaryStructure.h
+++ b/src/Dictionaries/DictionaryStructure.h
@@ -5,7 +5,6 @@
 #include <string>
 #include <vector>
 
-
 #include <Poco/Util/AbstractConfiguration.h>
 
 #include <Core/Field.h>
@@ -13,27 +12,43 @@
 #include <DataTypes/IDataType.h>
 #include <Interpreters/IExternalLoadable.h>
 
+#if defined(__GNUC__)
+    /// GCC mistakenly warns about the names in enum class.
+    #pragma GCC diagnostic ignored "-Wshadow"
+#endif
+
+
+#define FOR_ATTRIBUTE_TYPES(M) \
+    M(UInt8) \
+    M(UInt16) \
+    M(UInt32) \
+    M(UInt64) \
+    M(UInt128) \
+    M(UInt256) \
+    M(Int8) \
+    M(Int16) \
+    M(Int32) \
+    M(Int64) \
+    M(Int128) \
+    M(Int256) \
+    M(Float32) \
+    M(Float64) \
+    M(Decimal32) \
+    M(Decimal64) \
+    M(Decimal128) \
+    M(Decimal256) \
+    M(UUID) \
+    M(String) \
+
+
 namespace DB
 {
 
 enum class AttributeUnderlyingType
 {
-    utUInt8,
-    utUInt16,
-    utUInt32,
-    utUInt64,
-    utUInt128,
-    utInt8,
-    utInt16,
-    utInt32,
-    utInt64,
-    utFloat32,
-    utFloat64,
-    utDecimal32,
-    utDecimal64,
-    utDecimal128,
-    utDecimal256,
-    utString
+#define M(TYPE) TYPE,
+    FOR_ATTRIBUTE_TYPES(M)
+#undef M
 };
 
 
@@ -81,54 +96,12 @@ void callOnDictionaryAttributeType(AttributeUnderlyingType type, F&& func)
 {
     switch (type)
     {
-        case AttributeUnderlyingType::utUInt8:
-            func(DictionaryAttributeType<UInt8>());
-            break;
-        case AttributeUnderlyingType::utUInt16:
-            func(DictionaryAttributeType<UInt16>());
-            break;
-        case AttributeUnderlyingType::utUInt32:
-            func(DictionaryAttributeType<UInt32>());
-            break;
-        case AttributeUnderlyingType::utUInt64:
-            func(DictionaryAttributeType<UInt64>());
-            break;
-        case AttributeUnderlyingType::utUInt128:
-            func(DictionaryAttributeType<UInt128>());
-            break;
-        case AttributeUnderlyingType::utInt8:
-            func(DictionaryAttributeType<Int8>());
-            break;
-        case AttributeUnderlyingType::utInt16:
-            func(DictionaryAttributeType<Int16>());
-            break;
-        case AttributeUnderlyingType::utInt32:
-            func(DictionaryAttributeType<Int32>());
-            break;
-        case AttributeUnderlyingType::utInt64:
-            func(DictionaryAttributeType<Int64>());
-            break;
-        case AttributeUnderlyingType::utFloat32:
-            func(DictionaryAttributeType<Float32>());
-            break;
-        case AttributeUnderlyingType::utFloat64:
-            func(DictionaryAttributeType<Float64>());
-            break;
-        case AttributeUnderlyingType::utString:
-            func(DictionaryAttributeType<String>());
-            break;
-        case AttributeUnderlyingType::utDecimal32:
-            func(DictionaryAttributeType<Decimal32>());
-            break;
-        case AttributeUnderlyingType::utDecimal64:
-            func(DictionaryAttributeType<Decimal64>());
-            break;
-        case AttributeUnderlyingType::utDecimal128:
-            func(DictionaryAttributeType<Decimal128>());
-            break;
-        case AttributeUnderlyingType::utDecimal256:
-            func(DictionaryAttributeType<Decimal256>());
+#define M(TYPE) \
+        case AttributeUnderlyingType::TYPE: \
+            func(DictionaryAttributeType<TYPE>()); \
             break;
+    FOR_ATTRIBUTE_TYPES(M)
+#undef M
     }
 };
 
diff --git a/src/Dictionaries/DirectDictionary.cpp b/src/Dictionaries/DirectDictionary.cpp
index 2038704414e..c5efaef56f7 100644
--- a/src/Dictionaries/DirectDictionary.cpp
+++ b/src/Dictionaries/DirectDictionary.cpp
@@ -106,6 +106,8 @@ Columns DirectDictionary<dictionary_key_type>::getColumns(
 
     auto result_columns = request.makeAttributesResultColumns();
 
+    size_t keys_found = 0;
+
     for (size_t attribute_index = 0; attribute_index < result_columns.size(); ++attribute_index)
     {
         if (!request.shouldFillResultColumnWithIndex(attribute_index))
@@ -124,7 +126,10 @@ Columns DirectDictionary<dictionary_key_type>::getColumns(
             const auto * it = key_to_fetched_index.find(requested_key);
 
             if (it)
+            {
                 fetched_column_from_storage->get(it->getMapped(), value_to_insert);
+                ++keys_found;
+            }
             else
                 value_to_insert = default_value_provider.getDefaultValue(requested_key_index);
 
@@ -133,6 +138,7 @@ Columns DirectDictionary<dictionary_key_type>::getColumns(
     }
 
     query_count.fetch_add(requested_keys_size, std::memory_order_relaxed);
+    found_count.fetch_add(keys_found, std::memory_order_relaxed);
 
     return request.filterRequestedColumns(result_columns);
 }
@@ -181,6 +187,8 @@ ColumnUInt8::Ptr DirectDictionary<dictionary_key_type>::hasKeys(
 
     stream->readPrefix();
 
+    size_t keys_found = 0;
+
     while (const auto block = stream->read())
     {
         /// Split into keys columns and attribute columns
@@ -198,6 +206,8 @@ ColumnUInt8::Ptr DirectDictionary<dictionary_key_type>::hasKeys(
             assert(it);
 
             size_t result_data_found_index = it->getMapped();
+            /// block_keys_size cannot be used, due to duplicates.
+            keys_found += !result_data[result_data_found_index];
             result_data[result_data_found_index] = true;
 
             block_keys_extractor.rollbackCurrentKey();
@@ -209,6 +219,7 @@ ColumnUInt8::Ptr DirectDictionary<dictionary_key_type>::hasKeys(
     stream->readSuffix();
 
     query_count.fetch_add(requested_keys_size, std::memory_order_relaxed);
+    found_count.fetch_add(keys_found, std::memory_order_relaxed);
 
     return result;
 }
@@ -220,8 +231,10 @@ ColumnPtr DirectDictionary<dictionary_key_type>::getHierarchy(
 {
     if (dictionary_key_type == DictionaryKeyType::simple)
     {
-        auto result = getKeysHierarchyDefaultImplementation(this, key_column, key_type);
+        size_t keys_found;
+        auto result = getKeysHierarchyDefaultImplementation(this, key_column, key_type, keys_found);
         query_count.fetch_add(key_column->size(), std::memory_order_relaxed);
+        found_count.fetch_add(keys_found, std::memory_order_relaxed);
         return result;
     }
     else
@@ -236,8 +249,10 @@ ColumnUInt8::Ptr DirectDictionary<dictionary_key_type>::isInHierarchy(
 {
     if (dictionary_key_type == DictionaryKeyType::simple)
     {
-        auto result = getKeysIsInHierarchyDefaultImplementation(this, key_column, in_key_column, key_type);
+        size_t keys_found = 0;
+        auto result = getKeysIsInHierarchyDefaultImplementation(this, key_column, in_key_column, key_type, keys_found);
         query_count.fetch_add(key_column->size(), std::memory_order_relaxed);
+        found_count.fetch_add(keys_found, std::memory_order_relaxed);
         return result;
     }
     else
diff --git a/src/Dictionaries/DirectDictionary.h b/src/Dictionaries/DirectDictionary.h
index e547e10433c..1cc73622592 100644
--- a/src/Dictionaries/DirectDictionary.h
+++ b/src/Dictionaries/DirectDictionary.h
@@ -42,6 +42,14 @@ public:
 
     size_t getQueryCount() const override { return query_count.load(std::memory_order_relaxed); }
 
+    double getFoundRate() const override
+    {
+        size_t queries = query_count.load(std::memory_order_relaxed);
+        if (!queries)
+            return 0;
+        return static_cast<double>(found_count.load(std::memory_order_relaxed)) / queries;
+    }
+
     double getHitRate() const override { return 1.0; }
 
     size_t getElementCount() const override { return 0; }
@@ -101,6 +109,7 @@ private:
     const DictionaryLifetime dict_lifetime;
 
     mutable std::atomic<size_t> query_count{0};
+    mutable std::atomic<size_t> found_count{0};
 };
 
 extern template class DirectDictionary<DictionaryKeyType::simple>;
diff --git a/src/Dictionaries/Embedded/RegionsNames.h b/src/Dictionaries/Embedded/RegionsNames.h
index 7216f238156..91830490325 100644
--- a/src/Dictionaries/Embedded/RegionsNames.h
+++ b/src/Dictionaries/Embedded/RegionsNames.h
@@ -84,7 +84,7 @@ public:
     {
         size_t language_id = static_cast<size_t>(language);
 
-        if (region_id >= names_refs[language_id].size())
+        if (region_id >= names_refs[language_id].size()) //-V1051
             return StringRef("", 0);
 
         StringRef ref = names_refs[language_id][region_id];
diff --git a/src/Dictionaries/FlatDictionary.cpp b/src/Dictionaries/FlatDictionary.cpp
index cf9c6bf6858..c26bbc72ca4 100644
--- a/src/Dictionaries/FlatDictionary.cpp
+++ b/src/Dictionaries/FlatDictionary.cpp
@@ -130,13 +130,17 @@ ColumnUInt8::Ptr FlatDictionary::hasKeys(const Columns & key_columns, const Data
     auto result = ColumnUInt8::create(keys_size);
     auto & out = result->getData();
 
+    size_t keys_found = 0;
+
     for (size_t key_index = 0; key_index < keys_size; ++key_index)
     {
         const auto key = keys[key_index];
         out[key_index] = key < loaded_keys.size() && loaded_keys[key];
+        keys_found += out[key_index];
     }
 
     query_count.fetch_add(keys_size, std::memory_order_relaxed);
+    found_count.fetch_add(keys_found, std::memory_order_relaxed);
 
     return result;
 }
@@ -154,16 +158,20 @@ ColumnPtr FlatDictionary::getHierarchy(ColumnPtr key_column, const DataTypePtr &
 
     auto is_key_valid_func = [&, this](auto & key) { return key < loaded_keys.size() && loaded_keys[key]; };
 
+    size_t keys_found = 0;
+
     auto get_parent_key_func = [&, this](auto & hierarchy_key)
     {
         bool is_key_valid = hierarchy_key < loaded_keys.size() && loaded_keys[hierarchy_key];
         std::optional<UInt64> result = is_key_valid ? std::make_optional(parent_keys[hierarchy_key]) : std::nullopt;
+        keys_found += result.has_value();
         return result;
     };
 
     auto dictionary_hierarchy_array = getKeysHierarchyArray(keys, null_value, is_key_valid_func, get_parent_key_func);
 
     query_count.fetch_add(keys.size(), std::memory_order_relaxed);
+    found_count.fetch_add(keys_found, std::memory_order_relaxed);
 
     return dictionary_hierarchy_array;
 }
@@ -187,16 +195,20 @@ ColumnUInt8::Ptr FlatDictionary::isInHierarchy(
 
     auto is_key_valid_func = [&, this](auto & key) { return key < loaded_keys.size() && loaded_keys[key]; };
 
+    size_t keys_found = 0;
+
     auto get_parent_key_func = [&, this](auto & hierarchy_key)
     {
         bool is_key_valid = hierarchy_key < loaded_keys.size() && loaded_keys[hierarchy_key];
         std::optional<UInt64> result = is_key_valid ? std::make_optional(parent_keys[hierarchy_key]) : std::nullopt;
+        keys_found += result.has_value();
         return result;
     };
 
     auto result = getKeysIsInHierarchyColumn(keys, keys_in, null_value, is_key_valid_func, get_parent_key_func);
 
     query_count.fetch_add(keys.size(), std::memory_order_relaxed);
+    found_count.fetch_add(keys_found, std::memory_order_relaxed);
 
     return result;
 }
@@ -223,9 +235,11 @@ ColumnPtr FlatDictionary::getDescendants(
             parent_to_child[parent_key].emplace_back(static_cast<UInt64>(i));
     }
 
-    auto result = getKeysDescendantsArray(keys, parent_to_child, level);
+    size_t keys_found;
+    auto result = getKeysDescendantsArray(keys, parent_to_child, level, keys_found);
 
     query_count.fetch_add(keys.size(), std::memory_order_relaxed);
+    found_count.fetch_add(keys_found, std::memory_order_relaxed);
 
     return result;
 }
@@ -392,17 +406,23 @@ void FlatDictionary::getItemsImpl(
     const auto & container = std::get<ContainerType<AttributeType>>(attribute.container);
     const auto rows = keys.size();
 
+    size_t keys_found = 0;
+
     for (size_t row = 0; row < rows; ++row)
     {
         const auto key = keys[row];
 
         if (key < loaded_keys.size() && loaded_keys[key])
+        {
             set_value(row, static_cast<OutputType>(container[key]));
+            ++keys_found;
+        }
         else
             set_value(row, default_value_extractor[row]);
     }
 
     query_count.fetch_add(rows, std::memory_order_relaxed);
+    found_count.fetch_add(keys_found, std::memory_order_relaxed);
 }
 
 template <typename T>
diff --git a/src/Dictionaries/FlatDictionary.h b/src/Dictionaries/FlatDictionary.h
index 807d4c1e610..211b1cdc33d 100644
--- a/src/Dictionaries/FlatDictionary.h
+++ b/src/Dictionaries/FlatDictionary.h
@@ -47,6 +47,14 @@ public:
 
     size_t getQueryCount() const override { return query_count.load(std::memory_order_relaxed); }
 
+    double getFoundRate() const override
+    {
+        size_t queries = query_count.load(std::memory_order_relaxed);
+        if (!queries)
+            return 0;
+        return static_cast<double>(found_count.load(std::memory_order_relaxed)) / queries;
+    }
+
     double getHitRate() const override { return 1.0; }
 
     size_t getElementCount() const override { return element_count; }
@@ -113,16 +121,20 @@ private:
             UInt32,
             UInt64,
             UInt128,
+            UInt256,
             Int8,
             Int16,
             Int32,
             Int64,
+            Int128,
+            Int256,
             Decimal32,
             Decimal64,
             Decimal128,
             Decimal256,
             Float32,
             Float64,
+            UUID,
             StringRef>
             null_values;
         std::variant<
@@ -131,16 +143,20 @@ private:
             ContainerType<UInt32>,
             ContainerType<UInt64>,
             ContainerType<UInt128>,
+            ContainerType<UInt256>,
             ContainerType<Int8>,
             ContainerType<Int16>,
             ContainerType<Int32>,
             ContainerType<Int64>,
+            ContainerType<Int128>,
+            ContainerType<Int256>,
             ContainerType<Decimal32>,
             ContainerType<Decimal64>,
             ContainerType<Decimal128>,
             ContainerType<Decimal256>,
             ContainerType<Float32>,
             ContainerType<Float64>,
+            ContainerType<UUID>,
             ContainerType<StringRef>>
             container;
 
@@ -183,6 +199,7 @@ private:
     size_t element_count = 0;
     size_t bucket_count = 0;
     mutable std::atomic<size_t> query_count{0};
+    mutable std::atomic<size_t> found_count{0};
 
     BlockPtr update_field_loaded_block;
 };
diff --git a/src/Dictionaries/HTTPDictionarySource.cpp b/src/Dictionaries/HTTPDictionarySource.cpp
index b674d593444..18aa94ccc38 100644
--- a/src/Dictionaries/HTTPDictionarySource.cpp
+++ b/src/Dictionaries/HTTPDictionarySource.cpp
@@ -42,7 +42,6 @@ HTTPDictionarySource::HTTPDictionarySource(
     , context(context_)
     , timeouts(ConnectionTimeouts::getHTTPTimeouts(context))
 {
-
     if (check_config)
         context->getRemoteHostFilter().checkURL(Poco::URI(url));
 
@@ -87,6 +86,16 @@ HTTPDictionarySource::HTTPDictionarySource(const HTTPDictionarySource & other)
     credentials.setPassword(other.credentials.getPassword());
 }
 
+BlockInputStreamPtr HTTPDictionarySource::createWrappedBuffer(std::unique_ptr<ReadWriteBufferFromHTTP> http_buffer_ptr)
+{
+    Poco::URI uri(url);
+    String http_request_compression_method_str = http_buffer_ptr->getCompressionMethod();
+    auto in_ptr_wrapped
+        = wrapReadBufferWithCompressionMethod(std::move(http_buffer_ptr), chooseCompressionMethod(uri.getPath(), http_request_compression_method_str));
+    auto input_stream = context->getInputFormat(format, *in_ptr_wrapped, sample_block, max_block_size);
+    return std::make_shared<OwningBlockInputStream<ReadBuffer>>(input_stream, std::move(in_ptr_wrapped));
+}
+
 void HTTPDictionarySource::getUpdateFieldAndDate(Poco::URI & uri)
 {
     if (update_time != std::chrono::system_clock::from_time_t(0))
@@ -109,10 +118,15 @@ BlockInputStreamPtr HTTPDictionarySource::loadAll()
     LOG_TRACE(log, "loadAll {}", toString());
     Poco::URI uri(url);
     auto in_ptr = std::make_unique<ReadWriteBufferFromHTTP>(
-        uri, Poco::Net::HTTPRequest::HTTP_GET, ReadWriteBufferFromHTTP::OutStreamCallback(), timeouts,
-        0, credentials, DBMS_DEFAULT_BUFFER_SIZE, header_entries);
-    auto input_stream = context->getInputFormat(format, *in_ptr, sample_block, max_block_size);
-    return std::make_shared<OwningBlockInputStream<ReadWriteBufferFromHTTP>>(input_stream, std::move(in_ptr));
+        uri,
+        Poco::Net::HTTPRequest::HTTP_GET,
+        ReadWriteBufferFromHTTP::OutStreamCallback(),
+        timeouts,
+        0,
+        credentials,
+        DBMS_DEFAULT_BUFFER_SIZE,
+        header_entries);
+    return createWrappedBuffer(std::move(in_ptr));
 }
 
 BlockInputStreamPtr HTTPDictionarySource::loadUpdatedAll()
@@ -121,10 +135,15 @@ BlockInputStreamPtr HTTPDictionarySource::loadUpdatedAll()
     getUpdateFieldAndDate(uri);
     LOG_TRACE(log, "loadUpdatedAll {}", uri.toString());
     auto in_ptr = std::make_unique<ReadWriteBufferFromHTTP>(
-        uri, Poco::Net::HTTPRequest::HTTP_GET, ReadWriteBufferFromHTTP::OutStreamCallback(), timeouts,
-        0, credentials, DBMS_DEFAULT_BUFFER_SIZE, header_entries);
-    auto input_stream = context->getInputFormat(format, *in_ptr, sample_block, max_block_size);
-    return std::make_shared<OwningBlockInputStream<ReadWriteBufferFromHTTP>>(input_stream, std::move(in_ptr));
+        uri,
+        Poco::Net::HTTPRequest::HTTP_GET,
+        ReadWriteBufferFromHTTP::OutStreamCallback(),
+        timeouts,
+        0,
+        credentials,
+        DBMS_DEFAULT_BUFFER_SIZE,
+        header_entries);
+    return createWrappedBuffer(std::move(in_ptr));
 }
 
 BlockInputStreamPtr HTTPDictionarySource::loadIds(const std::vector<UInt64> & ids)
@@ -142,10 +161,15 @@ BlockInputStreamPtr HTTPDictionarySource::loadIds(const std::vector<UInt64> & id
 
     Poco::URI uri(url);
     auto in_ptr = std::make_unique<ReadWriteBufferFromHTTP>(
-        uri, Poco::Net::HTTPRequest::HTTP_POST, out_stream_callback, timeouts,
-        0, credentials, DBMS_DEFAULT_BUFFER_SIZE, header_entries);
-    auto input_stream = context->getInputFormat(format, *in_ptr, sample_block, max_block_size);
-    return std::make_shared<OwningBlockInputStream<ReadWriteBufferFromHTTP>>(input_stream, std::move(in_ptr));
+        uri,
+        Poco::Net::HTTPRequest::HTTP_POST,
+        out_stream_callback,
+        timeouts,
+        0,
+        credentials,
+        DBMS_DEFAULT_BUFFER_SIZE,
+        header_entries);
+    return createWrappedBuffer(std::move(in_ptr));
 }
 
 BlockInputStreamPtr HTTPDictionarySource::loadKeys(const Columns & key_columns, const std::vector<size_t> & requested_rows)
@@ -163,10 +187,15 @@ BlockInputStreamPtr HTTPDictionarySource::loadKeys(const Columns & key_columns,
 
     Poco::URI uri(url);
     auto in_ptr = std::make_unique<ReadWriteBufferFromHTTP>(
-        uri, Poco::Net::HTTPRequest::HTTP_POST, out_stream_callback, timeouts,
-        0, credentials, DBMS_DEFAULT_BUFFER_SIZE, header_entries);
-    auto input_stream = context->getInputFormat(format, *in_ptr, sample_block, max_block_size);
-    return std::make_shared<OwningBlockInputStream<ReadWriteBufferFromHTTP>>(input_stream, std::move(in_ptr));
+        uri,
+        Poco::Net::HTTPRequest::HTTP_POST,
+        out_stream_callback,
+        timeouts,
+        0,
+        credentials,
+        DBMS_DEFAULT_BUFFER_SIZE,
+        header_entries);
+    return createWrappedBuffer(std::move(in_ptr));
 }
 
 bool HTTPDictionarySource::isModified() const
@@ -198,21 +227,19 @@ std::string HTTPDictionarySource::toString() const
 void registerDictionarySourceHTTP(DictionarySourceFactory & factory)
 {
     auto create_table_source = [=](const DictionaryStructure & dict_struct,
-                                 const Poco::Util::AbstractConfiguration & config,
-                                 const std::string & config_prefix,
-                                 Block & sample_block,
-                                 ContextPtr context,
-                                 const std::string & /* default_database */,
-                                 bool check_config) -> DictionarySourcePtr
-    {
+                                   const Poco::Util::AbstractConfiguration & config,
+                                   const std::string & config_prefix,
+                                   Block & sample_block,
+                                   ContextPtr context,
+                                   const std::string & /* default_database */,
+                                   bool check_config) -> DictionarySourcePtr {
         if (dict_struct.has_expressions)
             throw Exception(ErrorCodes::LOGICAL_ERROR, "Dictionary source of type `http` does not support attribute expressions");
 
         auto context_local_copy = copyContextAndApplySettings(config_prefix, context, config);
 
         return std::make_unique<HTTPDictionarySource>(
-            dict_struct, config, config_prefix + ".http",
-            sample_block, context_local_copy, check_config);
+            dict_struct, config, config_prefix + ".http", sample_block, context_local_copy, check_config);
     };
     factory.registerSource("http", create_table_source);
 }
diff --git a/src/Dictionaries/HTTPDictionarySource.h b/src/Dictionaries/HTTPDictionarySource.h
index c42c67ec8c9..5b48e8a5a9c 100644
--- a/src/Dictionaries/HTTPDictionarySource.h
+++ b/src/Dictionaries/HTTPDictionarySource.h
@@ -8,6 +8,7 @@
 #include "DictionaryStructure.h"
 #include "IDictionarySource.h"
 #include <Interpreters/Context.h>
+#include <IO/CompressionMethod.h>
 
 namespace Poco
 {
@@ -53,6 +54,9 @@ public:
 private:
     void getUpdateFieldAndDate(Poco::URI & uri);
 
+    // wrap buffer using encoding from made request
+    BlockInputStreamPtr createWrappedBuffer(std::unique_ptr<ReadWriteBufferFromHTTP> http_buffer);
+
     Poco::Logger * log;
 
     LocalDateTime getLastModification() const;
@@ -70,3 +74,4 @@ private:
 };
 
 }
+
diff --git a/src/Dictionaries/HashedDictionary.cpp b/src/Dictionaries/HashedDictionary.cpp
index 64699b1711d..b0b62760fb2 100644
--- a/src/Dictionaries/HashedDictionary.cpp
+++ b/src/Dictionaries/HashedDictionary.cpp
@@ -162,6 +162,7 @@ ColumnUInt8::Ptr HashedDictionary<dictionary_key_type, sparse>::hasKeys(const Co
 
     const auto & attribute = attributes.front();
     bool is_attribute_nullable = attribute.is_nullable_set.has_value();
+    size_t keys_found = 0;
 
     getAttributeContainer(0, [&](const auto & container)
     {
@@ -171,6 +172,8 @@ ColumnUInt8::Ptr HashedDictionary<dictionary_key_type, sparse>::hasKeys(const Co
 
             out[requested_key_index] = container.find(requested_key) != container.end();
 
+            keys_found += out[requested_key_index];
+
             if (is_attribute_nullable && !out[requested_key_index])
                 out[requested_key_index] = attribute.is_nullable_set->find(requested_key) != nullptr;
 
@@ -179,6 +182,7 @@ ColumnUInt8::Ptr HashedDictionary<dictionary_key_type, sparse>::hasKeys(const Co
     });
 
     query_count.fetch_add(keys_size, std::memory_order_relaxed);
+    found_count.fetch_add(keys_found, std::memory_order_relaxed);
 
     return result;
 }
@@ -201,6 +205,8 @@ ColumnPtr HashedDictionary<dictionary_key_type, sparse>::getHierarchy(ColumnPtr
 
         auto is_key_valid_func = [&](auto & key) { return parent_keys_map.find(key) != parent_keys_map.end(); };
 
+        size_t keys_found = 0;
+
         auto get_parent_func = [&](auto & hierarchy_key)
         {
             std::optional<UInt64> result;
@@ -210,12 +216,15 @@ ColumnPtr HashedDictionary<dictionary_key_type, sparse>::getHierarchy(ColumnPtr
             if (it != parent_keys_map.end())
                 result = getValueFromCell(it);
 
+            keys_found +=result.has_value();
+
             return result;
         };
 
         auto dictionary_hierarchy_array = getKeysHierarchyArray(keys, null_value, is_key_valid_func, get_parent_func);
 
         query_count.fetch_add(keys.size(), std::memory_order_relaxed);
+        found_count.fetch_add(keys_found, std::memory_order_relaxed);
 
         return dictionary_hierarchy_array;
     }
@@ -247,6 +256,8 @@ ColumnUInt8::Ptr HashedDictionary<dictionary_key_type, sparse>::isInHierarchy(
 
         auto is_key_valid_func = [&](auto & key) { return parent_keys_map.find(key) != parent_keys_map.end(); };
 
+        size_t keys_found = 0;
+
         auto get_parent_func = [&](auto & hierarchy_key)
         {
             std::optional<UInt64> result;
@@ -256,12 +267,15 @@ ColumnUInt8::Ptr HashedDictionary<dictionary_key_type, sparse>::isInHierarchy(
             if (it != parent_keys_map.end())
                 result = getValueFromCell(it);
 
+            keys_found += result.has_value();
+
             return result;
         };
 
         auto result = getKeysIsInHierarchyColumn(keys, keys_in, null_value, is_key_valid_func, get_parent_func);
 
         query_count.fetch_add(keys.size(), std::memory_order_relaxed);
+        found_count.fetch_add(keys_found, std::memory_order_relaxed);
 
         return result;
     }
@@ -290,9 +304,11 @@ ColumnPtr HashedDictionary<dictionary_key_type, sparse>::getDescendants(
         for (const auto & [key, value] : parent_keys)
             parent_to_child[value].emplace_back(key);
 
-        auto result = getKeysDescendantsArray(keys, parent_to_child, level);
+        size_t keys_found;
+        auto result = getKeysDescendantsArray(keys, parent_to_child, level, keys_found);
 
         query_count.fetch_add(keys.size(), std::memory_order_relaxed);
+        found_count.fetch_add(keys_found, std::memory_order_relaxed);
 
         return result;
     }
@@ -493,6 +509,8 @@ void HashedDictionary<dictionary_key_type, sparse>::getItemsImpl(
 
     bool is_attribute_nullable = attribute.is_nullable_set.has_value();
 
+    size_t keys_found = 0;
+
     for (size_t key_index = 0; key_index < keys_size; ++key_index)
     {
         auto key = keys_extractor.extractCurrentKey();
@@ -500,7 +518,10 @@ void HashedDictionary<dictionary_key_type, sparse>::getItemsImpl(
         const auto it = attribute_container.find(key);
 
         if (it != attribute_container.end())
+        {
             set_value(key_index, getValueFromCell(it));
+            ++keys_found;
+        }
         else
         {
             if (is_attribute_nullable && attribute.is_nullable_set->find(key) != nullptr)
@@ -513,6 +534,7 @@ void HashedDictionary<dictionary_key_type, sparse>::getItemsImpl(
     }
 
     query_count.fetch_add(keys_size, std::memory_order_relaxed);
+    found_count.fetch_add(keys_found, std::memory_order_relaxed);
 }
 
 template <DictionaryKeyType dictionary_key_type, bool sparse>
diff --git a/src/Dictionaries/HashedDictionary.h b/src/Dictionaries/HashedDictionary.h
index f6c77960f55..cc04c6805ee 100644
--- a/src/Dictionaries/HashedDictionary.h
+++ b/src/Dictionaries/HashedDictionary.h
@@ -59,6 +59,14 @@ public:
 
     size_t getQueryCount() const override { return query_count.load(std::memory_order_relaxed); }
 
+    double getFoundRate() const override
+    {
+        size_t queries = query_count.load(std::memory_order_relaxed);
+        if (!queries)
+            return 0;
+        return static_cast<double>(found_count.load(std::memory_order_relaxed)) / queries;
+    }
+
     double getHitRate() const override { return 1.0; }
 
     size_t getElementCount() const override { return element_count; }
@@ -145,16 +153,20 @@ private:
             UInt32,
             UInt64,
             UInt128,
+            UInt256,
             Int8,
             Int16,
             Int32,
             Int64,
+            Int128,
+            Int256,
             Decimal32,
             Decimal64,
             Decimal128,
             Decimal256,
             Float32,
             Float64,
+            UUID,
             StringRef>
             null_values;
 
@@ -164,16 +176,20 @@ private:
             CollectionType<UInt32>,
             CollectionType<UInt64>,
             CollectionType<UInt128>,
+            CollectionType<UInt256>,
             CollectionType<Int8>,
             CollectionType<Int16>,
             CollectionType<Int32>,
             CollectionType<Int64>,
+            CollectionType<Int128>,
+            CollectionType<Int256>,
             CollectionType<Decimal32>,
             CollectionType<Decimal64>,
             CollectionType<Decimal128>,
             CollectionType<Decimal256>,
             CollectionType<Float32>,
             CollectionType<Float64>,
+            CollectionType<UUID>,
             CollectionType<StringRef>>
             container;
 
@@ -219,6 +235,7 @@ private:
     size_t element_count = 0;
     size_t bucket_count = 0;
     mutable std::atomic<size_t> query_count{0};
+    mutable std::atomic<size_t> found_count{0};
 
     BlockPtr update_field_loaded_block;
     Arena complex_key_arena;
diff --git a/src/Dictionaries/HierarchyDictionariesUtils.cpp b/src/Dictionaries/HierarchyDictionariesUtils.cpp
index 5bca6a5ac1a..dd729fe636c 100644
--- a/src/Dictionaries/HierarchyDictionariesUtils.cpp
+++ b/src/Dictionaries/HierarchyDictionariesUtils.cpp
@@ -84,8 +84,14 @@ namespace
     }
 }
 
-ColumnPtr getKeysHierarchyDefaultImplementation(const IDictionary * dictionary, ColumnPtr key_column, const DataTypePtr & key_type)
+ColumnPtr getKeysHierarchyDefaultImplementation(
+    const IDictionary * dictionary,
+    ColumnPtr key_column,
+    const DataTypePtr & key_type,
+    size_t & valid_keys)
 {
+    valid_keys = 0;
+
     key_column = key_column->convertToFullColumnIfConst();
     const auto * key_column_typed = checkAndGetColumn<ColumnVector<UInt64>>(*key_column);
     if (!key_column_typed)
@@ -104,6 +110,7 @@ ColumnPtr getKeysHierarchyDefaultImplementation(const IDictionary * dictionary,
     {
         auto it = key_to_parent_key.find(key);
         std::optional<UInt64> result = (it != nullptr ? std::make_optional(it->getMapped()) : std::nullopt);
+        valid_keys += result.has_value();
         return result;
     };
 
@@ -117,8 +124,11 @@ ColumnUInt8::Ptr getKeysIsInHierarchyDefaultImplementation(
     const IDictionary * dictionary,
     ColumnPtr key_column,
     ColumnPtr in_key_column,
-    const DataTypePtr & key_type)
+    const DataTypePtr & key_type,
+    size_t & valid_keys)
 {
+    valid_keys = 0;
+
     key_column = key_column->convertToFullColumnIfConst();
     in_key_column = in_key_column->convertToFullColumnIfConst();
 
@@ -143,6 +153,7 @@ ColumnUInt8::Ptr getKeysIsInHierarchyDefaultImplementation(
     {
         auto it = key_to_parent_key.find(key);
         std::optional<UInt64> result = (it != nullptr ? std::make_optional(it->getMapped()) : std::nullopt);
+        valid_keys += result.has_value();
         return result;
     };
 
diff --git a/src/Dictionaries/HierarchyDictionariesUtils.h b/src/Dictionaries/HierarchyDictionariesUtils.h
index 8b2fe6ef08e..44382f4720f 100644
--- a/src/Dictionaries/HierarchyDictionariesUtils.h
+++ b/src/Dictionaries/HierarchyDictionariesUtils.h
@@ -196,6 +196,8 @@ namespace detail
       * Hierarchy result is ElementsAndOffsets structure, for each element there is descendants array,
       * with size offset[element_index] - (element_index > 0 ? offset[element_index - 1] : 0).
       *
+      * @param valid_keys - number of keys that are valid in parent_to_child map
+      *
       * Example:
       * id  parent_id
       * 1   0
@@ -218,11 +220,13 @@ namespace detail
     ElementsAndOffsets<KeyType> getDescendants(
         const PaddedPODArray<KeyType> & keys,
         const HashMap<KeyType, PaddedPODArray<KeyType>> & parent_to_child,
-        Strategy strategy)
+        Strategy strategy,
+        size_t & valid_keys)
     {
         /// If strategy is GetAllDescendantsStrategy we try to cache and later reuse previously calculated descendants.
         /// If strategy is GetDescendantsAtSpecificLevelStrategy we does not use cache strategy.
         size_t keys_size = keys.size();
+        valid_keys = 0;
 
         PaddedPODArray<KeyType> descendants;
         descendants.reserve(keys_size);
@@ -265,6 +269,7 @@ namespace detail
                 descendants_offsets.emplace_back(descendants.size());
                 continue;
             }
+            ++valid_keys;
 
             next_keys_to_process_stack.emplace_back(KeyAndDepth{requested_key, 0});
 
@@ -425,43 +430,52 @@ ColumnUInt8::Ptr getKeysIsInHierarchyColumn(
 }
 
 /// Returns descendants array column for keys
+///
+/// @param valid_keys - number of keys that are valid in parent_to_child map
 template <typename KeyType>
 ColumnPtr getKeysDescendantsArray(
     const PaddedPODArray<KeyType> & requested_keys,
     const HashMap<KeyType, PaddedPODArray<KeyType>> & parent_to_child,
-    size_t level)
+    size_t level,
+    size_t & valid_keys)
 {
     if (level == 0)
     {
         detail::GetAllDescendantsStrategy strategy { .level = level };
-        auto elements_and_offsets = detail::getDescendants(requested_keys, parent_to_child, strategy);
+        auto elements_and_offsets = detail::getDescendants(requested_keys, parent_to_child, strategy, valid_keys);
         return detail::convertElementsAndOffsetsIntoArray(std::move(elements_and_offsets));
     }
     else
     {
         detail::GetDescendantsAtSpecificLevelStrategy strategy { .level = level };
-        auto elements_and_offsets = detail::getDescendants(requested_keys, parent_to_child, strategy);
+        auto elements_and_offsets = detail::getDescendants(requested_keys, parent_to_child, strategy, valid_keys);
         return detail::convertElementsAndOffsetsIntoArray(std::move(elements_and_offsets));
     }
 }
 
 /** Default getHierarchy implementation for dictionaries that does not have structure with child to parent representation.
   * Implementation will build such structure with getColumn calls, and then getHierarchy for such structure.
-  * Returns ColumnArray with hierarchy arrays for keys from key_column.
+  *
+  * @param valid_keys - number of keys (from @key_column) for which information about parent exists.
+  * @return ColumnArray with hierarchy arrays for keys from key_column.
   */
 ColumnPtr getKeysHierarchyDefaultImplementation(
     const IDictionary * dictionary,
     ColumnPtr key_column,
-    const DataTypePtr & key_type);
+    const DataTypePtr & key_type,
+    size_t & valid_keys);
 
 /** Default isInHierarchy implementation for dictionaries that does not have structure with child to parent representation.
   * Implementation will build such structure with getColumn calls, and then getHierarchy for such structure.
-  * Returns UInt8 column if key from in_key_column is in key hierarchy from key_column.
+  *
+  * @param valid_keys - number of keys (from @key_column) for which information about parent exists.
+  * @return UInt8 column if key from in_key_column is in key hierarchy from key_column.
   */
 ColumnUInt8::Ptr getKeysIsInHierarchyDefaultImplementation(
     const IDictionary * dictionary,
     ColumnPtr key_column,
     ColumnPtr in_key_column,
-    const DataTypePtr & key_type);
+    const DataTypePtr & key_type,
+    size_t & valid_keys);
 
 }
diff --git a/src/Dictionaries/IDictionary.h b/src/Dictionaries/IDictionary.h
index a7445312409..5467a673503 100644
--- a/src/Dictionaries/IDictionary.h
+++ b/src/Dictionaries/IDictionary.h
@@ -90,6 +90,8 @@ struct IDictionary : public IExternalLoadable
 
     virtual size_t getQueryCount() const = 0;
 
+    virtual double getFoundRate() const = 0;
+
     virtual double getHitRate() const = 0;
 
     virtual size_t getElementCount() const = 0;
diff --git a/src/Dictionaries/IPAddressDictionary.cpp b/src/Dictionaries/IPAddressDictionary.cpp
index 5c5f71e0b1d..dd6bb3bb42c 100644
--- a/src/Dictionaries/IPAddressDictionary.cpp
+++ b/src/Dictionaries/IPAddressDictionary.cpp
@@ -275,7 +275,9 @@ ColumnUInt8::Ptr IPAddressDictionary::hasKeys(const Columns & key_columns, const
     const auto rows = first_column->size();
 
     auto result = ColumnUInt8::create(rows);
-    auto& out = result->getData();
+    auto & out = result->getData();
+
+    size_t keys_found = 0;
 
     if (first_column->isNumeric())
     {
@@ -285,6 +287,7 @@ ColumnUInt8::Ptr IPAddressDictionary::hasKeys(const Columns & key_columns, const
             auto addrv4 = UInt32(first_column->get64(i));
             auto found = tryLookupIPv4(addrv4, addrv6_buf);
             out[i] = (found != ipNotFound());
+            keys_found += out[i];
         }
     }
     else
@@ -297,10 +300,12 @@ ColumnUInt8::Ptr IPAddressDictionary::hasKeys(const Columns & key_columns, const
 
             auto found = tryLookupIPv6(reinterpret_cast<const uint8_t *>(addr.data));
             out[i] = (found != ipNotFound());
+            keys_found += out[i];
         }
     }
 
     query_count.fetch_add(rows, std::memory_order_relaxed);
+    found_count.fetch_add(keys_found, std::memory_order_relaxed);
 
     return result;
 }
@@ -680,6 +685,8 @@ void IPAddressDictionary::getItemsImpl(
 
     auto & vec = std::get<ContainerType<AttributeType>>(attribute.maps);
 
+    size_t keys_found = 0;
+
     if (first_column->isNumeric())
     {
         uint8_t addrv6_buf[IPV6_BINARY_LENGTH];
@@ -689,7 +696,10 @@ void IPAddressDictionary::getItemsImpl(
             auto addrv4 = UInt32(first_column->get64(i));
             auto found = tryLookupIPv4(addrv4, addrv6_buf);
             if (found != ipNotFound())
+            {
                 set_value(i, static_cast<OutputType>(vec[*found]));
+                ++keys_found;
+            }
             else
                 set_value(i, default_value_extractor[i]);
         }
@@ -704,13 +714,17 @@ void IPAddressDictionary::getItemsImpl(
 
             auto found = tryLookupIPv6(reinterpret_cast<const uint8_t *>(addr.data));
             if (found != ipNotFound())
+            {
                 set_value(i, static_cast<OutputType>(vec[*found]));
+                ++keys_found;
+            }
             else
                 set_value(i, default_value_extractor[i]);
         }
     }
 
     query_count.fetch_add(rows, std::memory_order_relaxed);
+    found_count.fetch_add(keys_found, std::memory_order_relaxed);
 }
 
 template <typename T>
diff --git a/src/Dictionaries/IPAddressDictionary.h b/src/Dictionaries/IPAddressDictionary.h
index 619d1579e4e..edca68aedba 100644
--- a/src/Dictionaries/IPAddressDictionary.h
+++ b/src/Dictionaries/IPAddressDictionary.h
@@ -38,6 +38,14 @@ public:
 
     size_t getQueryCount() const override { return query_count.load(std::memory_order_relaxed); }
 
+    double getFoundRate() const override
+    {
+        size_t queries = query_count.load(std::memory_order_relaxed);
+        if (!queries)
+            return 0;
+        return static_cast<double>(found_count.load(std::memory_order_relaxed)) / queries;
+    }
+
     double getHitRate() const override { return 1.0; }
 
     size_t getElementCount() const override { return element_count; }
@@ -94,16 +102,20 @@ private:
             UInt32,
             UInt64,
             UInt128,
+            UInt256,
             Int8,
             Int16,
             Int32,
             Int64,
+            Int128,
+            Int256,
             Decimal32,
             Decimal64,
             Decimal128,
             Decimal256,
             Float32,
             Float64,
+            UUID,
             String>
             null_values;
         std::variant<
@@ -112,16 +124,20 @@ private:
             ContainerType<UInt32>,
             ContainerType<UInt64>,
             ContainerType<UInt128>,
+            ContainerType<UInt256>,
             ContainerType<Int8>,
             ContainerType<Int16>,
             ContainerType<Int32>,
             ContainerType<Int64>,
+            ContainerType<Int128>,
+            ContainerType<Int256>,
             ContainerType<Decimal32>,
             ContainerType<Decimal64>,
             ContainerType<Decimal128>,
             ContainerType<Decimal256>,
             ContainerType<Float32>,
             ContainerType<Float64>,
+            ContainerType<UUID>,
             ContainerType<StringRef>>
             maps;
         std::unique_ptr<Arena> string_arena;
@@ -202,6 +218,7 @@ private:
     size_t element_count = 0;
     size_t bucket_count = 0;
     mutable std::atomic<size_t> query_count{0};
+    mutable std::atomic<size_t> found_count{0};
 
     Poco::Logger * logger;
 };
diff --git a/src/Dictionaries/MongoDBDictionarySource.cpp b/src/Dictionaries/MongoDBDictionarySource.cpp
index 0ab45dc4593..63495174037 100644
--- a/src/Dictionaries/MongoDBDictionarySource.cpp
+++ b/src/Dictionaries/MongoDBDictionarySource.cpp
@@ -50,7 +50,6 @@ void registerDictionarySourceMongoDB(DictionarySourceFactory & factory)
 // Poco/MongoDB/BSONWriter.h:54: void writeCString(const std::string & value);
 // src/IO/WriteHelpers.h:146 #define writeCString(s, buf)
 #include <IO/WriteHelpers.h>
-#include <Common/FieldVisitors.h>
 #include <ext/enumerate.h>
 #include <DataStreams/MongoDBBlockInputStream.h>
 
@@ -59,6 +58,7 @@ namespace DB
 {
 namespace ErrorCodes
 {
+    extern const int NOT_IMPLEMENTED;
     extern const int UNSUPPORTED_METHOD;
     extern const int MONGODB_CANNOT_AUTHENTICATE;
 }
@@ -186,28 +186,26 @@ BlockInputStreamPtr MongoDBDictionarySource::loadKeys(const Columns & key_column
         {
             switch (attr.second.underlying_type)
             {
-                case AttributeUnderlyingType::utUInt8:
-                case AttributeUnderlyingType::utUInt16:
-                case AttributeUnderlyingType::utUInt32:
-                case AttributeUnderlyingType::utUInt64:
-                case AttributeUnderlyingType::utUInt128:
-                case AttributeUnderlyingType::utInt8:
-                case AttributeUnderlyingType::utInt16:
-                case AttributeUnderlyingType::utInt32:
-                case AttributeUnderlyingType::utInt64:
-                case AttributeUnderlyingType::utDecimal32:
-                case AttributeUnderlyingType::utDecimal64:
-                case AttributeUnderlyingType::utDecimal128:
-                case AttributeUnderlyingType::utDecimal256:
+                case AttributeUnderlyingType::UInt8:
+                case AttributeUnderlyingType::UInt16:
+                case AttributeUnderlyingType::UInt32:
+                case AttributeUnderlyingType::UInt64:
+                case AttributeUnderlyingType::Int8:
+                case AttributeUnderlyingType::Int16:
+                case AttributeUnderlyingType::Int32:
+                case AttributeUnderlyingType::Int64:
+                {
                     key.add(attr.second.name, Int32(key_columns[attr.first]->get64(row_idx)));
                     break;
-
-                case AttributeUnderlyingType::utFloat32:
-                case AttributeUnderlyingType::utFloat64:
+                }
+                case AttributeUnderlyingType::Float32:
+                case AttributeUnderlyingType::Float64:
+                {
                     key.add(attr.second.name, key_columns[attr.first]->getFloat64(row_idx));
                     break;
-
-                case AttributeUnderlyingType::utString:
+                }
+                case AttributeUnderlyingType::String:
+                {
                     String loaded_str(get<String>((*key_columns[attr.first])[row_idx]));
                     /// Convert string to ObjectID
                     if (attr.second.is_object_id)
@@ -220,6 +218,9 @@ BlockInputStreamPtr MongoDBDictionarySource::loadKeys(const Columns & key_column
                         key.add(attr.second.name, loaded_str);
                     }
                     break;
+                }
+                default:
+                    throw Exception("Unsupported dictionary attribute type for MongoDB dictionary source", ErrorCodes::NOT_IMPLEMENTED);
             }
         }
     }
diff --git a/src/Dictionaries/MySQLDictionarySource.cpp b/src/Dictionaries/MySQLDictionarySource.cpp
index 676863ae588..e440ed59fb0 100644
--- a/src/Dictionaries/MySQLDictionarySource.cpp
+++ b/src/Dictionaries/MySQLDictionarySource.cpp
@@ -164,7 +164,7 @@ bool MySQLDictionarySource::isModified() const
     if (!invalidate_query.empty())
     {
         auto response = doInvalidateQuery(invalidate_query);
-        if (response == invalidate_query_response)
+        if (response == invalidate_query_response) //-V1051
             return false;
         invalidate_query_response = response;
         return true;
diff --git a/src/Dictionaries/PolygonDictionary.cpp b/src/Dictionaries/PolygonDictionary.cpp
index 64d435cf632..084228c98ae 100644
--- a/src/Dictionaries/PolygonDictionary.cpp
+++ b/src/Dictionaries/PolygonDictionary.cpp
@@ -64,6 +64,8 @@ ColumnPtr IPolygonDictionary::getColumn(
     Field row_value_to_insert;
     size_t polygon_index = 0;
 
+    size_t keys_found = 0;
+
     if (unlikely(complex_attribute))
     {
         for (size_t requested_key_index = 0; requested_key_index < requested_key_points.size(); ++requested_key_index)
@@ -74,6 +76,7 @@ ColumnPtr IPolygonDictionary::getColumn(
             {
                 size_t attribute_values_index = polygon_index_to_attribute_value_index[polygon_index];
                 attribute_values_column->get(attribute_values_index, row_value_to_insert);
+                ++keys_found;
             }
             else
                 row_value_to_insert = default_value_provider.getDefaultValue(requested_key_index);
@@ -110,6 +113,7 @@ ColumnPtr IPolygonDictionary::getColumn(
                         size_t attribute_values_index = polygon_index_to_attribute_value_index[polygon_index];
                         auto data_to_insert = attribute_values_column->getDataAt(attribute_values_index);
                         result_column_typed.insertData(data_to_insert.data, data_to_insert.size);
+                        ++keys_found;
                     }
                     else
                         result_column_typed.insert(default_value_provider.getDefaultValue(requested_key_index));
@@ -129,6 +133,7 @@ ColumnPtr IPolygonDictionary::getColumn(
                         size_t attribute_values_index = polygon_index_to_attribute_value_index[polygon_index];
                         auto & item = attribute_data[attribute_values_index];
                         result_data.emplace_back(item);
+                        ++keys_found;
                     }
                     else
                     {
@@ -143,6 +148,7 @@ ColumnPtr IPolygonDictionary::getColumn(
     }
 
     query_count.fetch_add(requested_key_points.size(), std::memory_order_relaxed);
+    found_count.fetch_add(keys_found, std::memory_order_relaxed);
 
     return result;
 }
@@ -285,16 +291,20 @@ ColumnUInt8::Ptr IPolygonDictionary::hasKeys(const Columns & key_columns, const
     std::vector<IPolygonDictionary::Point> points = extractPoints(key_columns);
 
     auto result = ColumnUInt8::create(points.size());
-    auto& out = result->getData();
+    auto & out = result->getData();
+
+    size_t keys_found = 0;
 
     for (size_t i = 0; i < points.size(); ++i)
     {
         size_t unused_find_result = 0;
         auto & point = points[i];
         out[i] = find(point, unused_find_result);
+        keys_found += out[i];
     }
 
     query_count.fetch_add(points.size(), std::memory_order_relaxed);
+    found_count.fetch_add(keys_found, std::memory_order_relaxed);
 
     return result;
 }
diff --git a/src/Dictionaries/PolygonDictionary.h b/src/Dictionaries/PolygonDictionary.h
index 5974e6461a7..f43fc0c8f57 100644
--- a/src/Dictionaries/PolygonDictionary.h
+++ b/src/Dictionaries/PolygonDictionary.h
@@ -63,6 +63,14 @@ public:
 
     size_t getQueryCount() const override { return query_count.load(std::memory_order_relaxed); }
 
+    double getFoundRate() const override
+    {
+        size_t queries = query_count.load(std::memory_order_relaxed);
+        if (!queries)
+            return 0;
+        return static_cast<double>(found_count.load(std::memory_order_relaxed)) / queries;
+    }
+
     double getHitRate() const override { return 1.0; }
 
     size_t getElementCount() const override { return attributes.empty() ? 0 : attributes.front()->size(); }
@@ -141,6 +149,7 @@ private:
 
     size_t bytes_allocated = 0;
     mutable std::atomic<size_t> query_count{0};
+    mutable std::atomic<size_t> found_count{0};
 
     /** Since the original data may have been in the form of multi-polygons, an id is stored for each single polygon
      *  corresponding to the row in which any other attributes for this entry are located.
diff --git a/src/Dictionaries/PostgreSQLDictionarySource.cpp b/src/Dictionaries/PostgreSQLDictionarySource.cpp
index 051ee94ef3e..af7aef45acc 100644
--- a/src/Dictionaries/PostgreSQLDictionarySource.cpp
+++ b/src/Dictionaries/PostgreSQLDictionarySource.cpp
@@ -103,7 +103,7 @@ bool PostgreSQLDictionarySource::isModified() const
     if (!invalidate_query.empty())
     {
         auto response = doInvalidateQuery(invalidate_query);
-        if (response == invalidate_query_response)
+        if (response == invalidate_query_response) //-V1051
             return false;
         invalidate_query_response = response;
     }
diff --git a/src/Dictionaries/RangeHashedDictionary.cpp b/src/Dictionaries/RangeHashedDictionary.cpp
index 1bdcd942b4a..4533e3ec58c 100644
--- a/src/Dictionaries/RangeHashedDictionary.cpp
+++ b/src/Dictionaries/RangeHashedDictionary.cpp
@@ -195,17 +195,20 @@ ColumnUInt8::Ptr RangeHashedDictionary::hasKeys(const Columns & key_columns, con
 
     ColumnUInt8::Ptr result;
 
+    size_t keys_found = 0;
+
     auto type_call = [&](const auto & dictionary_attribute_type)
     {
         using Type = std::decay_t<decltype(dictionary_attribute_type)>;
         using AttributeType = typename Type::AttributeType;
         using ValueType = DictionaryValueType<AttributeType>;
-        result = hasKeysImpl<ValueType>(attribute, ids, dates);
+        result = hasKeysImpl<ValueType>(attribute, ids, dates, keys_found);
     };
 
     callOnDictionaryAttributeType(attribute.type, type_call);
 
     query_count.fetch_add(ids.size(), std::memory_order_relaxed);
+    found_count.fetch_add(keys_found, std::memory_order_relaxed);
 
     return result;
 }
@@ -214,13 +217,16 @@ template <typename AttributeType>
 ColumnUInt8::Ptr RangeHashedDictionary::hasKeysImpl(
     const Attribute & attribute,
     const PaddedPODArray<UInt64> & ids,
-    const PaddedPODArray<RangeStorageType> & dates) const
+    const PaddedPODArray<RangeStorageType> & dates,
+    size_t & keys_found) const
 {
     auto result = ColumnUInt8::create(ids.size());
     auto& out = result->getData();
 
     const auto & attr = *std::get<Ptr<AttributeType>>(attribute.maps);
 
+    keys_found = 0;
+
     for (const auto row : ext::range(0, ids.size()))
     {
         const auto it = attr.find(ids[row]);
@@ -237,10 +243,8 @@ ColumnUInt8::Ptr RangeHashedDictionary::hasKeysImpl(
                     return v.range.contains(date);
                 });
 
-            if (val_it != std::end(ranges_and_values))
-                out[row] = true;
-            else
-                out[row] = false;
+            out[row] = val_it != std::end(ranges_and_values);
+            keys_found += out[row];
         }
         else
             out[row] = false;
@@ -396,6 +400,8 @@ void RangeHashedDictionary::getItemsImpl(
 
     const auto & attr = *std::get<Ptr<AttributeType>>(attribute.maps);
 
+    size_t keys_found = 0;
+
     for (const auto row : ext::range(0, ids.size()))
     {
         const auto it = attr.find(ids[row]);
@@ -413,7 +419,8 @@ void RangeHashedDictionary::getItemsImpl(
 
             if (val_it != std::end(ranges_and_values))
             {
-                auto& value = val_it->value;
+                ++keys_found;
+                auto & value = val_it->value;
 
                 if (value)
                     set_value(row, static_cast<OutputType>(*value), false); // NOLINT
@@ -432,6 +439,7 @@ void RangeHashedDictionary::getItemsImpl(
     }
 
     query_count.fetch_add(ids.size(), std::memory_order_relaxed);
+    found_count.fetch_add(keys_found, std::memory_order_relaxed);
 }
 
 
diff --git a/src/Dictionaries/RangeHashedDictionary.h b/src/Dictionaries/RangeHashedDictionary.h
index 8a286f530ba..edd8275acd1 100644
--- a/src/Dictionaries/RangeHashedDictionary.h
+++ b/src/Dictionaries/RangeHashedDictionary.h
@@ -32,6 +32,14 @@ public:
 
     size_t getQueryCount() const override { return query_count.load(std::memory_order_relaxed); }
 
+    double getFoundRate() const override
+    {
+        size_t queries = query_count.load(std::memory_order_relaxed);
+        if (!queries)
+            return 0;
+        return static_cast<double>(found_count.load(std::memory_order_relaxed)) / queries;
+    }
+
     double getHitRate() const override { return 1.0; }
 
     size_t getElementCount() const override { return element_count; }
@@ -105,16 +113,20 @@ private:
             UInt32,
             UInt64,
             UInt128,
+            UInt256,
             Int8,
             Int16,
             Int32,
             Int64,
+            Int128,
+            Int256,
             Decimal32,
             Decimal64,
             Decimal128,
             Decimal256,
             Float32,
             Float64,
+            UUID,
             StringRef>
             null_values;
         std::variant<
@@ -123,16 +135,20 @@ private:
             Ptr<UInt32>,
             Ptr<UInt64>,
             Ptr<UInt128>,
+            Ptr<UInt256>,
             Ptr<Int8>,
             Ptr<Int16>,
             Ptr<Int32>,
             Ptr<Int64>,
+            Ptr<Int128>,
+            Ptr<Int256>,
             Ptr<Decimal32>,
             Ptr<Decimal64>,
             Ptr<Decimal128>,
             Ptr<Decimal256>,
             Ptr<Float32>,
             Ptr<Float64>,
+            Ptr<UUID>,
             Ptr<StringRef>>
             maps;
         std::unique_ptr<Arena> string_arena;
@@ -163,7 +179,8 @@ private:
     ColumnUInt8::Ptr hasKeysImpl(
         const Attribute & attribute,
         const PaddedPODArray<UInt64> & ids,
-        const PaddedPODArray<RangeStorageType> & dates) const;
+        const PaddedPODArray<RangeStorageType> & dates,
+        size_t & keys_found) const;
 
     template <typename T>
     static void setAttributeValueImpl(Attribute & attribute, const UInt64 id, const Range & range, const Field & value);
@@ -201,6 +218,7 @@ private:
     size_t element_count = 0;
     size_t bucket_count = 0;
     mutable std::atomic<size_t> query_count{0};
+    mutable std::atomic<size_t> found_count{0};
 };
 
 }
diff --git a/src/Dictionaries/RedisBlockInputStream.cpp b/src/Dictionaries/RedisBlockInputStream.cpp
index f74ac348a99..bb8ef92eeea 100644
--- a/src/Dictionaries/RedisBlockInputStream.cpp
+++ b/src/Dictionaries/RedisBlockInputStream.cpp
@@ -109,7 +109,7 @@ namespace DB
                     break;
                 }
                 case ValueType::vtUUID:
-                    assert_cast<ColumnUInt128 &>(column).insertValue(parse<UUID>(string_value));
+                    assert_cast<ColumnUUID &>(column).insertValue(parse<UUID>(string_value));
                     break;
                 default:
                     throw Exception(ErrorCodes::UNKNOWN_TYPE,
diff --git a/src/Dictionaries/RedisDictionarySource.cpp b/src/Dictionaries/RedisDictionarySource.cpp
index 8144b37e63d..f62dc0d74bd 100644
--- a/src/Dictionaries/RedisDictionarySource.cpp
+++ b/src/Dictionaries/RedisDictionarySource.cpp
@@ -30,7 +30,6 @@ void registerDictionarySourceRedis(DictionarySourceFactory & factory)
 #include <Poco/Util/AbstractConfiguration.h>
 
 #include <IO/WriteHelpers.h>
-#include <Common/FieldVisitors.h>
 
 #include "RedisBlockInputStream.h"
 
diff --git a/src/Dictionaries/SSDCacheDictionaryStorage.h b/src/Dictionaries/SSDCacheDictionaryStorage.h
index 7d72beca35e..fcfb5803a18 100644
--- a/src/Dictionaries/SSDCacheDictionaryStorage.h
+++ b/src/Dictionaries/SSDCacheDictionaryStorage.h
@@ -744,6 +744,9 @@ private:
 
         FileDescriptor & operator=(FileDescriptor && rhs)
         {
+            if (this == &rhs)
+                return *this;
+
             close(fd);
 
             fd = rhs.fd;
diff --git a/src/Dictionaries/XDBCDictionarySource.cpp b/src/Dictionaries/XDBCDictionarySource.cpp
index 5774641a90f..618e5282068 100644
--- a/src/Dictionaries/XDBCDictionarySource.cpp
+++ b/src/Dictionaries/XDBCDictionarySource.cpp
@@ -225,7 +225,7 @@ bool XDBCDictionarySource::isModified() const
     if (!invalidate_query.empty())
     {
         auto response = doInvalidateQuery(invalidate_query);
-        if (invalidate_query_response == response)
+        if (invalidate_query_response == response) //-V1051
             return false;
         invalidate_query_response = response;
     }
diff --git a/src/Dictionaries/tests/gtest_dictionary_configuration.cpp b/src/Dictionaries/tests/gtest_dictionary_configuration.cpp
index 389199bfe61..2b16228b59e 100644
--- a/src/Dictionaries/tests/gtest_dictionary_configuration.cpp
+++ b/src/Dictionaries/tests/gtest_dictionary_configuration.cpp
@@ -19,10 +19,10 @@ static bool registered = false;
 #pragma GCC diagnostic ignored "-Wunused-function"
 static std::string configurationToString(const DictionaryConfigurationPtr & config)
 {
-    const Poco::Util::XMLConfiguration * xml_config = dynamic_cast<const Poco::Util::XMLConfiguration *>(config.get());
+    const Poco::Util::XMLConfiguration & xml_config = dynamic_cast<const Poco::Util::XMLConfiguration &>(*config);
     std::ostringstream oss;     // STYLE_CHECK_ALLOW_STD_STRING_STREAM
     oss.exceptions(std::ios::failbit);
-    xml_config->save(oss);
+    xml_config.save(oss);
     return oss.str();
 }
 
diff --git a/src/Dictionaries/tests/gtest_hierarchy_dictionaries_utils.cpp b/src/Dictionaries/tests/gtest_hierarchy_dictionaries_utils.cpp
index 064f57dfe11..f4854b7c77e 100644
--- a/src/Dictionaries/tests/gtest_hierarchy_dictionaries_utils.cpp
+++ b/src/Dictionaries/tests/gtest_hierarchy_dictionaries_utils.cpp
@@ -154,10 +154,12 @@ TEST(HierarchyDictionariesUtils, getDescendants)
         PaddedPODArray<UInt64> keys = {0, 1, 2, 3, 4};
 
         {
+            size_t keys_found;
             auto result = DB::detail::getDescendants(
                 keys,
                 parent_to_child,
-                DB::detail::GetAllDescendantsStrategy());
+                DB::detail::GetAllDescendantsStrategy(),
+                keys_found);
 
             const auto & actual_elements = result.elements;
             const auto & actual_offsets = result.offsets;
@@ -167,12 +169,15 @@ TEST(HierarchyDictionariesUtils, getDescendants)
 
             ASSERT_EQ(actual_elements, expected_elements);
             ASSERT_EQ(actual_offsets, expected_offsets);
+            ASSERT_EQ(keys_found, 3);
         }
         {
+            size_t keys_found;
             auto result = DB::detail::getDescendants(
                 keys,
                 parent_to_child,
-                DB::detail::GetDescendantsAtSpecificLevelStrategy{1});
+                DB::detail::GetDescendantsAtSpecificLevelStrategy{1},
+                keys_found);
 
             const auto & actual_elements = result.elements;
             const auto & actual_offsets = result.offsets;
@@ -182,6 +187,7 @@ TEST(HierarchyDictionariesUtils, getDescendants)
 
             ASSERT_EQ(actual_elements, expected_elements);
             ASSERT_EQ(actual_offsets, expected_offsets);
+            ASSERT_EQ(keys_found, 3);
         }
     }
     {
@@ -192,10 +198,12 @@ TEST(HierarchyDictionariesUtils, getDescendants)
         PaddedPODArray<UInt64> keys = {1, 2, 3};
 
         {
+            size_t keys_found;
             auto result = DB::detail::getDescendants(
                 keys,
                 parent_to_child,
-                DB::detail::GetAllDescendantsStrategy());
+                DB::detail::GetAllDescendantsStrategy(),
+                keys_found);
 
             const auto & actual_elements = result.elements;
             const auto & actual_offsets = result.offsets;
@@ -205,12 +213,15 @@ TEST(HierarchyDictionariesUtils, getDescendants)
 
             ASSERT_EQ(actual_elements, expected_elements);
             ASSERT_EQ(actual_offsets, expected_offsets);
+            ASSERT_EQ(keys_found, 2);
         }
         {
+            size_t keys_found;
             auto result = DB::detail::getDescendants(
                 keys,
                 parent_to_child,
-                DB::detail::GetDescendantsAtSpecificLevelStrategy{1});
+                DB::detail::GetDescendantsAtSpecificLevelStrategy{1},
+                keys_found);
 
             const auto & actual_elements = result.elements;
             const auto & actual_offsets = result.offsets;
@@ -220,6 +231,7 @@ TEST(HierarchyDictionariesUtils, getDescendants)
 
             ASSERT_EQ(actual_elements, expected_elements);
             ASSERT_EQ(actual_offsets, expected_offsets);
+            ASSERT_EQ(keys_found, 2);
         }
     }
 }
diff --git a/src/Disks/S3/registerDiskS3.cpp b/src/Disks/S3/registerDiskS3.cpp
index 56726cfcca1..c197496d1c6 100644
--- a/src/Disks/S3/registerDiskS3.cpp
+++ b/src/Disks/S3/registerDiskS3.cpp
@@ -115,6 +115,7 @@ std::shared_ptr<Aws::S3::S3Client>
 getClient(const Poco::Util::AbstractConfiguration & config, const String & config_prefix, ContextConstPtr context)
 {
     S3::PocoHTTPClientConfiguration client_configuration = S3::ClientFactory::instance().createClientConfiguration(
+        config.getString(config_prefix + ".region", ""),
         context->getRemoteHostFilter(), context->getGlobalContext()->getSettingsRef().s3_max_redirects);
 
     S3::URI uri(Poco::URI(config.getString(config_prefix + ".endpoint")));
diff --git a/src/Formats/MySQLBlockInputStream.cpp b/src/Formats/MySQLBlockInputStream.cpp
index be0cb31f22d..b12b4f755ed 100644
--- a/src/Formats/MySQLBlockInputStream.cpp
+++ b/src/Formats/MySQLBlockInputStream.cpp
@@ -177,8 +177,8 @@ namespace
                 break;
             }
             case ValueType::vtUUID:
-                assert_cast<ColumnUInt128 &>(column).insert(parse<UUID>(value.data(), value.size()));
-                read_bytes_size += assert_cast<ColumnUInt128 &>(column).byteSize();
+                assert_cast<ColumnUUID &>(column).insert(parse<UUID>(value.data(), value.size()));
+                read_bytes_size += assert_cast<ColumnUUID &>(column).byteSize();
                 break;
             case ValueType::vtDateTime64:[[fallthrough]];
             case ValueType::vtDecimal32: [[fallthrough]];
diff --git a/src/Formats/ProtobufSerializer.cpp b/src/Formats/ProtobufSerializer.cpp
index 3539628f98e..962df507f82 100644
--- a/src/Formats/ProtobufSerializer.cpp
+++ b/src/Formats/ProtobufSerializer.cpp
@@ -237,7 +237,7 @@ namespace
             }
             catch (...)
             {
-                cannotConvertValue(str, "String", TypeName<DestType>::get());
+                cannotConvertValue(str, "String", TypeName<DestType>);
             }
         }
 
@@ -254,7 +254,7 @@ namespace
             }
             catch (boost::numeric::bad_numeric_cast &)
             {
-                cannotConvertValue(toString(value), TypeName<SrcType>::get(), TypeName<DestType>::get());
+                cannotConvertValue(toString(value), TypeName<SrcType>, TypeName<DestType>);
             }
             return result;
         }
@@ -429,7 +429,7 @@ namespace
                         else if (value == 1)
                             writeUInt(1);
                         else
-                            cannotConvertValue(toString(value), TypeName<NumberType>::get(), field_descriptor.type_name());
+                            cannotConvertValue(toString(value), TypeName<NumberType>, field_descriptor.type_name());
                     };
 
                     read_function = [this]() -> NumberType
@@ -438,7 +438,7 @@ namespace
                         if (u64 < 2)
                             return static_cast<NumberType>(u64);
                         else
-                            cannotConvertValue(toString(u64), field_descriptor.type_name(), TypeName<NumberType>::get());
+                            cannotConvertValue(toString(u64), field_descriptor.type_name(), TypeName<NumberType>);
                     };
 
                     default_function = [this]() -> NumberType { return static_cast<NumberType>(field_descriptor.default_value_bool()); };
@@ -492,7 +492,7 @@ namespace
         {
             throw Exception(
                 "The field " + quoteString(field_descriptor.full_name()) + " has an incompatible type " + field_descriptor.type_name()
-                    + " for serialization of the data type " + quoteString(TypeName<NumberType>::get()),
+                    + " for serialization of the data type " + quoteString(TypeName<NumberType>),
                 ErrorCodes::DATA_TYPE_INCOMPATIBLE_WITH_PROTOBUF_FIELD);
         }
 
@@ -507,7 +507,7 @@ namespace
         {
             const auto * enum_value_descriptor = field_descriptor.enum_type()->FindValueByNumber(value);
             if (!enum_value_descriptor)
-                cannotConvertValue(toString(value), TypeName<NumberType>::get(), field_descriptor.type_name());
+                cannotConvertValue(toString(value), TypeName<NumberType>, field_descriptor.type_name());
         }
 
     protected:
@@ -1240,7 +1240,7 @@ namespace
                             {
                                 WriteBufferFromOwnString buf;
                                 writeText(decimal, scale, buf);
-                                cannotConvertValue(buf.str(), TypeName<DecimalType>::get(), field_descriptor.type_name());
+                                cannotConvertValue(buf.str(), TypeName<DecimalType>, field_descriptor.type_name());
                             }
                         };
 
@@ -1250,7 +1250,7 @@ namespace
                             if (u64 < 2)
                                 return numberToDecimal(static_cast<UInt64>(u64 != 0));
                             else
-                                cannotConvertValue(toString(u64), field_descriptor.type_name(), TypeName<DecimalType>::get());
+                                cannotConvertValue(toString(u64), field_descriptor.type_name(), TypeName<DecimalType>);
                         };
 
                         default_function = [this]() -> DecimalType
@@ -1289,7 +1289,7 @@ namespace
         {
             throw Exception(
                 "The field " + quoteString(field_descriptor.full_name()) + " has an incompatible type " + field_descriptor.type_name()
-                    + " for serialization of the data type " + quoteString(TypeName<DecimalType>::get()),
+                    + " for serialization of the data type " + quoteString(TypeName<DecimalType>),
                 ErrorCodes::DATA_TYPE_INCOMPATIBLE_WITH_PROTOBUF_FIELD);
         }
 
@@ -1503,18 +1503,42 @@ namespace
     };
 
 
-    /// Serializes a ColumnVector<UInt128> containing UUIDs to a field of type TYPE_STRING or TYPE_BYTES.
-    class ProtobufSerializerUUID : public ProtobufSerializerNumber<UInt128>
+    /// Serializes a ColumnVector<UUID> containing UUIDs to a field of type TYPE_STRING or TYPE_BYTES.
+    class ProtobufSerializerUUID : public ProtobufSerializerSingleValue
     {
     public:
         ProtobufSerializerUUID(
             const google::protobuf::FieldDescriptor & field_descriptor_,
             const ProtobufReaderOrWriter & reader_or_writer_)
-            : ProtobufSerializerNumber<UInt128>(field_descriptor_, reader_or_writer_)
+            : ProtobufSerializerSingleValue(field_descriptor_, reader_or_writer_)
         {
             setFunctions();
         }
 
+        void writeRow(size_t row_num) override
+        {
+            const auto & column_vector = assert_cast<const ColumnVector<UUID> &>(*column);
+            write_function(column_vector.getElement(row_num));
+        }
+
+        void readRow(size_t row_num) override
+        {
+            UUID value = read_function();
+            auto & column_vector = assert_cast<ColumnVector<UUID> &>(column->assumeMutableRef());
+            if (row_num < column_vector.size())
+                column_vector.getElement(row_num) = value;
+            else
+                column_vector.insertValue(value);
+        }
+
+        void insertDefaults(size_t row_num) override
+        {
+            auto & column_vector = assert_cast<ColumnVector<UUID> &>(column->assumeMutableRef());
+            if (row_num < column_vector.size())
+                return;
+            column_vector.insertDefault();
+        }
+
     private:
         void setFunctions()
         {
@@ -1526,19 +1550,19 @@ namespace
                     ErrorCodes::DATA_TYPE_INCOMPATIBLE_WITH_PROTOBUF_FIELD);
             }
 
-            write_function = [this](UInt128 value)
+            write_function = [this](UUID value)
             {
-                uuidToString(static_cast<UUID>(value), text_buffer);
+                uuidToString(value, text_buffer);
                 writeStr(text_buffer);
             };
 
-            read_function = [this]() -> UInt128
+            read_function = [this]() -> UUID
             {
                 readStr(text_buffer);
-                return stringToUUID(text_buffer);
+                return parse<UUID>(text_buffer);
             };
 
-            default_function = [this]() -> UInt128 { return stringToUUID(field_descriptor.default_value_string()); };
+            default_function = [this]() -> UUID { return parse<UUID>(field_descriptor.default_value_string()); };
         }
 
         static void uuidToString(const UUID & uuid, String & str)
@@ -1547,13 +1571,10 @@ namespace
             writeText(uuid, buf);
         }
 
-        static UUID stringToUUID(const String & str)
-        {
-            ReadBufferFromString buf{str};
-            UUID uuid;
-            readUUIDText(uuid, buf);
-            return uuid;
-        }
+        std::function<void(UUID)> write_function;
+        std::function<UUID()> read_function;
+        std::function<UUID()> default_function;
+        String text_buffer;
     };
 
 
diff --git a/src/Functions/CustomWeekTransforms.h b/src/Functions/CustomWeekTransforms.h
index 28da546eb93..98b7c38f266 100644
--- a/src/Functions/CustomWeekTransforms.h
+++ b/src/Functions/CustomWeekTransforms.h
@@ -1,5 +1,5 @@
 #pragma once
-#include <regex>
+
 #include <Columns/ColumnVector.h>
 #include <Columns/ColumnsNumber.h>
 #include <common/types.h>
@@ -13,6 +13,7 @@
 /// The default mode value to use for the WEEK() function
 #define DEFAULT_WEEK_MODE 0
 
+
 namespace DB
 {
 namespace ErrorCodes
diff --git a/src/Functions/DateTimeTransforms.h b/src/Functions/DateTimeTransforms.h
index c299b9c4169..86cac4f4222 100644
--- a/src/Functions/DateTimeTransforms.h
+++ b/src/Functions/DateTimeTransforms.h
@@ -1,9 +1,9 @@
 #pragma once
+
 #include <common/types.h>
 #include <Core/DecimalFunctions.h>
 #include <Common/Exception.h>
 #include <common/DateLUTImpl.h>
-//#include <common/TimeZone.h>
 #include <Columns/ColumnVector.h>
 #include <Columns/ColumnDecimal.h>
 #include <Functions/FunctionHelpers.h>
@@ -12,6 +12,7 @@
 #include <DataTypes/DataTypeDateTime.h>
 #include <DataTypes/DataTypeDateTime64.h>
 
+
 namespace DB
 {
 
@@ -857,7 +858,8 @@ struct Transformer
 template <typename FromDataType, typename ToDataType, typename Transform>
 struct DateTimeTransformImpl
 {
-    static ColumnPtr execute(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t /*input_rows_count*/, const Transform & transform = {})
+    static ColumnPtr execute(
+        const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t /*input_rows_count*/, const Transform & transform = {})
     {
         using Op = Transformer<typename FromDataType::FieldType, typename ToDataType::FieldType, Transform>;
 
diff --git a/src/Functions/FunctionBase64Conversion.h b/src/Functions/FunctionBase64Conversion.h
index d060b86c54b..29aa5913b83 100644
--- a/src/Functions/FunctionBase64Conversion.h
+++ b/src/Functions/FunctionBase64Conversion.h
@@ -146,7 +146,7 @@ public:
                     if (!outlen)
                     {
                         outlen = 0;
-                        dst_pos = savepoint;
+                        dst_pos = savepoint; //-V1048
                         // clean the symbol
                         dst_pos[0] = 0;
                     }
diff --git a/src/Functions/FunctionBinaryArithmetic.h b/src/Functions/FunctionBinaryArithmetic.h
index ef9d05b4b5e..508c598b0ed 100644
--- a/src/Functions/FunctionBinaryArithmetic.h
+++ b/src/Functions/FunctionBinaryArithmetic.h
@@ -5,7 +5,7 @@
 // sanitizer/asan_interface.h
 #include <memory>
 #include <type_traits>
-#include <Common/Arena.h>
+#include <common/wide_integer_to_string.h>
 
 #include <DataTypes/DataTypesNumber.h>
 #include <DataTypes/DataTypesDecimal.h>
@@ -29,6 +29,7 @@
 #include "DivisionUtils.h"
 #include "castTypeToEither.h"
 #include "FunctionFactory.h"
+#include <Common/Arena.h>
 #include <Common/typeid_cast.h>
 #include <Common/assert_cast.h>
 #include <Common/FieldVisitors.h>
@@ -86,6 +87,7 @@ template <> inline constexpr bool IsIntegral<DataTypeInt32> = true;
 template <> inline constexpr bool IsIntegral<DataTypeInt64> = true;
 
 template <typename DataType> constexpr bool IsExtended = false;
+template <> inline constexpr bool IsExtended<DataTypeUInt128> = true;
 template <> inline constexpr bool IsExtended<DataTypeUInt256> = true;
 template <> inline constexpr bool IsExtended<DataTypeInt128> = true;
 template <> inline constexpr bool IsExtended<DataTypeInt256> = true;
@@ -523,6 +525,7 @@ class FunctionBinaryArithmetic : public IFunction
             DataTypeUInt16,
             DataTypeUInt32,
             DataTypeUInt64,
+            DataTypeUInt128,
             DataTypeUInt256,
             DataTypeInt8,
             DataTypeInt16,
@@ -550,6 +553,7 @@ class FunctionBinaryArithmetic : public IFunction
             DataTypeUInt16,
             DataTypeUInt32,
             DataTypeUInt64,
+            DataTypeUInt128,
             DataTypeUInt256,
             DataTypeInt8,
             DataTypeInt16,
@@ -782,7 +786,7 @@ class FunctionBinaryArithmetic : public IFunction
         return function->execute(new_arguments, result_type, input_rows_count);
     }
 
-    template <class T, class ResultDataType, class CC, class C>
+    template <typename T, typename ResultDataType, typename CC, typename C>
     static auto helperGetOrConvert(const CC & col_const, const C & col)
     {
         using ResultType = typename ResultDataType::FieldType;
@@ -790,12 +794,14 @@ class FunctionBinaryArithmetic : public IFunction
 
         if constexpr (IsFloatingPoint<ResultDataType> && IsDecimalNumber<T>)
             return DecimalUtils::convertTo<NativeResultType>(col_const->template getValue<T>(), col.getScale());
+        else if constexpr (IsDecimalNumber<T>)
+            return col_const->template getValue<T>().value;
         else
             return col_const->template getValue<T>();
     }
 
-    template <OpCase op_case, bool left_decimal, bool right_decimal, class OpImpl, class OpImplCheck,
-              class L, class R, class VR, class SA, class SB>
+    template <OpCase op_case, bool left_decimal, bool right_decimal, typename OpImpl, typename OpImplCheck,
+              typename L, typename R, typename VR, typename SA, typename SB>
     void helperInvokeEither(const L& left, const R& right, VR& vec_res, SA scale_a, SB scale_b) const
     {
         if (check_decimal_overflow)
@@ -1323,7 +1329,7 @@ public:
         });
     }
 
-    llvm::Value * compileImpl(llvm::IRBuilderBase & builder, const DataTypes & types, ValuePlaceholders values) const override
+    llvm::Value * compileImpl(llvm::IRBuilderBase & builder, const DataTypes & types, Values values) const override
     {
         assert(2 == types.size() && 2 == values.size());
 
@@ -1340,8 +1346,8 @@ public:
                 {
                     auto & b = static_cast<llvm::IRBuilder<> &>(builder);
                     auto type = std::make_shared<ResultDataType>();
-                    auto * lval = nativeCast(b, types[0], values[0](), type);
-                    auto * rval = nativeCast(b, types[1], values[1](), type);
+                    auto * lval = nativeCast(b, types[0], values[0], type);
+                    auto * rval = nativeCast(b, types[1], values[1], type);
                     result = OpSpec::compile(b, lval, rval, std::is_signed_v<typename ResultDataType::FieldType>);
                     return true;
                 }
diff --git a/src/Functions/FunctionFactory.h b/src/Functions/FunctionFactory.h
index 96238a88420..7a49c79e2bf 100644
--- a/src/Functions/FunctionFactory.h
+++ b/src/Functions/FunctionFactory.h
@@ -51,6 +51,13 @@ public:
     FunctionOverloadResolverImplPtr getImpl(const std::string & name, ContextPtr context) const;
     FunctionOverloadResolverImplPtr tryGetImpl(const std::string & name, ContextPtr context) const;
 
+    /// Register a function by its name.
+    /// No locking, you must register all functions before usage of get.
+    void registerFunction(
+        const std::string & name,
+        Value creator,
+        CaseSensitiveness case_sensitiveness = CaseSensitive);
+
 private:
     using Functions = std::unordered_map<std::string, Value>;
 
@@ -68,13 +75,6 @@ private:
     const Functions & getCaseInsensitiveMap() const override { return case_insensitive_functions; }
 
     String getFactoryName() const override { return "FunctionFactory"; }
-
-    /// Register a function by its name.
-    /// No locking, you must register all functions before usage of get.
-    void registerFunction(
-            const std::string & name,
-            Value creator,
-            CaseSensitiveness case_sensitiveness = CaseSensitive);
 };
 
 }
diff --git a/src/Functions/FunctionIfBase.h b/src/Functions/FunctionIfBase.h
index bdb883ee342..c4a514ae987 100644
--- a/src/Functions/FunctionIfBase.h
+++ b/src/Functions/FunctionIfBase.h
@@ -10,7 +10,6 @@
 namespace DB
 {
 
-template <bool null_is_false>
 class FunctionIfBase : public IFunction
 {
 #if USE_EMBEDDED_COMPILER
@@ -40,46 +39,40 @@ public:
         return true;
     }
 
-    llvm::Value * compileImpl(llvm::IRBuilderBase & builder, const DataTypes & types, ValuePlaceholders values) const override
+    llvm::Value * compileImpl(llvm::IRBuilderBase & builder, const DataTypes & types, Values values) const override
     {
         auto & b = static_cast<llvm::IRBuilder<> &>(builder);
-        auto type = getReturnTypeImpl(types);
-        llvm::Value * null = nullptr;
-        if (!null_is_false && type->isNullable())
-            null = b.CreateInsertValue(llvm::Constant::getNullValue(toNativeType(b, type)), b.getTrue(), {1});
+        auto return_type = getReturnTypeImpl(types);
+
         auto * head = b.GetInsertBlock();
-        auto * join = llvm::BasicBlock::Create(head->getContext(), "", head->getParent());
+        auto * join = llvm::BasicBlock::Create(head->getContext(), "join_block", head->getParent());
+
         std::vector<std::pair<llvm::BasicBlock *, llvm::Value *>> returns;
         for (size_t i = 0; i + 1 < types.size(); i += 2)
         {
-            auto * then = llvm::BasicBlock::Create(head->getContext(), "", head->getParent());
-            auto * next = llvm::BasicBlock::Create(head->getContext(), "", head->getParent());
-            auto * cond = values[i]();
-            if (!null_is_false && types[i]->isNullable())
-            {
-                auto * nonnull = llvm::BasicBlock::Create(head->getContext(), "", head->getParent());
-                returns.emplace_back(b.GetInsertBlock(), null);
-                b.CreateCondBr(b.CreateExtractValue(cond, {1}), join, nonnull);
-                b.SetInsertPoint(nonnull);
-                b.CreateCondBr(nativeBoolCast(b, removeNullable(types[i]), b.CreateExtractValue(cond, {0})), then, next);
-            }
-            else
-            {
-                b.CreateCondBr(nativeBoolCast(b, types[i], cond), then, next);
-            }
+            auto * then = llvm::BasicBlock::Create(head->getContext(), "then_" + std::to_string(i), head->getParent());
+            auto * next = llvm::BasicBlock::Create(head->getContext(), "next_" + std::to_string(i), head->getParent());
+            auto * cond = values[i];
+
+            b.CreateCondBr(nativeBoolCast(b, types[i], cond), then, next);
             b.SetInsertPoint(then);
-            auto * value = nativeCast(b, types[i + 1], values[i + 1](), type);
+
+            auto * value = nativeCast(b, types[i + 1], values[i + 1], return_type);
             returns.emplace_back(b.GetInsertBlock(), value);
             b.CreateBr(join);
             b.SetInsertPoint(next);
         }
-        auto * value = nativeCast(b, types.back(), values.back()(), type);
-        returns.emplace_back(b.GetInsertBlock(), value);
+
+        auto * else_value = nativeCast(b, types.back(), values.back(), return_type);
+        returns.emplace_back(b.GetInsertBlock(), else_value);
         b.CreateBr(join);
+
         b.SetInsertPoint(join);
-        auto * phi = b.CreatePHI(toNativeType(b, type), returns.size());
-        for (const auto & r : returns)
-            phi->addIncoming(r.second, r.first);
+
+        auto * phi = b.CreatePHI(toNativeType(b, return_type), returns.size());
+        for (const auto & [block, value] : returns)
+            phi->addIncoming(value, block);
+
         return phi;
     }
 #endif
diff --git a/src/Functions/FunctionMathBinaryFloat64.h b/src/Functions/FunctionMathBinaryFloat64.h
index 00f6909f65c..7b54d59d852 100644
--- a/src/Functions/FunctionMathBinaryFloat64.h
+++ b/src/Functions/FunctionMathBinaryFloat64.h
@@ -76,18 +76,8 @@ private:
             if (rows_remaining != 0)
             {
                 RightType right_src_remaining[Impl::rows_per_iteration];
-                if constexpr (!is_big_int_v<RightType> && !std::is_same_v<RightType, Decimal256>)
-                {
-                    memcpy(right_src_remaining, &right_src_data[rows_size], rows_remaining * sizeof(RightType));
-                    memset(right_src_remaining + rows_remaining, 0, (Impl::rows_per_iteration - rows_remaining) * sizeof(RightType));
-                }
-                else
-                {
-                    for (size_t i = 0; i < rows_remaining; i++)
-                        right_src_remaining[i] = right_src_data[rows_size + i];
-                    for (size_t i = rows_remaining; i < Impl::rows_per_iteration; i++)
-                        right_src_remaining[i] = 0;
-                }
+                memcpy(right_src_remaining, &right_src_data[rows_size], rows_remaining * sizeof(RightType));
+                memset(right_src_remaining + rows_remaining, 0, (Impl::rows_per_iteration - rows_remaining) * sizeof(RightType));
                 Float64 dst_remaining[Impl::rows_per_iteration];
 
                 Impl::execute(left_src_data, right_src_remaining, dst_remaining);
@@ -123,32 +113,13 @@ private:
             if (rows_remaining != 0)
             {
                 LeftType left_src_remaining[Impl::rows_per_iteration];
-                if constexpr (!is_big_int_v<LeftType> && !std::is_same_v<LeftType, Decimal256>)
-                {
-                    memcpy(left_src_remaining, &left_src_data[rows_size], rows_remaining * sizeof(LeftType));
-                    memset(left_src_remaining + rows_remaining, 0, (Impl::rows_per_iteration - rows_remaining) * sizeof(LeftType));
-                }
-                else
-                {
-                    for (size_t i = 0; i < rows_remaining; i++)
-                        left_src_remaining[i] = left_src_data[rows_size + i];
-                    for (size_t i = rows_remaining; i < Impl::rows_per_iteration; i++)
-                        left_src_remaining[i] = 0;
-                }
+                memcpy(left_src_remaining, &left_src_data[rows_size], rows_remaining * sizeof(LeftType));
+                memset(left_src_remaining + rows_remaining, 0, (Impl::rows_per_iteration - rows_remaining) * sizeof(LeftType));
 
                 RightType right_src_remaining[Impl::rows_per_iteration];
-                if constexpr (!is_big_int_v<RightType> && !std::is_same_v<RightType, Decimal256>)
-                {
-                    memcpy(right_src_remaining, &right_src_data[rows_size], rows_remaining * sizeof(RightType));
-                    memset(right_src_remaining + rows_remaining, 0, (Impl::rows_per_iteration - rows_remaining) * sizeof(RightType));
-                }
-                else
-                {
-                    for (size_t i = 0; i < rows_remaining; i++)
-                        right_src_remaining[i] = right_src_data[rows_size + i];
-                    for (size_t i = rows_remaining; i < Impl::rows_per_iteration; i++)
-                        right_src_remaining[i] = 0;
-                }
+                memcpy(right_src_remaining, &right_src_data[rows_size], rows_remaining * sizeof(RightType));
+                memset(right_src_remaining + rows_remaining, 0, (Impl::rows_per_iteration - rows_remaining) * sizeof(RightType));
+
                 Float64 dst_remaining[Impl::rows_per_iteration];
 
                 Impl::execute(left_src_remaining, right_src_remaining, dst_remaining);
@@ -178,18 +149,8 @@ private:
             if (rows_remaining != 0)
             {
                 LeftType left_src_remaining[Impl::rows_per_iteration];
-                if constexpr (!is_big_int_v<LeftType> && !std::is_same_v<LeftType, Decimal256>)
-                {
-                    memcpy(left_src_remaining, &left_src_data[rows_size], rows_remaining * sizeof(LeftType));
-                    memset(left_src_remaining + rows_remaining, 0, (Impl::rows_per_iteration - rows_remaining) * sizeof(LeftType));
-                }
-                else
-                {
-                    for (size_t i = 0; i < rows_remaining; i++)
-                        left_src_remaining[i] = left_src_data[rows_size + i];
-                    for (size_t i = rows_remaining; i < Impl::rows_per_iteration; i++)
-                        left_src_remaining[i] = 0;
-                }
+                memcpy(left_src_remaining, &left_src_data[rows_size], rows_remaining * sizeof(LeftType));
+                memset(left_src_remaining + rows_remaining, 0, (Impl::rows_per_iteration - rows_remaining) * sizeof(LeftType));
 
                 Float64 dst_remaining[Impl::rows_per_iteration];
 
diff --git a/src/Functions/FunctionMathUnary.h b/src/Functions/FunctionMathUnary.h
index e24d19e5a9b..78c6cf3ce0b 100644
--- a/src/Functions/FunctionMathUnary.h
+++ b/src/Functions/FunctionMathUnary.h
@@ -87,18 +87,8 @@ private:
             if (rows_remaining != 0)
             {
                 T src_remaining[Impl::rows_per_iteration];
-                if constexpr (is_big_int_v<T> || std::is_same_v<T, Decimal256>)
-                {
-                    for (size_t i = 0; i < rows_remaining; i++)
-                        src_remaining[i] = src_data[rows_size + i];
-                    for (size_t i = rows_remaining; i < Impl::rows_per_iteration; i++)
-                        src_remaining[i] = 0;
-                }
-                else
-                {
-                    memcpy(src_remaining, &src_data[rows_size], rows_remaining * sizeof(T));
-                    memset(src_remaining + rows_remaining, 0, (Impl::rows_per_iteration - rows_remaining) * sizeof(T));
-                }
+                memcpy(src_remaining, &src_data[rows_size], rows_remaining * sizeof(T));
+                memset(src_remaining + rows_remaining, 0, (Impl::rows_per_iteration - rows_remaining) * sizeof(T));
                 ReturnType dst_remaining[Impl::rows_per_iteration];
 
                 Impl::execute(src_remaining, dst_remaining);
diff --git a/src/Functions/FunctionUnaryArithmetic.h b/src/Functions/FunctionUnaryArithmetic.h
index 9145c4a2ec5..0b616fd8ab6 100644
--- a/src/Functions/FunctionUnaryArithmetic.h
+++ b/src/Functions/FunctionUnaryArithmetic.h
@@ -91,6 +91,7 @@ class FunctionUnaryArithmetic : public IFunction
             DataTypeUInt16,
             DataTypeUInt32,
             DataTypeUInt64,
+            DataTypeUInt128,
             DataTypeUInt256,
             DataTypeInt8,
             DataTypeInt16,
@@ -243,7 +244,7 @@ public:
         });
     }
 
-    llvm::Value * compileImpl(llvm::IRBuilderBase & builder, const DataTypes & types, ValuePlaceholders values) const override
+    llvm::Value * compileImpl(llvm::IRBuilderBase & builder, const DataTypes & types, Values values) const override
     {
         assert(1 == types.size() && 1 == values.size());
 
@@ -260,7 +261,7 @@ public:
                 if constexpr (!std::is_same_v<T1, InvalidType> && !IsDataTypeDecimal<DataType> && Op<T0>::compilable)
                 {
                     auto & b = static_cast<llvm::IRBuilder<> &>(builder);
-                    auto * v = nativeCast(b, types[0], values[0](), std::make_shared<DataTypeNumber<T1>>());
+                    auto * v = nativeCast(b, types[0], values[0], std::make_shared<DataTypeNumber<T1>>());
                     result = Op<T0>::compile(b, v, is_signed_v<T1>);
                     return true;
                 }
diff --git a/src/Functions/FunctionUnixTimestamp64.h b/src/Functions/FunctionUnixTimestamp64.h
index 18f9c7a8b02..d8d8a1b7a06 100644
--- a/src/Functions/FunctionUnixTimestamp64.h
+++ b/src/Functions/FunctionUnixTimestamp64.h
@@ -5,145 +5,131 @@
 #include <Functions/FunctionHelpers.h>
 #include <DataTypes/DataTypeDateTime64.h>
 #include <DataTypes/DataTypesNumber.h>
+#include <Columns/ColumnsNumber.h>
 
 #include <common/arithmeticOverflow.h>
 
+
 namespace DB
 {
 
 namespace ErrorCodes
 {
+    extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH;
     extern const int ILLEGAL_TYPE_OF_ARGUMENT;
     extern const int DECIMAL_OVERFLOW;
 }
 
-/** Casts DateTim64 to or from Int64 representation narrowed down (or scaled up) to any scale value defined in Impl.
- */
-template <typename Impl>
-class FunctionUnixTimestamp64 : public IFunction
+/// Cast DateTime64 to Int64 representation narrowed down (or scaled up) to any scale value defined in Impl.
+class FunctionToUnixTimestamp64 : public IFunction
 {
+private:
+    size_t target_scale;
+    const char * name;
 public:
-    static constexpr auto name = Impl::name;
-    static constexpr auto target_scale = Impl::target_scale;
-
-    using SourceDataType = typename Impl::SourceDataType;
-    using ResultDataType = typename Impl::ResultDataType;
-
-    static constexpr bool is_result_datetime64 = std::is_same_v<ResultDataType, DataTypeDateTime64>;
-
-    static_assert(std::is_same_v<SourceDataType, DataTypeDateTime64> || std::is_same_v<ResultDataType, DataTypeDateTime64>);
-
-    static auto create(ContextPtr)
+    FunctionToUnixTimestamp64(size_t target_scale_, const char * name_)
+        : target_scale(target_scale_), name(name_)
     {
-        return std::make_shared<FunctionUnixTimestamp64<Impl>>();
     }
 
     String getName() const override { return name; }
-    size_t getNumberOfArguments() const override { return is_result_datetime64 ? 2 : 1; }
-    bool isVariadic() const override { return is_result_datetime64; }
+    size_t getNumberOfArguments() const override { return 1; }
+    bool isVariadic() const override { return false; }
     bool useDefaultImplementationForConstants() const override { return true; }
 
     DataTypePtr getReturnTypeImpl(const ColumnsWithTypeAndName & arguments) const override
     {
-        if constexpr (is_result_datetime64)
-        {
-            validateFunctionArgumentTypes(*this, arguments,
-                    FunctionArgumentDescriptors{{"value", isDataType<SourceDataType>, nullptr, std::string(SourceDataType::family_name).c_str()}},
-                    // optional
-                    FunctionArgumentDescriptors{
-    //                    {"precision", isDataType<DataTypeUInt8>, isColumnConst, ("Precision of the result, default is " + std::to_string(target_scale)).c_str()},
-                        {"timezone", isStringOrFixedString, isColumnConst, "Timezone of the result"},
-                    });
-            const auto timezone = extractTimeZoneNameFromFunctionArguments(arguments, 1, 0);
-            return std::make_shared<DataTypeDateTime64>(target_scale, timezone);
-        }
-        else
-        {
-            validateFunctionArgumentTypes(*this, arguments,
-                    FunctionArgumentDescriptors{{"value", isDataType<SourceDataType>, nullptr, std::string(SourceDataType::family_name).c_str()}});
-            return std::make_shared<DataTypeInt64>();
-        }
+        if (!isDateTime64(arguments[0].type))
+            throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "The only argument for function {} must be DateTime64", name);
+
+        return std::make_shared<DataTypeInt64>();
     }
 
-    ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count) const override
+    ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t input_rows_count) const override
     {
-        using SourceColumnType = typename SourceDataType::ColumnType;
-        using ResultColumnType = typename ResultDataType::ColumnType;
-
         const auto & src = arguments[0];
         const auto & col = *src.column;
 
-        const SourceColumnType * source_col_typed = checkAndGetColumn<SourceColumnType>(col);
-        if (!source_col_typed && !(source_col_typed = checkAndGetColumnConstData<SourceColumnType>(&col)))
-            throw Exception("Invalid column type" + col.getName() + " expected "
-                    + std::string(SourceDataType::family_name),
-                    ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+        auto res_column = ColumnInt64::create(input_rows_count);
+        auto & result_data = res_column->getData();
 
-        auto res_column = result_type->createColumn();
+        const auto & source_data = typeid_cast<const ColumnDecimal<DateTime64> &>(col).getData();
 
-        if (input_rows_count == 0)
-            return res_column;
-
-        auto & result_data = assert_cast<ResultColumnType &>(res_column->assumeMutableRef()).getData();
-        result_data.reserve(source_col_typed->size());
-        const auto & source_data = source_col_typed->getData();
-
-        const auto scale_diff = getScaleDiff(*checkAndGetDataType<SourceDataType>(src.type.get()), *checkAndGetDataType<ResultDataType>(result_type.get()));
+        Int32 scale_diff = typeid_cast<const DataTypeDateTime64 &>(*src.type).getScale() - target_scale;
         if (scale_diff == 0)
         {
-            static_assert(sizeof(typename SourceColumnType::Container::value_type) == sizeof(typename ResultColumnType::Container::value_type));
-            // no conversion necessary
-            result_data.push_back_raw_many(source_data.size(), source_data.data());
+            for (size_t i = 0; i < input_rows_count; ++i)
+                result_data[i] = source_data[i];
         }
         else if (scale_diff < 0)
         {
-            const Int64 scale_multiplier = DecimalUtils::scaleMultiplier<Int64>(std::abs(scale_diff));
-            for (const auto & v : source_data)
+            const Int64 scale_multiplier = DecimalUtils::scaleMultiplier<Int64>(-scale_diff);
+            for (size_t i = 0; i < input_rows_count; ++i)
             {
-                Int64 result_value = toDestValue(v);
+                Int64 result_value = source_data[i];
                 if (common::mulOverflow(result_value, scale_multiplier, result_value))
                     throw Exception("Decimal overflow in " + getName(), ErrorCodes::DECIMAL_OVERFLOW);
 
-                result_data.push_back(result_value);
+                result_data[i] = result_value;
             }
         }
         else
         {
             const Int64 scale_multiplier = DecimalUtils::scaleMultiplier<Int64>(scale_diff);
-            for (const auto & v : source_data)
-                result_data.push_back(static_cast<Int64>(toDestValue(v) / scale_multiplier));
+            for (size_t i = 0; i < input_rows_count; ++i)
+                result_data[i] = Int64(source_data[i]) / scale_multiplier;
         }
 
         return res_column;
     }
+};
 
+
+class FunctionFromUnixTimestamp64 : public IFunction
+{
 private:
-    static Int64 getScaleDiff(const SourceDataType & src, const ResultDataType & dst)
+    size_t target_scale;
+    const char * name;
+public:
+    FunctionFromUnixTimestamp64(size_t target_scale_, const char * name_)
+        : target_scale(target_scale_), name(name_)
     {
-        Int64 src_scale = target_scale;
-        if constexpr (std::is_same_v<SourceDataType, DataTypeDateTime64>)
-        {
-            src_scale = src.getScale();
-        }
-
-        Int64 dst_scale = target_scale;
-        if constexpr (std::is_same_v<ResultDataType, DataTypeDateTime64>)
-        {
-            dst_scale = dst.getScale();
-        }
-
-        return src_scale - dst_scale;
     }
 
-    static auto toDestValue(const DateTime64 & v)
+    String getName() const override { return name; }
+    size_t getNumberOfArguments() const override { return 0; }
+    bool isVariadic() const override { return true; }
+    bool useDefaultImplementationForConstants() const override { return true; }
+
+    DataTypePtr getReturnTypeImpl(const ColumnsWithTypeAndName & arguments) const override
     {
-        return Int64{v.value};
+        if (arguments.size() < 1 || arguments.size() > 2)
+            throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH, "Function {} takes one or two arguments", name);
+
+        if (!typeid_cast<const DataTypeInt64 *>(arguments[0].type.get()))
+            throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "The first argument for function {} must be Int64", name);
+
+        std::string timezone;
+        if (arguments.size() == 2)
+            timezone = extractTimeZoneNameFromFunctionArguments(arguments, 1, 0);
+
+        return std::make_shared<DataTypeDateTime64>(target_scale, timezone);
     }
 
-    template <typename T>
-    static auto toDestValue(const T & v)
+    ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t input_rows_count) const override
     {
-        return Int64{v};
+        const auto & src = arguments[0];
+        const auto & col = *src.column;
+
+        auto res_column = ColumnDecimal<DateTime64>::create(input_rows_count, target_scale);
+        auto & result_data = res_column->getData();
+
+        const auto & source_data = typeid_cast<const ColumnInt64 &>(col).getData();
+
+        for (size_t i = 0; i < input_rows_count; ++i)
+            result_data[i] = source_data[i];
+
+        return res_column;
     }
 };
 
diff --git a/src/Functions/FunctionsComparison.h b/src/Functions/FunctionsComparison.h
index 025b7c67b21..f724915b3bc 100644
--- a/src/Functions/FunctionsComparison.h
+++ b/src/Functions/FunctionsComparison.h
@@ -1240,23 +1240,27 @@ public:
         if (2 != types.size())
             return false;
 
-        auto isBigInteger = &typeIsEither<DataTypeInt64, DataTypeUInt64, DataTypeUUID>;
-        auto isFloatingPoint = &typeIsEither<DataTypeFloat32, DataTypeFloat64>;
-        if ((isBigInteger(*types[0]) && isFloatingPoint(*types[1]))
-            || (isBigInteger(*types[1]) && isFloatingPoint(*types[0]))
-            || (WhichDataType(types[0]).isDate() && WhichDataType(types[1]).isDateTime())
-            || (WhichDataType(types[1]).isDate() && WhichDataType(types[0]).isDateTime()))
+        WhichDataType data_type_lhs(types[0]);
+        WhichDataType data_type_rhs(types[1]);
+
+        auto is_big_integer = [](WhichDataType type) { return type.isUInt64() || type.isInt64(); };
+
+        if ((is_big_integer(data_type_lhs) && data_type_rhs.isFloat())
+            || (is_big_integer(data_type_rhs) && data_type_lhs.isFloat())
+            || (data_type_lhs.isDate() && data_type_rhs.isDateTime())
+            || (data_type_rhs.isDate() && data_type_lhs.isDateTime()))
             return false; /// TODO: implement (double, int_N where N > double's mantissa width)
+
         return isCompilableType(types[0]) && isCompilableType(types[1]);
     }
 
-    llvm::Value * compileImpl(llvm::IRBuilderBase & builder, const DataTypes & types, ValuePlaceholders values) const override
+    llvm::Value * compileImpl(llvm::IRBuilderBase & builder, const DataTypes & types, Values values) const override
     {
         assert(2 == types.size() && 2 == values.size());
 
         auto & b = static_cast<llvm::IRBuilder<> &>(builder);
-        auto * x = values[0]();
-        auto * y = values[1]();
+        auto * x = values[0];
+        auto * y = values[1];
         if (!types[0]->equals(*types[1]))
         {
             llvm::Type * common;
diff --git a/src/Functions/FunctionsConversion.cpp b/src/Functions/FunctionsConversion.cpp
index 3110a204deb..b4cf875adfb 100644
--- a/src/Functions/FunctionsConversion.cpp
+++ b/src/Functions/FunctionsConversion.cpp
@@ -13,6 +13,7 @@ void registerFunctionsConversion(FunctionFactory & factory)
     factory.registerFunction<FunctionToUInt16>();
     factory.registerFunction<FunctionToUInt32>();
     factory.registerFunction<FunctionToUInt64>();
+    factory.registerFunction<FunctionToUInt128>();
     factory.registerFunction<FunctionToUInt256>();
     factory.registerFunction<FunctionToInt8>();
     factory.registerFunction<FunctionToInt16>();
@@ -50,6 +51,7 @@ void registerFunctionsConversion(FunctionFactory & factory)
     factory.registerFunction<FunctionToUInt16OrZero>();
     factory.registerFunction<FunctionToUInt32OrZero>();
     factory.registerFunction<FunctionToUInt64OrZero>();
+    factory.registerFunction<FunctionToUInt128OrZero>();
     factory.registerFunction<FunctionToUInt256OrZero>();
     factory.registerFunction<FunctionToInt8OrZero>();
     factory.registerFunction<FunctionToInt16OrZero>();
@@ -74,6 +76,7 @@ void registerFunctionsConversion(FunctionFactory & factory)
     factory.registerFunction<FunctionToUInt16OrNull>();
     factory.registerFunction<FunctionToUInt32OrNull>();
     factory.registerFunction<FunctionToUInt64OrNull>();
+    factory.registerFunction<FunctionToUInt128OrNull>();
     factory.registerFunction<FunctionToUInt256OrNull>();
     factory.registerFunction<FunctionToInt8OrNull>();
     factory.registerFunction<FunctionToInt16OrNull>();
diff --git a/src/Functions/FunctionsConversion.h b/src/Functions/FunctionsConversion.h
index 1cd308c774d..8830107b170 100644
--- a/src/Functions/FunctionsConversion.h
+++ b/src/Functions/FunctionsConversion.h
@@ -36,7 +36,6 @@
 #include <Columns/ColumnTuple.h>
 #include <Columns/ColumnMap.h>
 #include <Columns/ColumnsCommon.h>
-#include <Common/FieldVisitors.h>
 #include <Common/assert_cast.h>
 #include <Common/quoteString.h>
 #include <Core/AccurateComparison.h>
@@ -125,7 +124,7 @@ struct ConvertImpl
 
     template <typename Additions = void *>
     static ColumnPtr NO_SANITIZE_UNDEFINED execute(
-        const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type [[maybe_unused]], size_t /*input_rows_count*/,
+        const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type [[maybe_unused]], size_t input_rows_count,
         Additions additions [[maybe_unused]] = Additions())
     {
         const ColumnWithTypeAndName & named_from = arguments[0];
@@ -173,31 +172,19 @@ struct ConvertImpl
 
             const auto & vec_from = col_from->getData();
             auto & vec_to = col_to->getData();
-            size_t size = vec_from.size();
-            vec_to.resize(size);
+            vec_to.resize(input_rows_count);
 
             ColumnUInt8::MutablePtr col_null_map_to;
             ColumnUInt8::Container * vec_null_map_to [[maybe_unused]] = nullptr;
             if constexpr (std::is_same_v<Additions, AccurateOrNullConvertStrategyAdditions>)
             {
-                col_null_map_to = ColumnUInt8::create(size, false);
+                col_null_map_to = ColumnUInt8::create(input_rows_count, false);
                 vec_null_map_to = &col_null_map_to->getData();
             }
 
-            for (size_t i = 0; i < size; ++i)
+            for (size_t i = 0; i < input_rows_count; ++i)
             {
-                if constexpr ((is_big_int_v<FromFieldType> || is_big_int_v<ToFieldType>) &&
-                    (std::is_same_v<FromFieldType, UInt128> || std::is_same_v<ToFieldType, UInt128>))
-                {
-                    if constexpr (std::is_same_v<Additions, AccurateOrNullConvertStrategyAdditions>)
-                    {
-                        vec_to[i] = 0;
-                        (*vec_null_map_to)[i] = true;
-                    }
-                    else
-                        throw Exception("Unexpected UInt128 to big int conversion", ErrorCodes::NOT_IMPLEMENTED);
-                }
-                else if constexpr (std::is_same_v<FromDataType, DataTypeUUID> != std::is_same_v<ToDataType, DataTypeUUID>)
+                if constexpr (std::is_same_v<FromDataType, DataTypeUUID> != std::is_same_v<ToDataType, DataTypeUUID>)
                 {
                     throw Exception("Conversion between numeric types and UUID is not supported", ErrorCodes::NOT_IMPLEMENTED);
                 }
@@ -784,7 +771,7 @@ inline void parseImpl<DataTypeUUID>(DataTypeUUID::FieldType & x, ReadBuffer & rb
 {
     UUID tmp;
     readUUIDText(tmp, rb);
-    x = tmp;
+    x = tmp.toUnderType();
 }
 
 
@@ -824,7 +811,7 @@ inline bool tryParseImpl<DataTypeUUID>(DataTypeUUID::FieldType & x, ReadBuffer &
     if (!tryReadUUIDText(tmp, rb))
         return false;
 
-    x = tmp;
+    x = tmp.toUnderType();
     return true;
 }
 
@@ -1454,7 +1441,7 @@ private:
     ColumnPtr executeInternal(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count) const
     {
         if (arguments.empty())
-            throw Exception{"Function " + getName() + " expects at least 1 arguments",
+            throw Exception{"Function " + getName() + " expects at least 1 argument",
                ErrorCodes::TOO_FEW_ARGUMENTS_FOR_FUNCTION};
 
         const IDataType * from_type = arguments[0].type.get();
@@ -1471,7 +1458,7 @@ private:
             {
                 if constexpr (std::is_same_v<RightDataType, DataTypeDateTime64>)
                 {
-                    // account for optional timezone argument
+                    /// Account for optional timezone argument.
                     if (arguments.size() != 2 && arguments.size() != 3)
                         throw Exception{"Function " + getName() + " expects 2 or 3 arguments for DataTypeDateTime64.",
                             ErrorCodes::TOO_FEW_ARGUMENTS_FOR_FUNCTION};
@@ -1958,6 +1945,7 @@ struct NameToUInt8 { static constexpr auto name = "toUInt8"; };
 struct NameToUInt16 { static constexpr auto name = "toUInt16"; };
 struct NameToUInt32 { static constexpr auto name = "toUInt32"; };
 struct NameToUInt64 { static constexpr auto name = "toUInt64"; };
+struct NameToUInt128 { static constexpr auto name = "toUInt128"; };
 struct NameToUInt256 { static constexpr auto name = "toUInt256"; };
 struct NameToInt8 { static constexpr auto name = "toInt8"; };
 struct NameToInt16 { static constexpr auto name = "toInt16"; };
@@ -1973,6 +1961,7 @@ using FunctionToUInt8 = FunctionConvert<DataTypeUInt8, NameToUInt8, ToNumberMono
 using FunctionToUInt16 = FunctionConvert<DataTypeUInt16, NameToUInt16, ToNumberMonotonicity<UInt16>>;
 using FunctionToUInt32 = FunctionConvert<DataTypeUInt32, NameToUInt32, ToNumberMonotonicity<UInt32>>;
 using FunctionToUInt64 = FunctionConvert<DataTypeUInt64, NameToUInt64, ToNumberMonotonicity<UInt64>>;
+using FunctionToUInt128 = FunctionConvert<DataTypeUInt128, NameToUInt128, ToNumberMonotonicity<UInt128>>;
 using FunctionToUInt256 = FunctionConvert<DataTypeUInt256, NameToUInt256, ToNumberMonotonicity<UInt256>>;
 using FunctionToInt8 = FunctionConvert<DataTypeInt8, NameToInt8, ToNumberMonotonicity<Int8>>;
 using FunctionToInt16 = FunctionConvert<DataTypeInt16, NameToInt16, ToNumberMonotonicity<Int16>>;
@@ -2001,6 +1990,7 @@ template <> struct FunctionTo<DataTypeUInt8> { using Type = FunctionToUInt8; };
 template <> struct FunctionTo<DataTypeUInt16> { using Type = FunctionToUInt16; };
 template <> struct FunctionTo<DataTypeUInt32> { using Type = FunctionToUInt32; };
 template <> struct FunctionTo<DataTypeUInt64> { using Type = FunctionToUInt64; };
+template <> struct FunctionTo<DataTypeUInt128> { using Type = FunctionToUInt128; };
 template <> struct FunctionTo<DataTypeUInt256> { using Type = FunctionToUInt256; };
 template <> struct FunctionTo<DataTypeInt8> { using Type = FunctionToInt8; };
 template <> struct FunctionTo<DataTypeInt16> { using Type = FunctionToInt16; };
@@ -2030,6 +2020,7 @@ struct NameToUInt8OrZero { static constexpr auto name = "toUInt8OrZero"; };
 struct NameToUInt16OrZero { static constexpr auto name = "toUInt16OrZero"; };
 struct NameToUInt32OrZero { static constexpr auto name = "toUInt32OrZero"; };
 struct NameToUInt64OrZero { static constexpr auto name = "toUInt64OrZero"; };
+struct NameToUInt128OrZero { static constexpr auto name = "toUInt128OrZero"; };
 struct NameToUInt256OrZero { static constexpr auto name = "toUInt256OrZero"; };
 struct NameToInt8OrZero { static constexpr auto name = "toInt8OrZero"; };
 struct NameToInt16OrZero { static constexpr auto name = "toInt16OrZero"; };
@@ -2052,6 +2043,7 @@ using FunctionToUInt8OrZero = FunctionConvertFromString<DataTypeUInt8, NameToUIn
 using FunctionToUInt16OrZero = FunctionConvertFromString<DataTypeUInt16, NameToUInt16OrZero, ConvertFromStringExceptionMode::Zero>;
 using FunctionToUInt32OrZero = FunctionConvertFromString<DataTypeUInt32, NameToUInt32OrZero, ConvertFromStringExceptionMode::Zero>;
 using FunctionToUInt64OrZero = FunctionConvertFromString<DataTypeUInt64, NameToUInt64OrZero, ConvertFromStringExceptionMode::Zero>;
+using FunctionToUInt128OrZero = FunctionConvertFromString<DataTypeUInt128, NameToUInt128OrZero, ConvertFromStringExceptionMode::Zero>;
 using FunctionToUInt256OrZero = FunctionConvertFromString<DataTypeUInt256, NameToUInt256OrZero, ConvertFromStringExceptionMode::Zero>;
 using FunctionToInt8OrZero = FunctionConvertFromString<DataTypeInt8, NameToInt8OrZero, ConvertFromStringExceptionMode::Zero>;
 using FunctionToInt16OrZero = FunctionConvertFromString<DataTypeInt16, NameToInt16OrZero, ConvertFromStringExceptionMode::Zero>;
@@ -2074,6 +2066,7 @@ struct NameToUInt8OrNull { static constexpr auto name = "toUInt8OrNull"; };
 struct NameToUInt16OrNull { static constexpr auto name = "toUInt16OrNull"; };
 struct NameToUInt32OrNull { static constexpr auto name = "toUInt32OrNull"; };
 struct NameToUInt64OrNull { static constexpr auto name = "toUInt64OrNull"; };
+struct NameToUInt128OrNull { static constexpr auto name = "toUInt128OrNull"; };
 struct NameToUInt256OrNull { static constexpr auto name = "toUInt256OrNull"; };
 struct NameToInt8OrNull { static constexpr auto name = "toInt8OrNull"; };
 struct NameToInt16OrNull { static constexpr auto name = "toInt16OrNull"; };
@@ -2096,6 +2089,7 @@ using FunctionToUInt8OrNull = FunctionConvertFromString<DataTypeUInt8, NameToUIn
 using FunctionToUInt16OrNull = FunctionConvertFromString<DataTypeUInt16, NameToUInt16OrNull, ConvertFromStringExceptionMode::Null>;
 using FunctionToUInt32OrNull = FunctionConvertFromString<DataTypeUInt32, NameToUInt32OrNull, ConvertFromStringExceptionMode::Null>;
 using FunctionToUInt64OrNull = FunctionConvertFromString<DataTypeUInt64, NameToUInt64OrNull, ConvertFromStringExceptionMode::Null>;
+using FunctionToUInt128OrNull = FunctionConvertFromString<DataTypeUInt128, NameToUInt128OrNull, ConvertFromStringExceptionMode::Null>;
 using FunctionToUInt256OrNull = FunctionConvertFromString<DataTypeUInt256, NameToUInt256OrNull, ConvertFromStringExceptionMode::Null>;
 using FunctionToInt8OrNull = FunctionConvertFromString<DataTypeInt8, NameToInt8OrNull, ConvertFromStringExceptionMode::Null>;
 using FunctionToInt16OrNull = FunctionConvertFromString<DataTypeInt16, NameToInt16OrNull, ConvertFromStringExceptionMode::Null>;
@@ -3043,6 +3037,7 @@ private:
                 std::is_same_v<ToDataType, DataTypeUInt16> ||
                 std::is_same_v<ToDataType, DataTypeUInt32> ||
                 std::is_same_v<ToDataType, DataTypeUInt64> ||
+                std::is_same_v<ToDataType, DataTypeUInt128> ||
                 std::is_same_v<ToDataType, DataTypeUInt256> ||
                 std::is_same_v<ToDataType, DataTypeInt8> ||
                 std::is_same_v<ToDataType, DataTypeInt16> ||
@@ -3122,43 +3117,45 @@ public:
 
     static MonotonicityForRange getMonotonicityInformation(const DataTypePtr & from_type, const IDataType * to_type)
     {
-        if (const auto *const type = checkAndGetDataType<DataTypeUInt8>(to_type))
+        if (const auto * type = checkAndGetDataType<DataTypeUInt8>(to_type))
             return monotonicityForType(type);
-        if (const auto *const type = checkAndGetDataType<DataTypeUInt16>(to_type))
+        if (const auto * type = checkAndGetDataType<DataTypeUInt16>(to_type))
             return monotonicityForType(type);
-        if (const auto *const type = checkAndGetDataType<DataTypeUInt32>(to_type))
+        if (const auto * type = checkAndGetDataType<DataTypeUInt32>(to_type))
             return monotonicityForType(type);
-        if (const auto *const type = checkAndGetDataType<DataTypeUInt64>(to_type))
+        if (const auto * type = checkAndGetDataType<DataTypeUInt64>(to_type))
             return monotonicityForType(type);
-        if (const auto *const type = checkAndGetDataType<DataTypeUInt256>(to_type))
+        if (const auto * type = checkAndGetDataType<DataTypeUInt128>(to_type))
             return monotonicityForType(type);
-        if (const auto *const type = checkAndGetDataType<DataTypeInt8>(to_type))
+        if (const auto * type = checkAndGetDataType<DataTypeUInt256>(to_type))
             return monotonicityForType(type);
-        if (const auto *const type = checkAndGetDataType<DataTypeInt16>(to_type))
+        if (const auto * type = checkAndGetDataType<DataTypeInt8>(to_type))
             return monotonicityForType(type);
-        if (const auto *const type = checkAndGetDataType<DataTypeInt32>(to_type))
+        if (const auto * type = checkAndGetDataType<DataTypeInt16>(to_type))
             return monotonicityForType(type);
-        if (const auto *const type = checkAndGetDataType<DataTypeInt64>(to_type))
+        if (const auto * type = checkAndGetDataType<DataTypeInt32>(to_type))
             return monotonicityForType(type);
-        if (const auto *const type = checkAndGetDataType<DataTypeInt128>(to_type))
+        if (const auto * type = checkAndGetDataType<DataTypeInt64>(to_type))
             return monotonicityForType(type);
-        if (const auto *const type = checkAndGetDataType<DataTypeInt256>(to_type))
+        if (const auto * type = checkAndGetDataType<DataTypeInt128>(to_type))
             return monotonicityForType(type);
-        if (const auto *const type = checkAndGetDataType<DataTypeFloat32>(to_type))
+        if (const auto * type = checkAndGetDataType<DataTypeInt256>(to_type))
             return monotonicityForType(type);
-        if (const auto *const type = checkAndGetDataType<DataTypeFloat64>(to_type))
+        if (const auto * type = checkAndGetDataType<DataTypeFloat32>(to_type))
             return monotonicityForType(type);
-        if (const auto *const type = checkAndGetDataType<DataTypeDate>(to_type))
+        if (const auto * type = checkAndGetDataType<DataTypeFloat64>(to_type))
             return monotonicityForType(type);
-        if (const auto *const type = checkAndGetDataType<DataTypeDateTime>(to_type))
+        if (const auto * type = checkAndGetDataType<DataTypeDate>(to_type))
             return monotonicityForType(type);
-        if (const auto *const type = checkAndGetDataType<DataTypeString>(to_type))
+        if (const auto * type = checkAndGetDataType<DataTypeDateTime>(to_type))
+            return monotonicityForType(type);
+        if (const auto * type = checkAndGetDataType<DataTypeString>(to_type))
             return monotonicityForType(type);
         if (isEnum(from_type))
         {
-            if (const auto *const type = checkAndGetDataType<DataTypeEnum8>(to_type))
+            if (const auto * type = checkAndGetDataType<DataTypeEnum8>(to_type))
                 return monotonicityForType(type);
-            if (const auto *const type = checkAndGetDataType<DataTypeEnum16>(to_type))
+            if (const auto * type = checkAndGetDataType<DataTypeEnum16>(to_type))
                 return monotonicityForType(type);
         }
         /// other types like Null, FixedString, Array and Tuple have no monotonicity defined
diff --git a/src/Functions/FunctionsEmbeddedDictionaries.h b/src/Functions/FunctionsEmbeddedDictionaries.h
index 7584a217a26..82b6ebb021b 100644
--- a/src/Functions/FunctionsEmbeddedDictionaries.h
+++ b/src/Functions/FunctionsEmbeddedDictionaries.h
@@ -165,14 +165,14 @@ public:
                 + toString(arguments.size()) + ", should be 1 or 2.",
                 ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
 
-        if (arguments[0]->getName() != TypeName<T>::get())
+        if (arguments[0]->getName() != TypeName<T>)
             throw Exception("Illegal type " + arguments[0]->getName() + " of argument of function " + getName()
-                + " (must be " + String(TypeName<T>::get()) + ")",
+                + " (must be " + String(TypeName<T>) + ")",
                 ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
-        if (arguments.size() == 2 && arguments[1]->getName() != TypeName<String>::get())
+        if (arguments.size() == 2 && arguments[1]->getName() != TypeName<String>)
             throw Exception("Illegal type " + arguments[1]->getName() + " of the second ('point of view') argument of function " + getName()
-                + " (must be " + String(TypeName<T>::get()) + ")",
+                + " (must be " + String(TypeName<T>) + ")",
                 ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
         return arguments[0];
@@ -259,19 +259,19 @@ public:
                 + toString(arguments.size()) + ", should be 2 or 3.",
                 ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
 
-        if (arguments[0]->getName() != TypeName<T>::get())
+        if (arguments[0]->getName() != TypeName<T>)
             throw Exception("Illegal type " + arguments[0]->getName() + " of first argument of function " + getName()
-                + " (must be " + String(TypeName<T>::get()) + ")",
+                + " (must be " + String(TypeName<T>) + ")",
                 ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
-        if (arguments[1]->getName() != TypeName<T>::get())
+        if (arguments[1]->getName() != TypeName<T>)
             throw Exception("Illegal type " + arguments[1]->getName() + " of second argument of function " + getName()
-                + " (must be " + String(TypeName<T>::get()) + ")",
+                + " (must be " + String(TypeName<T>) + ")",
                 ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
-        if (arguments.size() == 3 && arguments[2]->getName() != TypeName<String>::get())
+        if (arguments.size() == 3 && arguments[2]->getName() != TypeName<String>)
             throw Exception("Illegal type " + arguments[2]->getName() + " of the third ('point of view') argument of function " + getName()
-                + " (must be " + String(TypeName<String>::get()) + ")",
+                + " (must be " + String(TypeName<String>) + ")",
                 ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
         return std::make_shared<DataTypeUInt8>();
@@ -397,14 +397,14 @@ public:
                 + toString(arguments.size()) + ", should be 1 or 2.",
                 ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
 
-        if (arguments[0]->getName() != TypeName<T>::get())
+        if (arguments[0]->getName() != TypeName<T>)
             throw Exception("Illegal type " + arguments[0]->getName() + " of argument of function " + getName()
-            + " (must be " + String(TypeName<T>::get()) + ")",
+            + " (must be " + String(TypeName<T>) + ")",
             ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
-        if (arguments.size() == 2 && arguments[1]->getName() != TypeName<String>::get())
+        if (arguments.size() == 2 && arguments[1]->getName() != TypeName<String>)
             throw Exception("Illegal type " + arguments[1]->getName() + " of the second ('point of view') argument of function " + getName()
-                + " (must be " + String(TypeName<String>::get()) + ")",
+                + " (must be " + String(TypeName<String>) + ")",
                 ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
         return std::make_shared<DataTypeArray>(arguments[0]);
@@ -602,14 +602,14 @@ public:
                 + toString(arguments.size()) + ", should be 1 or 2.",
                 ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
 
-        if (arguments[0]->getName() != TypeName<UInt32>::get())
+        if (arguments[0]->getName() != TypeName<UInt32>)
             throw Exception("Illegal type " + arguments[0]->getName() + " of the first argument of function " + getName()
-                + " (must be " + String(TypeName<UInt32>::get()) + ")",
+                + " (must be " + String(TypeName<UInt32>) + ")",
                 ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
-        if (arguments.size() == 2 && arguments[1]->getName() != TypeName<String>::get())
+        if (arguments.size() == 2 && arguments[1]->getName() != TypeName<String>)
             throw Exception("Illegal type " + arguments[0]->getName() + " of the second argument of function " + getName()
-                + " (must be " + String(TypeName<String>::get()) + ")",
+                + " (must be " + String(TypeName<String>) + ")",
                 ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
         return std::make_shared<DataTypeString>();
diff --git a/src/Functions/FunctionsExternalDictionaries.h b/src/Functions/FunctionsExternalDictionaries.h
index 6157b532cb9..305eb3752c6 100644
--- a/src/Functions/FunctionsExternalDictionaries.h
+++ b/src/Functions/FunctionsExternalDictionaries.h
@@ -794,8 +794,11 @@ private:
         return result_type;
     }
 
-    ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t input_rows_count) const override
+    ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count) const override
     {
+        if (input_rows_count == 0)
+            return result_type->createColumn();
+
         /** We call dictHas function to get which map is key presented in dictionary.
             For key that presented in dictionary dict has result for that key index value will be 1. Otherwise 0.
             We invert result, and then for key that is not presented in dictionary value will be 1. Otherwise 0.
@@ -817,15 +820,15 @@ private:
         for (auto & key : is_key_in_dictionary_data)
             key = !key;
 
-        auto result_type = dictionary_get_func_impl.getReturnTypeImpl(arguments);
-        auto dictionary_get_result_column = dictionary_get_func_impl.executeImpl(arguments, result_type, input_rows_count);
+        auto dictionary_get_result_type = dictionary_get_func_impl.getReturnTypeImpl(arguments);
+        auto dictionary_get_result_column = dictionary_get_func_impl.executeImpl(arguments, dictionary_get_result_type, input_rows_count);
 
         ColumnPtr result;
 
-        WhichDataType result_data_type(result_type);
+        WhichDataType dictionary_get_result_data_type(dictionary_get_result_type);
         auto dictionary_get_result_column_mutable = dictionary_get_result_column->assumeMutable();
 
-        if (result_data_type.isTuple())
+        if (dictionary_get_result_data_type.isTuple())
         {
             ColumnTuple & column_tuple = assert_cast<ColumnTuple &>(*dictionary_get_result_column_mutable);
 
diff --git a/src/Functions/FunctionsHashing.h b/src/Functions/FunctionsHashing.h
index 94f8acbdf66..e664d0e035d 100644
--- a/src/Functions/FunctionsHashing.h
+++ b/src/Functions/FunctionsHashing.h
@@ -973,7 +973,7 @@ private:
         else if (which.isUInt16()) executeIntType<UInt16, first>(icolumn, vec_to);
         else if (which.isUInt32()) executeIntType<UInt32, first>(icolumn, vec_to);
         else if (which.isUInt64()) executeIntType<UInt64, first>(icolumn, vec_to);
-        else if (which.isUInt128() || which.isUUID()) executeBigIntType<UInt128, first>(icolumn, vec_to);
+        else if (which.isUInt128()) executeBigIntType<UInt128, first>(icolumn, vec_to);
         else if (which.isUInt256()) executeBigIntType<UInt256, first>(icolumn, vec_to);
         else if (which.isInt8()) executeIntType<Int8, first>(icolumn, vec_to);
         else if (which.isInt16()) executeIntType<Int16, first>(icolumn, vec_to);
@@ -981,6 +981,7 @@ private:
         else if (which.isInt64()) executeIntType<Int64, first>(icolumn, vec_to);
         else if (which.isInt128()) executeBigIntType<Int128, first>(icolumn, vec_to);
         else if (which.isInt256()) executeBigIntType<Int256, first>(icolumn, vec_to);
+        else if (which.isUUID()) executeBigIntType<UUID, first>(icolumn, vec_to);
         else if (which.isEnum8()) executeIntType<Int8, first>(icolumn, vec_to);
         else if (which.isEnum16()) executeIntType<Int16, first>(icolumn, vec_to);
         else if (which.isDate()) executeIntType<UInt16, first>(icolumn, vec_to);
diff --git a/src/Functions/FunctionsLogical.h b/src/Functions/FunctionsLogical.h
index 12733348762..9cd40e47a2f 100644
--- a/src/Functions/FunctionsLogical.h
+++ b/src/Functions/FunctionsLogical.h
@@ -3,6 +3,7 @@
 #include <common/types.h>
 #include <Core/Defines.h>
 #include <DataTypes/IDataType.h>
+#include <DataTypes/DataTypesNumber.h>
 #include <Functions/IFunctionImpl.h>
 #include <IO/WriteHelpers.h>
 #include <type_traits>
@@ -159,16 +160,16 @@ public:
 #if USE_EMBEDDED_COMPILER
     bool isCompilableImpl(const DataTypes &) const override { return useDefaultImplementationForNulls(); }
 
-    llvm::Value * compileImpl(llvm::IRBuilderBase & builder, const DataTypes & types, ValuePlaceholders values) const override
+    llvm::Value * compileImpl(llvm::IRBuilderBase & builder, const DataTypes & types, Values values) const override
     {
         assert(!types.empty() && !values.empty());
 
         auto & b = static_cast<llvm::IRBuilder<> &>(builder);
         if constexpr (!Impl::isSaturable())
         {
-            auto * result = nativeBoolCast(b, types[0], values[0]());
+            auto * result = nativeBoolCast(b, types[0], values[0]);
             for (size_t i = 1; i < types.size(); i++)
-                result = Impl::apply(b, result, nativeBoolCast(b, types[i], values[i]()));
+                result = Impl::apply(b, result, nativeBoolCast(b, types[i], values[i]));
             return b.CreateSelect(result, b.getInt8(1), b.getInt8(0));
         }
         constexpr bool breakOnTrue = Impl::isSaturatedValue(true);
@@ -179,7 +180,7 @@ public:
         for (size_t i = 0; i < types.size(); i++)
         {
             b.SetInsertPoint(next);
-            auto * value = values[i]();
+            auto * value = values[i];
             auto * truth = nativeBoolCast(b, types[i], value);
             if (!types[i]->equals(DataTypeUInt8{}))
                 value = b.CreateSelect(truth, b.getInt8(1), b.getInt8(0));
@@ -222,10 +223,10 @@ public:
 #if USE_EMBEDDED_COMPILER
     bool isCompilableImpl(const DataTypes &) const override { return true; }
 
-    llvm::Value * compileImpl(llvm::IRBuilderBase & builder, const DataTypes & types, ValuePlaceholders values) const override
+    llvm::Value * compileImpl(llvm::IRBuilderBase & builder, const DataTypes & types, Values values) const override
     {
         auto & b = static_cast<llvm::IRBuilder<> &>(builder);
-        return b.CreateSelect(Impl<UInt8>::apply(b, nativeBoolCast(b, types[0], values[0]())), b.getInt8(1), b.getInt8(0));
+        return b.CreateSelect(Impl<UInt8>::apply(b, nativeBoolCast(b, types[0], values[0])), b.getInt8(1), b.getInt8(0));
     }
 #endif
 };
diff --git a/src/Functions/FunctionsRound.h b/src/Functions/FunctionsRound.h
index 01074984ebf..e62d9524675 100644
--- a/src/Functions/FunctionsRound.h
+++ b/src/Functions/FunctionsRound.h
@@ -444,13 +444,7 @@ public:
         }
         else
         {
-            if constexpr (!is_big_int_v<NativeType>)
-                memcpy(out.data(), in.data(), in.size() * sizeof(T));
-            else
-            {
-                for (size_t i = 0; i < in.size(); i++)
-                    out[i] = in[i];
-            }
+            memcpy(out.data(), in.data(), in.size() * sizeof(T));
         }
     }
 };
@@ -511,7 +505,7 @@ class Dispatcher
 public:
     static ColumnPtr apply(const IColumn * column, Scale scale_arg)
     {
-        if constexpr (IsNumber<T>)
+        if constexpr (is_arithmetic_v<T>)
             return apply(checkAndGetColumn<ColumnVector<T>>(column), scale_arg);
         else if constexpr (IsDecimalNumber<T>)
             return apply(checkAndGetColumn<ColumnDecimal<T>>(column), scale_arg);
diff --git a/src/Functions/GCDLCMImpl.h b/src/Functions/GCDLCMImpl.h
index b83fe37abb6..f13a6dc3f95 100644
--- a/src/Functions/GCDLCMImpl.h
+++ b/src/Functions/GCDLCMImpl.h
@@ -2,7 +2,7 @@
 
 #include <DataTypes/NumberTraits.h>
 #include <Common/Exception.h>
-#include <numeric>
+#include <common/extended_types.h>
 #include <limits>
 #include <type_traits>
 
@@ -16,12 +16,9 @@ namespace DB
 
 namespace ErrorCodes
 {
-    extern const int NOT_IMPLEMENTED;
     extern const int DECIMAL_OVERFLOW;
 }
 
-template <class T>
-inline constexpr bool is_gcd_lcm_implemeted = !is_big_int_v<T>;
 
 template <typename A, typename B, typename Impl, typename Name>
 struct GCDLCMImpl
@@ -30,15 +27,7 @@ struct GCDLCMImpl
     static const constexpr bool allow_fixed_string = false;
 
     template <typename Result = ResultType>
-    static inline std::enable_if_t<!is_gcd_lcm_implemeted<Result>, Result>
-    apply(A, B)
-    {
-        throw Exception(ErrorCodes::NOT_IMPLEMENTED, "{} is not implemented for big integers", Name::name);
-    }
-
-    template <typename Result = ResultType>
-    static inline std::enable_if_t<is_gcd_lcm_implemeted<Result>, Result>
-    apply(A a, B b)
+    static inline Result apply(A a, B b)
     {
         throwIfDivisionLeadsToFPE(typename NumberTraits::ToInteger<A>::Type(a), typename NumberTraits::ToInteger<B>::Type(b));
         throwIfDivisionLeadsToFPE(typename NumberTraits::ToInteger<B>::Type(b), typename NumberTraits::ToInteger<A>::Type(a));
@@ -50,7 +39,7 @@ struct GCDLCMImpl
             /// gcd() internally uses std::abs()
             Int a_s = static_cast<Int>(a);
             Int b_s = static_cast<Int>(b);
-            Int min = std::numeric_limits<Int>::min();
+            Int min = std::numeric_limits<Int>::lowest();
             Int max = std::numeric_limits<Int>::max();
             if (unlikely((a_s == min || a_s == max) || (b_s == min || b_s == max)))
                 throw Exception(ErrorCodes::DECIMAL_OVERFLOW, "Intermediate result overflow (signed a = {}, signed b = {}, min = {}, max = {})", a_s, b_s, min, max);
diff --git a/src/Functions/GatherUtils/Algorithms.h b/src/Functions/GatherUtils/Algorithms.h
index 1a962089d0c..d17ab082004 100644
--- a/src/Functions/GatherUtils/Algorithms.h
+++ b/src/Functions/GatherUtils/Algorithms.h
@@ -13,7 +13,6 @@ namespace DB::ErrorCodes
 {
     extern const int LOGICAL_ERROR;
     extern const int TOO_LARGE_ARRAY_SIZE;
-    extern const int NOT_IMPLEMENTED;
 }
 
 namespace DB::GatherUtils
@@ -45,11 +44,7 @@ void writeSlice(const NumericArraySlice<T> & slice, NumericArraySink<U> & sink)
 
         if constexpr (OverBigInt<T> || OverBigInt<U>)
         {
-            if constexpr (std::is_same_v<U, UInt128>)
-            {
-                throw Exception("No conversion between UInt128 and " + demangle(typeid(T).name()), ErrorCodes::NOT_IMPLEMENTED);
-            }
-            else if constexpr (IsDecimalNumber<T>)
+            if constexpr (IsDecimalNumber<T>)
                 dst = static_cast<NativeU>(src.value);
             else
                 dst = static_cast<NativeU>(src);
diff --git a/src/Functions/GatherUtils/ArraySinkVisitor.h b/src/Functions/GatherUtils/ArraySinkVisitor.h
index b146780924f..7a53da25869 100644
--- a/src/Functions/GatherUtils/ArraySinkVisitor.h
+++ b/src/Functions/GatherUtils/ArraySinkVisitor.h
@@ -14,7 +14,7 @@ struct GenericArraySink;
 template <typename ArraySink>
 struct NullableArraySink;
 
-using NumericArraySinks = typename TypeListMap<NumericArraySink, TypeListNumbersAndUInt128>::Type;
+using NumericArraySinks = typename TypeListMap<NumericArraySink, TypeListNumbersAndUUID>::Type;
 using BasicArraySinks = typename AppendToTypeList<GenericArraySink, NumericArraySinks>::Type;
 using NullableArraySinks = typename TypeListMap<NullableArraySink, BasicArraySinks>::Type;
 using TypeListArraySinks = typename TypeListConcat<BasicArraySinks, NullableArraySinks>::Type;
diff --git a/src/Functions/GatherUtils/ArraySourceVisitor.h b/src/Functions/GatherUtils/ArraySourceVisitor.h
index 260e9a87161..1b92a9d2e81 100644
--- a/src/Functions/GatherUtils/ArraySourceVisitor.h
+++ b/src/Functions/GatherUtils/ArraySourceVisitor.h
@@ -17,7 +17,7 @@ struct NullableArraySource;
 template <typename Base>
 struct ConstSource;
 
-using NumericArraySources = typename TypeListMap<NumericArraySource, TypeListNumbersAndUInt128>::Type;
+using NumericArraySources = typename TypeListMap<NumericArraySource, TypeListNumbersAndUUID>::Type;
 using BasicArraySources = typename AppendToTypeList<GenericArraySource, NumericArraySources>::Type;
 
 class ArraySourceVisitor : public ApplyTypeListForClass<Visitor, BasicArraySources>::Type
diff --git a/src/Functions/GatherUtils/ValueSourceVisitor.h b/src/Functions/GatherUtils/ValueSourceVisitor.h
index 538ee156e5d..be503cdcfcf 100644
--- a/src/Functions/GatherUtils/ValueSourceVisitor.h
+++ b/src/Functions/GatherUtils/ValueSourceVisitor.h
@@ -17,7 +17,7 @@ struct NullableValueSource;
 template <typename Base>
 struct ConstSource;
 
-using NumericValueSources = typename TypeListMap<NumericValueSource, TypeListNumbersAndUInt128>::Type;
+using NumericValueSources = typename TypeListMap<NumericValueSource, TypeListNumbersAndUUID>::Type;
 using BasicValueSources = typename AppendToTypeList<GenericValueSource, NumericValueSources>::Type;
 using NullableValueSources = typename TypeListMap<NullableValueSource, BasicValueSources>::Type;
 using BasicAndNullableValueSources = typename TypeListConcat<BasicValueSources, NullableValueSources>::Type;
diff --git a/src/Functions/GatherUtils/createArraySink.cpp b/src/Functions/GatherUtils/createArraySink.cpp
index 00b33cf9821..90983c9c25c 100644
--- a/src/Functions/GatherUtils/createArraySink.cpp
+++ b/src/Functions/GatherUtils/createArraySink.cpp
@@ -55,7 +55,7 @@ struct ArraySinkCreator<>
 
 std::unique_ptr<IArraySink> createArraySink(ColumnArray & col, size_t column_size)
 {
-    using Creator = ApplyTypeListForClass<ArraySinkCreator, TypeListNumbersAndUInt128>::Type;
+    using Creator = ApplyTypeListForClass<ArraySinkCreator, TypeListNumbersAndUUID>::Type;
     return Creator::create(col.getData(), col.getOffsets(), column_size);
 }
 }
diff --git a/src/Functions/GatherUtils/createArraySource.cpp b/src/Functions/GatherUtils/createArraySource.cpp
index 0744e2f2ea3..d98a72e456f 100644
--- a/src/Functions/GatherUtils/createArraySource.cpp
+++ b/src/Functions/GatherUtils/createArraySource.cpp
@@ -58,7 +58,7 @@ struct ArraySourceCreator<>
 
 std::unique_ptr<IArraySource> createArraySource(const ColumnArray & col, bool is_const, size_t total_rows)
 {
-    using Creator = typename ApplyTypeListForClass<ArraySourceCreator, TypeListNumbersAndUInt128>::Type;
+    using Creator = typename ApplyTypeListForClass<ArraySourceCreator, TypeListNumbersAndUUID>::Type;
     if (const auto * column_nullable = typeid_cast<const ColumnNullable *>(&col.getData()))
     {
         auto column = ColumnArray::create(column_nullable->getNestedColumnPtr(), col.getOffsetsPtr());
diff --git a/src/Functions/GatherUtils/createValueSource.cpp b/src/Functions/GatherUtils/createValueSource.cpp
index 20110066214..4f538b95369 100644
--- a/src/Functions/GatherUtils/createValueSource.cpp
+++ b/src/Functions/GatherUtils/createValueSource.cpp
@@ -58,7 +58,7 @@ struct ValueSourceCreator<>
 
 std::unique_ptr<IValueSource> createValueSource(const IColumn & col, bool is_const, size_t total_rows)
 {
-    using Creator = typename ApplyTypeListForClass<ValueSourceCreator, TypeListNumbersAndUInt128>::Type;
+    using Creator = typename ApplyTypeListForClass<ValueSourceCreator, TypeListNumbersAndUUID>::Type;
     if (const auto * column_nullable = typeid_cast<const ColumnNullable *>(&col))
     {
         return Creator::create(column_nullable->getNestedColumn(), &column_nullable->getNullMapData(), is_const, total_rows);
diff --git a/src/Functions/GregorianDate.h b/src/Functions/GregorianDate.h
index 844fb180e5e..5f179483b53 100644
--- a/src/Functions/GregorianDate.h
+++ b/src/Functions/GregorianDate.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <common/extended_types.h>
 #include <Common/Exception.h>
 #include <Core/Types.h>
 #include <IO/ReadBuffer.h>
@@ -9,6 +10,7 @@
 
 #include <cstdint>
 
+
 namespace DB
 {
     namespace ErrorCodes
@@ -27,8 +29,6 @@ namespace DB
     class GregorianDate
     {
     public:
-        GregorianDate() = delete;
-
         /** Construct from date in text form 'YYYY-MM-DD' by reading from
           * ReadBuffer.
           */
@@ -38,14 +38,14 @@ namespace DB
           * integral type which should be at least 32 bits wide, and
           * should preferably signed.
           */
-        template <typename T, std::enable_if_t<wide::IntegralConcept<T>()> * = nullptr>
+        template <typename T, std::enable_if_t<is_integer_v<T>> * = nullptr>
         GregorianDate(T mjd);
 
         /** Convert to Modified Julian Day. The type T is an integral type
           * which should be at least 32 bits wide, and should preferably
           * signed.
           */
-        template <typename T, std::enable_if_t<wide::IntegralConcept<T>()> * = nullptr>
+        template <typename T, std::enable_if_t<is_integer_v<T>> * = nullptr>
         T toModifiedJulianDay() const;
 
         /** Write the date in text form 'YYYY-MM-DD' to a buffer.
@@ -90,14 +90,14 @@ namespace DB
           * integral type which should be at least 32 bits wide, and
           * should preferably signed.
           */
-        template <typename T, std::enable_if_t<wide::IntegralConcept<T>()> * = nullptr>
+        template <typename T, std::enable_if_t<is_integer_v<T>> * = nullptr>
         OrdinalDate(T mjd);
 
         /** Convert to Modified Julian Day. The type T is an integral
           * type which should be at least 32 bits wide, and should
           * preferably be signed.
           */
-        template <typename T, std::enable_if_t<wide::IntegralConcept<T>()> * = nullptr>
+        template <typename T, std::enable_if_t<is_integer_v<T>> * = nullptr>
         T toModifiedJulianDay() const noexcept;
 
         YearT year() const noexcept
@@ -259,7 +259,7 @@ namespace DB
     }
 
     template <typename YearT>
-    template <typename T, std::enable_if_t<wide::IntegralConcept<T>()> *>
+    template <typename T, std::enable_if_t<is_integer_v<T>> *>
     GregorianDate<YearT>::GregorianDate(T mjd)
     {
         const OrdinalDate<YearT> ord(mjd);
@@ -270,7 +270,7 @@ namespace DB
     }
 
     template <typename YearT>
-    template <typename T, std::enable_if_t<wide::IntegralConcept<T>()> *>
+    template <typename T, std::enable_if_t<is_integer_v<T>> *>
     T GregorianDate<YearT>::toModifiedJulianDay() const
     {
         const MonthDay md(month_, day_of_month_);
@@ -332,7 +332,7 @@ namespace DB
     }
 
     template <typename YearT>
-    template <typename T, std::enable_if_t<wide::IntegralConcept<T>()> *>
+    template <typename T, std::enable_if_t<is_integer_v<T>> *>
     OrdinalDate<YearT>::OrdinalDate(T mjd)
     {
         const auto a         = mjd + 678575;
@@ -348,7 +348,7 @@ namespace DB
     }
 
     template <typename YearT>
-    template <typename T, std::enable_if_t<wide::IntegralConcept<T>()> *>
+    template <typename T, std::enable_if_t<is_integer_v<T>> *>
     T OrdinalDate<YearT>::toModifiedJulianDay() const noexcept
     {
         const auto y = year_ - 1;
diff --git a/src/Functions/IFunction.cpp b/src/Functions/IFunction.cpp
index 5bbe6eb523e..c8a3bd22c3c 100644
--- a/src/Functions/IFunction.cpp
+++ b/src/Functions/IFunction.cpp
@@ -64,8 +64,7 @@ public:
         size_t operator()(const DictionaryKey & key) const
         {
             SipHash hash;
-            hash.update(key.hash.low);
-            hash.update(key.hash.high);
+            hash.update(key.hash);
             hash.update(key.size);
             return hash.get64();
         }
@@ -516,43 +515,49 @@ bool IFunction::isCompilable(const DataTypes & arguments) const
     return isCompilableImpl(arguments);
 }
 
-llvm::Value * IFunction::compile(llvm::IRBuilderBase & builder, const DataTypes & arguments, ValuePlaceholders values) const
+llvm::Value * IFunction::compile(llvm::IRBuilderBase & builder, const DataTypes & arguments, Values values) const
 {
-    if (useDefaultImplementationForNulls())
+    auto denulled_arguments = removeNullables(arguments);
+    if (useDefaultImplementationForNulls() && denulled_arguments)
     {
-        if (auto denulled = removeNullables(arguments))
+        auto & b = static_cast<llvm::IRBuilder<> &>(builder);
+
+        std::vector<llvm::Value*> unwrapped_values;
+        std::vector<llvm::Value*> is_null_values;
+
+        unwrapped_values.reserve(arguments.size());
+        is_null_values.reserve(arguments.size());
+
+        for (size_t i = 0; i < arguments.size(); ++i)
         {
-            /// FIXME: when only one column is nullable, this can actually be slower than the non-jitted version
-            ///        because this involves copying the null map while `wrapInNullable` reuses it.
-            auto & b = static_cast<llvm::IRBuilder<> &>(builder);
-            auto * fail = llvm::BasicBlock::Create(b.GetInsertBlock()->getContext(), "", b.GetInsertBlock()->getParent());
-            auto * join = llvm::BasicBlock::Create(b.GetInsertBlock()->getContext(), "", b.GetInsertBlock()->getParent());
-            auto * zero = llvm::Constant::getNullValue(toNativeType(b, makeNullable(getReturnTypeImpl(*denulled))));
-            for (size_t i = 0; i < arguments.size(); i++)
+            auto * value = values[i];
+
+            WhichDataType data_type(arguments[i]);
+            if (data_type.isNullable())
             {
-                if (!arguments[i]->isNullable())
-                    continue;
-                /// Would be nice to evaluate all this lazily, but that'd change semantics: if only unevaluated
-                /// arguments happen to contain NULLs, the return value would not be NULL, though it should be.
-                auto * value = values[i]();
-                auto * ok = llvm::BasicBlock::Create(b.GetInsertBlock()->getContext(), "", b.GetInsertBlock()->getParent());
-                b.CreateCondBr(b.CreateExtractValue(value, {1}), fail, ok);
-                b.SetInsertPoint(ok);
-                values[i] = [value = b.CreateExtractValue(value, {0})]() { return value; };
+                unwrapped_values.emplace_back(b.CreateExtractValue(value, {0}));
+                is_null_values.emplace_back(b.CreateExtractValue(value, {1}));
+            }
+            else
+            {
+                unwrapped_values.emplace_back(value);
             }
-            auto * result = b.CreateInsertValue(zero, compileImpl(builder, *denulled, std::move(values)), {0});
-            auto * result_columns = b.GetInsertBlock();
-            b.CreateBr(join);
-            b.SetInsertPoint(fail);
-            auto * null = b.CreateInsertValue(zero, b.getTrue(), {1});
-            b.CreateBr(join);
-            b.SetInsertPoint(join);
-            auto * phi = b.CreatePHI(result->getType(), 2);
-            phi->addIncoming(result, result_columns);
-            phi->addIncoming(null, fail);
-            return phi;
         }
+
+        auto * result = compileImpl(builder, *denulled_arguments, unwrapped_values);
+
+        auto * nullable_structure_type = toNativeType(b, makeNullable(getReturnTypeImpl(*denulled_arguments)));
+        auto * nullable_structure_value = llvm::Constant::getNullValue(nullable_structure_type);
+
+        auto * nullable_structure_with_result_value = b.CreateInsertValue(nullable_structure_value, result, {0});
+        auto * nullable_structure_result_null = b.CreateExtractValue(nullable_structure_with_result_value, {1});
+
+        for (auto * is_null_value : is_null_values)
+            nullable_structure_result_null = b.CreateOr(nullable_structure_result_null, is_null_value);
+
+        return b.CreateInsertValue(nullable_structure_with_result_value, nullable_structure_result_null, {1});
     }
+
     return compileImpl(builder, arguments, std::move(values));
 }
 
diff --git a/src/Functions/IFunction.h b/src/Functions/IFunction.h
index f9217d30707..97e38e0afe8 100644
--- a/src/Functions/IFunction.h
+++ b/src/Functions/IFunction.h
@@ -54,7 +54,7 @@ public:
 using ExecutableFunctionPtr = std::shared_ptr<IExecutableFunction>;
 
 
-using ValuePlaceholders = std::vector<std::function<llvm::Value * ()>>;
+using Values = std::vector<llvm::Value *>;
 
 /// Function with known arguments and return type (when the specific overload was chosen).
 /// It is also the point where all function-specific properties are known.
@@ -90,7 +90,7 @@ public:
       *       templates with default arguments is impossible and including LLVM in such a generic header
       *       as this one is a major pain.
       */
-    virtual llvm::Value * compile(llvm::IRBuilderBase & /*builder*/, ValuePlaceholders /*values*/) const
+    virtual llvm::Value * compile(llvm::IRBuilderBase & /*builder*/, Values /*values*/) const
     {
         throw Exception(getName() + " is not JIT-compilable", ErrorCodes::NOT_IMPLEMENTED);
     }
diff --git a/src/Functions/IFunctionAdaptors.h b/src/Functions/IFunctionAdaptors.h
index 2b9034dc784..f9f27d528ec 100644
--- a/src/Functions/IFunctionAdaptors.h
+++ b/src/Functions/IFunctionAdaptors.h
@@ -54,7 +54,7 @@ public:
 
     bool isCompilable() const final { return impl->isCompilable(); }
 
-    llvm::Value * compile(llvm::IRBuilderBase & builder, ValuePlaceholders values) const override
+    llvm::Value * compile(llvm::IRBuilderBase & builder, Values values) const override
     {
         return impl->compile(builder, std::move(values));
     }
@@ -183,7 +183,10 @@ public:
 
     bool isCompilable() const override { return function->isCompilable(getArgumentTypes()); }
 
-    llvm::Value * compile(llvm::IRBuilderBase & builder, ValuePlaceholders values) const override { return function->compile(builder, getArgumentTypes(), std::move(values)); }
+    llvm::Value * compile(llvm::IRBuilderBase & builder, Values values) const override
+    {
+        return function->compile(builder, getArgumentTypes(), std::move(values));
+    }
 
 #endif
 
diff --git a/src/Functions/IFunctionImpl.h b/src/Functions/IFunctionImpl.h
index f75fe07122d..e61b9b3414f 100644
--- a/src/Functions/IFunctionImpl.h
+++ b/src/Functions/IFunctionImpl.h
@@ -96,7 +96,7 @@ public:
 
     virtual bool isCompilable() const { return false; }
 
-    virtual llvm::Value * compile(llvm::IRBuilderBase & /*builder*/, ValuePlaceholders /*values*/) const
+    virtual llvm::Value * compile(llvm::IRBuilderBase & /*builder*/, Values /*values*/) const
     {
         throw Exception(getName() + " is not JIT-compilable", ErrorCodes::NOT_IMPLEMENTED);
     }
@@ -237,20 +237,6 @@ public:
       */
     virtual bool canBeExecutedOnDefaultArguments() const { return true; }
 
-#if USE_EMBEDDED_COMPILER
-
-    virtual bool isCompilable() const
-    {
-        throw Exception("isCompilable without explicit types is not implemented for IFunction", ErrorCodes::NOT_IMPLEMENTED);
-    }
-
-    virtual llvm::Value * compile(llvm::IRBuilderBase & /*builder*/, ValuePlaceholders /*values*/) const
-    {
-        throw Exception("compile without explicit types is not implemented for IFunction", ErrorCodes::NOT_IMPLEMENTED);
-    }
-
-#endif
-
     /// Properties from IFunctionBase (see IFunction.h)
     virtual bool isSuitableForConstantFolding() const { return true; }
     virtual ColumnPtr getResultIfAlwaysReturnsConstantAndHasArguments(const ColumnsWithTypeAndName & /*arguments*/) const { return nullptr; }
@@ -298,7 +284,7 @@ public:
 
     bool isCompilable(const DataTypes & arguments) const;
 
-    llvm::Value * compile(llvm::IRBuilderBase &, const DataTypes & arguments, ValuePlaceholders values) const;
+    llvm::Value * compile(llvm::IRBuilderBase &, const DataTypes & arguments, Values values) const;
 
 #endif
 
@@ -308,7 +294,7 @@ protected:
 
     virtual bool isCompilableImpl(const DataTypes &) const { return false; }
 
-    virtual llvm::Value * compileImpl(llvm::IRBuilderBase &, const DataTypes &, ValuePlaceholders) const
+    virtual llvm::Value * compileImpl(llvm::IRBuilderBase &, const DataTypes &, Values) const
     {
         throw Exception(getName() + " is not JIT-compilable", ErrorCodes::NOT_IMPLEMENTED);
     }
diff --git a/src/Functions/PolygonUtils.h b/src/Functions/PolygonUtils.h
index 27ee1d2a99f..4226e3ae0b0 100644
--- a/src/Functions/PolygonUtils.h
+++ b/src/Functions/PolygonUtils.h
@@ -646,7 +646,7 @@ UInt128 sipHash128(Polygon && polygon)
         hash_ring(inner);
 
     UInt128 res;
-    hash.get128(res.low, res.high);
+    hash.get128(res);
     return res;
 }
 
diff --git a/src/Functions/array/arrayAggregation.cpp b/src/Functions/array/arrayAggregation.cpp
index 784beb9fc3a..3d40dfe83ea 100644
--- a/src/Functions/array/arrayAggregation.cpp
+++ b/src/Functions/array/arrayAggregation.cpp
@@ -68,12 +68,13 @@ struct ArrayAggregateResultImpl<ArrayElement, AggregateOperation::sum>
 {
     using Result =
         std::conditional_t<std::is_same_v<ArrayElement, Int128>, Int128,
-            std::conditional_t<std::is_same_v<ArrayElement, Int256>, Int256,
-                std::conditional_t<std::is_same_v<ArrayElement, UInt256>, UInt256,
-                    std::conditional_t<IsDecimalNumber<ArrayElement>, Decimal128,
-                        std::conditional_t<std::is_floating_point_v<ArrayElement>, Float64,
-                            std::conditional_t<std::is_signed_v<ArrayElement>, Int64,
-                                UInt64>>>>>>;
+        std::conditional_t<std::is_same_v<ArrayElement, UInt128>, UInt128,
+        std::conditional_t<std::is_same_v<ArrayElement, Int256>, Int256,
+        std::conditional_t<std::is_same_v<ArrayElement, UInt256>, UInt256,
+        std::conditional_t<IsDecimalNumber<ArrayElement>, Decimal128,
+        std::conditional_t<std::is_floating_point_v<ArrayElement>, Float64,
+        std::conditional_t<std::is_signed_v<ArrayElement>, Int64,
+            UInt64>>>>>>>;
 };
 
 template <typename ArrayElement, AggregateOperation operation>
@@ -173,7 +174,7 @@ struct ArrayAggregateImpl
                 {
                     size_t array_size = offsets[i] - pos;
                     /// Just multiply the value by array size.
-                    res[i] = x * array_size;
+                    res[i] = x * ResultType(array_size);
                 }
                 else if constexpr (aggregate_operation == AggregateOperation::min ||
                                 aggregate_operation == AggregateOperation::max)
@@ -244,12 +245,15 @@ struct ArrayAggregateImpl
         size_t pos = 0;
         for (size_t i = 0; i < offsets.size(); ++i)
         {
-            AggregationType aggregate_value = 0;
+            AggregationType aggregate_value{};
 
             /// Array is empty
             if (offsets[i] == pos)
             {
-                res[i] = aggregate_value;
+                if constexpr (IsDecimalNumber<AggregationType>)
+                    res[i] = aggregate_value.value;
+                else
+                    res[i] = aggregate_value;
                 continue;
             }
 
@@ -304,7 +308,7 @@ struct ArrayAggregateImpl
             {
                 if constexpr (IsDecimalNumber<Element>)
                 {
-                    aggregate_value = aggregate_value / count;
+                    aggregate_value = aggregate_value / AggregationType(count);
                     res[i] = DecimalUtils::convertTo<ResultType>(aggregate_value, data.getScale());
                 }
                 else
@@ -340,6 +344,7 @@ struct ArrayAggregateImpl
             executeType<UInt16>(mapped, offsets, res) ||
             executeType<UInt32>(mapped, offsets, res) ||
             executeType<UInt64>(mapped, offsets, res) ||
+            executeType<UInt128>(mapped, offsets, res) ||
             executeType<UInt256>(mapped, offsets, res) ||
             executeType<Int8>(mapped, offsets, res) ||
             executeType<Int16>(mapped, offsets, res) ||
diff --git a/src/Functions/array/arrayCumSumNonNegative.cpp b/src/Functions/array/arrayCumSumNonNegative.cpp
index 2c7362a1605..288422c1c9c 100644
--- a/src/Functions/array/arrayCumSumNonNegative.cpp
+++ b/src/Functions/array/arrayCumSumNonNegative.cpp
@@ -60,8 +60,8 @@ struct ArrayCumSumNonNegativeImpl
             for (; pos < offset; ++pos)
             {
                 accumulated += src_values[pos];
-                if (accumulated < 0)
-                    accumulated = 0;
+                if (accumulated < Dst{})
+                    accumulated = {};
                 res_values[pos] = accumulated;
             }
         }
diff --git a/src/Functions/array/arrayDifference.cpp b/src/Functions/array/arrayDifference.cpp
index b4b30079a4e..7d11c6e89c8 100644
--- a/src/Functions/array/arrayDifference.cpp
+++ b/src/Functions/array/arrayDifference.cpp
@@ -13,6 +13,7 @@ namespace ErrorCodes
 {
     extern const int ILLEGAL_TYPE_OF_ARGUMENT;
     extern const int ILLEGAL_COLUMN;
+    extern const int DECIMAL_OVERFLOW;
 }
 
 /** arrayDifference() - returns an array with the difference between all pairs of neighboring elements.
@@ -57,13 +58,32 @@ struct ArrayDifferenceImpl
         {
             if (pos == begin)
             {
-                dst[pos] = 0;
+                dst[pos] = {};
                 prev = src[pos];
             }
             else
             {
                 Element curr = src[pos];
-                dst[pos] = curr - prev;
+
+                if constexpr (IsDecimalNumber<Element>)
+                {
+                    using ResultNativeType = typename Result::NativeType;
+
+                    ResultNativeType result_value;
+                    bool overflow = common::subOverflow(
+                        static_cast<ResultNativeType>(curr.value),
+                        static_cast<ResultNativeType>(prev.value),
+                        result_value);
+                    if (overflow)
+                        throw Exception(ErrorCodes::DECIMAL_OVERFLOW, "Decimal math overflow");
+
+                    dst[pos] = Result(result_value);
+                }
+                else
+                {
+                    dst[pos] = curr - prev;
+                }
+
                 prev = curr;
             }
         }
diff --git a/src/Functions/array/arrayDistinct.cpp b/src/Functions/array/arrayDistinct.cpp
index cf73a577def..c43047a0c56 100644
--- a/src/Functions/array/arrayDistinct.cpp
+++ b/src/Functions/array/arrayDistinct.cpp
@@ -270,7 +270,7 @@ void FunctionArrayDistinct::executeHashed(
             UInt128 hash;
             SipHash hash_function;
             src_data.updateHashWithValue(j, hash_function);
-            hash_function.get128(reinterpret_cast<char *>(&hash));
+            hash_function.get128(hash);
 
             if (!set.find(hash))
             {
diff --git a/src/Functions/array/arrayElement.cpp b/src/Functions/array/arrayElement.cpp
index 4254b00e4bc..f49739d75cc 100644
--- a/src/Functions/array/arrayElement.cpp
+++ b/src/Functions/array/arrayElement.cpp
@@ -876,7 +876,7 @@ bool FunctionArrayElement::matchKeyToIndexNumberConst(
     Field::dispatch([&](const auto & value)
     {
         using FieldType = std::decay_t<decltype(value)>;
-        if constexpr (is_integer_v<FieldType> && std::is_convertible_v<FieldType, DataType>)
+        if constexpr (std::is_same_v<FieldType, DataType> || (is_integer_v<FieldType> && std::is_convertible_v<FieldType, DataType>))
             index_as_integer = static_cast<DataType>(value);
     }, index);
 
@@ -914,14 +914,15 @@ bool FunctionArrayElement::matchKeyToIndex(
         || matchKeyToIndexNumber<UInt16>(data, offsets, arguments, matched_idxs)
         || matchKeyToIndexNumber<UInt32>(data, offsets, arguments, matched_idxs)
         || matchKeyToIndexNumber<UInt64>(data, offsets, arguments, matched_idxs)
+        || matchKeyToIndexNumber<UInt128>(data, offsets, arguments, matched_idxs)
+        || matchKeyToIndexNumber<UInt256>(data, offsets, arguments, matched_idxs)
         || matchKeyToIndexNumber<Int8>(data, offsets, arguments, matched_idxs)
         || matchKeyToIndexNumber<Int16>(data, offsets, arguments, matched_idxs)
         || matchKeyToIndexNumber<Int32>(data, offsets, arguments, matched_idxs)
         || matchKeyToIndexNumber<Int64>(data, offsets, arguments, matched_idxs)
         || matchKeyToIndexNumber<Int128>(data, offsets, arguments, matched_idxs)
-        || matchKeyToIndexNumber<UInt128>(data, offsets, arguments, matched_idxs)
         || matchKeyToIndexNumber<Int256>(data, offsets, arguments, matched_idxs)
-        || matchKeyToIndexNumber<UInt256>(data, offsets, arguments, matched_idxs)
+        || matchKeyToIndexNumber<UUID>(data, offsets, arguments, matched_idxs)
         || matchKeyToIndexString(data, offsets, arguments, matched_idxs);
 }
 
@@ -933,14 +934,15 @@ bool FunctionArrayElement::matchKeyToIndexConst(
         || matchKeyToIndexNumberConst<UInt16>(data, offsets, index, matched_idxs)
         || matchKeyToIndexNumberConst<UInt32>(data, offsets, index, matched_idxs)
         || matchKeyToIndexNumberConst<UInt64>(data, offsets, index, matched_idxs)
+        || matchKeyToIndexNumberConst<UInt128>(data, offsets, index, matched_idxs)
+        || matchKeyToIndexNumberConst<UInt256>(data, offsets, index, matched_idxs)
         || matchKeyToIndexNumberConst<Int8>(data, offsets, index, matched_idxs)
         || matchKeyToIndexNumberConst<Int16>(data, offsets, index, matched_idxs)
         || matchKeyToIndexNumberConst<Int32>(data, offsets, index, matched_idxs)
         || matchKeyToIndexNumberConst<Int64>(data, offsets, index, matched_idxs)
         || matchKeyToIndexNumberConst<Int128>(data, offsets, index, matched_idxs)
-        || matchKeyToIndexNumberConst<UInt128>(data, offsets, index, matched_idxs)
         || matchKeyToIndexNumberConst<Int256>(data, offsets, index, matched_idxs)
-        || matchKeyToIndexNumberConst<UInt256>(data, offsets, index, matched_idxs)
+        || matchKeyToIndexNumberConst<UUID>(data, offsets, index, matched_idxs)
         || matchKeyToIndexStringConst(data, offsets, index, matched_idxs);
 }
 
diff --git a/src/Functions/array/arrayEnumerateRanked.h b/src/Functions/array/arrayEnumerateRanked.h
index 2d13482b01e..789c2c38e96 100644
--- a/src/Functions/array/arrayEnumerateRanked.h
+++ b/src/Functions/array/arrayEnumerateRanked.h
@@ -142,7 +142,7 @@ static inline UInt128 ALWAYS_INLINE hash128depths(const std::vector<size_t> & in
         key_columns[j]->updateHashWithValue(indices[j], hash);
     }
 
-    hash.get128(key.low, key.high);
+    hash.get128(key);
 
     return key;
 }
diff --git a/src/Functions/array/arrayIntersect.cpp b/src/Functions/array/arrayIntersect.cpp
index 7275a1395c0..05bb4351c3e 100644
--- a/src/Functions/array/arrayIntersect.cpp
+++ b/src/Functions/array/arrayIntersect.cpp
@@ -518,7 +518,9 @@ ColumnPtr FunctionArrayIntersect::execute(const UnpackedArrays & arrays, Mutable
                     typename Map::mapped_type * value = nullptr;
 
                     if constexpr (is_numeric_column)
+                    {
                         value = &map[columns[arg_num]->getElement(i)];
+                    }
                     else if constexpr (std::is_same<ColumnType, ColumnString>::value || std::is_same<ColumnType, ColumnFixedString>::value)
                         value = &map[columns[arg_num]->getDataAt(i)];
                     else
diff --git a/src/Functions/array/mapOp.cpp b/src/Functions/array/mapOp.cpp
index 78b7ce2b155..1a19ee41d2f 100644
--- a/src/Functions/array/mapOp.cpp
+++ b/src/Functions/array/mapOp.cpp
@@ -30,15 +30,15 @@ struct TupArg
     const IColumn::Offsets & val_offsets;
     bool is_const;
 };
-using TupleMaps = std::vector<struct TupArg>;
+using TupleMaps = std::vector<TupArg>;
 
-namespace OpTypes
+enum class OpTypes
 {
-    extern const int ADD = 0;
-    extern const int SUBTRACT = 1;
-}
+    ADD = 0,
+    SUBTRACT = 1
+};
 
-template <int op_type>
+template <OpTypes op_type>
 class FunctionMapOp : public IFunction
 {
 public:
@@ -160,7 +160,7 @@ private:
                     KeyType key;
                     if constexpr (is_str_key)
                     {
-                        // have to use Field structs to get strings
+                        // have to use Field to get strings
                         key = arg.key_column[offset + j].get<KeyType>();
                     }
                     else
@@ -209,7 +209,8 @@ private:
     {
         const auto & promoted_type = (assert_cast<const DataTypeArray *>(res_type.getElements()[1].get()))->getNestedType();
 #define MATCH_EXECUTE(is_str) \
-        switch (promoted_type->getTypeId()) { \
+        switch (promoted_type->getTypeId()) \
+        { \
             case TypeIndex::Int64: return execute2<KeyType, is_str, Int64>(row_count, args, res_type); \
             case TypeIndex::UInt64: return execute2<KeyType, is_str, UInt64>(row_count, args, res_type); \
             case TypeIndex::Float64: return execute2<KeyType, is_str, Float64>(row_count, args, res_type); \
@@ -290,6 +291,10 @@ private:
                 return execute1<Int32, false>(row_count, res_type, args);
             case TypeIndex::Int64:
                 return execute1<Int64, false>(row_count, res_type, args);
+            case TypeIndex::Int128:
+                return execute1<Int128, false>(row_count, res_type, args);
+            case TypeIndex::Int256:
+                return execute1<Int256, false>(row_count, res_type, args);
             case TypeIndex::UInt8:
                 return execute1<UInt8, false>(row_count, res_type, args);
             case TypeIndex::Date:
@@ -300,8 +305,12 @@ private:
                 return execute1<UInt32, false>(row_count, res_type, args);
             case TypeIndex::UInt64:
                 return execute1<UInt64, false>(row_count, res_type, args);
-            case TypeIndex::UUID:
+            case TypeIndex::UInt128:
                 return execute1<UInt128, false>(row_count, res_type, args);
+            case TypeIndex::UInt256:
+                return execute1<UInt256, false>(row_count, res_type, args);
+            case TypeIndex::UUID:
+                return execute1<UUID, false>(row_count, res_type, args);
             case TypeIndex::FixedString:
             case TypeIndex::String:
                 return execute1<String, true>(row_count, res_type, args);
diff --git a/src/Functions/bar.cpp b/src/Functions/bar.cpp
index c2b5f93994e..821cd8bcfab 100644
--- a/src/Functions/bar.cpp
+++ b/src/Functions/bar.cpp
@@ -3,7 +3,6 @@
 #include <DataTypes/DataTypeString.h>
 #include <Columns/ColumnString.h>
 #include <Common/UnicodeBar.h>
-#include <Common/FieldVisitors.h>
 #include <IO/WriteHelpers.h>
 
 
diff --git a/src/Functions/fromUnixTimestamp64Micro.cpp b/src/Functions/fromUnixTimestamp64Micro.cpp
index a4bac327a3a..6cc22b31758 100644
--- a/src/Functions/fromUnixTimestamp64Micro.cpp
+++ b/src/Functions/fromUnixTimestamp64Micro.cpp
@@ -4,17 +4,11 @@
 namespace DB
 {
 
-struct TransformFromMicro
-{
-    static constexpr auto name = "fromUnixTimestamp64Micro";
-    static constexpr auto target_scale = 6;
-    using SourceDataType = DataTypeInt64;
-    using ResultDataType = DataTypeDateTime64;
-};
-
 void registerFromUnixTimestamp64Micro(FunctionFactory & factory)
 {
-    factory.registerFunction<FunctionUnixTimestamp64<TransformFromMicro>>();
+    factory.registerFunction("fromUnixTimestamp64Micro",
+        [](ContextPtr){ return std::make_unique<DefaultOverloadResolver>(
+            std::make_shared<FunctionFromUnixTimestamp64>(6, "fromUnixTimestamp64Micro")); });
 }
 
 }
diff --git a/src/Functions/fromUnixTimestamp64Milli.cpp b/src/Functions/fromUnixTimestamp64Milli.cpp
index a4ce79ecebb..6973fb47176 100644
--- a/src/Functions/fromUnixTimestamp64Milli.cpp
+++ b/src/Functions/fromUnixTimestamp64Milli.cpp
@@ -4,17 +4,11 @@
 namespace DB
 {
 
-struct TransformFromMilli
-{
-    static constexpr auto name = "fromUnixTimestamp64Milli";
-    static constexpr auto target_scale = 3;
-    using SourceDataType = DataTypeInt64;
-    using ResultDataType = DataTypeDateTime64;
-};
-
 void registerFromUnixTimestamp64Milli(FunctionFactory & factory)
 {
-    factory.registerFunction<FunctionUnixTimestamp64<TransformFromMilli>>();
+    factory.registerFunction("fromUnixTimestamp64Milli",
+        [](ContextPtr){ return std::make_unique<DefaultOverloadResolver>(
+            std::make_shared<FunctionFromUnixTimestamp64>(3, "fromUnixTimestamp64Milli")); });
 }
 
 }
diff --git a/src/Functions/fromUnixTimestamp64Nano.cpp b/src/Functions/fromUnixTimestamp64Nano.cpp
index cd69aa56a2c..50c4e4dc8d8 100644
--- a/src/Functions/fromUnixTimestamp64Nano.cpp
+++ b/src/Functions/fromUnixTimestamp64Nano.cpp
@@ -4,17 +4,11 @@
 namespace DB
 {
 
-struct TransformFromNano
-{
-    static constexpr auto name = "fromUnixTimestamp64Nano";
-    static constexpr auto target_scale = 9;
-    using SourceDataType = DataTypeInt64;
-    using ResultDataType = DataTypeDateTime64;
-};
-
 void registerFromUnixTimestamp64Nano(FunctionFactory & factory)
 {
-    factory.registerFunction<FunctionUnixTimestamp64<TransformFromNano>>();
+    factory.registerFunction("fromUnixTimestamp64Nano",
+        [](ContextPtr){ return std::make_unique<DefaultOverloadResolver>(
+            std::make_shared<FunctionFromUnixTimestamp64>(9, "fromUnixTimestamp64Nano")); });
 }
 
 }
diff --git a/src/Functions/gcd.cpp b/src/Functions/gcd.cpp
index 52addfc66ed..f42f8f96cdb 100644
--- a/src/Functions/gcd.cpp
+++ b/src/Functions/gcd.cpp
@@ -2,6 +2,8 @@
 #include <Functions/FunctionBinaryArithmetic.h>
 #include <Functions/GCDLCMImpl.h>
 
+#include <boost/integer/common_factor.hpp>
+
 
 namespace DB
 {
@@ -19,7 +21,7 @@ struct GCDImpl : public GCDLCMImpl<A, B, GCDImpl<A, B>, NameGCD>
     static ResultType applyImpl(A a, B b)
     {
         using Int = typename NumberTraits::ToInteger<ResultType>::Type;
-        return std::gcd(Int(a), Int(b));
+        return boost::integer::gcd(Int(a), Int(b));
     }
 };
 
diff --git a/src/Functions/generateUUIDv4.cpp b/src/Functions/generateUUIDv4.cpp
index a1e50e3c54f..7ca127857df 100644
--- a/src/Functions/generateUUIDv4.cpp
+++ b/src/Functions/generateUUIDv4.cpp
@@ -32,21 +32,22 @@ public:
 
     ColumnPtr executeImpl(const ColumnsWithTypeAndName &, const DataTypePtr &, size_t input_rows_count) const override
     {
-        auto col_res = ColumnVector<UInt128>::create();
-        typename ColumnVector<UInt128>::Container & vec_to = col_res->getData();
+        auto col_res = ColumnVector<UUID>::create();
+        typename ColumnVector<UUID>::Container & vec_to = col_res->getData();
 
         size_t size = input_rows_count;
         vec_to.resize(size);
 
         /// RandImpl is target-dependent and is not the same in different TargetSpecific namespaces.
-        RandImpl::execute(reinterpret_cast<char *>(vec_to.data()), vec_to.size() * sizeof(UInt128));
+        RandImpl::execute(reinterpret_cast<char *>(vec_to.data()), vec_to.size() * sizeof(UUID));
 
-        for (UInt128 & uuid: vec_to)
+        for (UUID & uuid : vec_to)
         {
-            /** https://tools.ietf.org/html/rfc4122#section-4.4
-             */
-            uuid.low = (uuid.low & 0xffffffffffff0fffull) | 0x0000000000004000ull;
-            uuid.high = (uuid.high & 0x3fffffffffffffffull) | 0x8000000000000000ull;
+            /// https://tools.ietf.org/html/rfc4122#section-4.4
+
+            UInt128 & impl = uuid.toUnderType();
+            impl.items[0] = (impl.items[0] & 0xffffffffffff0fffull) | 0x0000000000004000ull;
+            impl.items[1] = (impl.items[1] & 0x3fffffffffffffffull) | 0x8000000000000000ull;
         }
 
         return col_res;
diff --git a/src/Functions/greatCircleDistance.cpp b/src/Functions/greatCircleDistance.cpp
index 93ec7c9de4c..095edd25e40 100644
--- a/src/Functions/greatCircleDistance.cpp
+++ b/src/Functions/greatCircleDistance.cpp
@@ -187,8 +187,8 @@ float distance(float lon1deg, float lat1deg, float lon2deg, float lat2deg)
 
         /// This is linear interpolation between two table items at index "latitude_midpoint_index" and "latitude_midpoint_index + 1".
 
-        float k_lat;
-        float k_lon;
+        float k_lat{};
+        float k_lon{};
 
         if constexpr (method == Method::SPHERE_DEGREES)
         {
diff --git a/src/Functions/greatest.cpp b/src/Functions/greatest.cpp
index 56b5630b6bc..9fda95db01f 100644
--- a/src/Functions/greatest.cpp
+++ b/src/Functions/greatest.cpp
@@ -26,10 +26,13 @@ struct GreatestBaseImpl
     static inline llvm::Value * compile(llvm::IRBuilder<> & b, llvm::Value * left, llvm::Value * right, bool is_signed)
     {
         if (!left->getType()->isIntegerTy())
-            /// XXX maxnum is basically fmax(), it may or may not match whatever apply() does
-            /// XXX CreateMaxNum is broken on LLVM 5.0 and 6.0 (generates minnum instead; fixed in 7)
-            return b.CreateBinaryIntrinsic(llvm::Intrinsic::maxnum, left, right);
-        return b.CreateSelect(is_signed ? b.CreateICmpSGT(left, right) : b.CreateICmpUGT(left, right), left, right);
+        {
+            /// Follows the IEEE-754 semantics for maxNum except for the handling of signaling NaNs. This matches the behavior of libc fmax.
+            return b.CreateMaxNum(left, right);
+        }
+
+        auto * compare_value = is_signed ? b.CreateICmpSGT(left, right) : b.CreateICmpUGT(left, right);
+        return b.CreateSelect(compare_value, left, right);
     }
 #endif
 };
diff --git a/src/Functions/hasColumnInTable.cpp b/src/Functions/hasColumnInTable.cpp
index 28f83a63386..6f34082a87d 100644
--- a/src/Functions/hasColumnInTable.cpp
+++ b/src/Functions/hasColumnInTable.cpp
@@ -134,7 +134,7 @@ ColumnPtr FunctionHasColumnInTable::executeImpl(const ColumnsWithTypeAndName & a
         has_column = remote_columns.hasPhysical(column_name);
     }
 
-    return DataTypeUInt8().createColumnConst(input_rows_count, Field(has_column));
+    return DataTypeUInt8().createColumnConst(input_rows_count, Field{UInt64(has_column)});
 }
 
 }
diff --git a/src/Functions/if.cpp b/src/Functions/if.cpp
index 4883b827d7d..e1acd830dcb 100644
--- a/src/Functions/if.cpp
+++ b/src/Functions/if.cpp
@@ -169,7 +169,7 @@ public:
 };
 
 
-class FunctionIf : public FunctionIfBase</*null_is_false=*/false>
+class FunctionIf : public FunctionIfBase
 {
 public:
     static constexpr auto name = "if";
@@ -986,7 +986,7 @@ public:
             right_id = right_array->getNestedType()->getTypeId();
 
         if (!(callOnBasicTypes<true, true, true, false>(left_id, right_id, call)
-            || (res = executeTyped<UInt128, UInt128>(cond_col, arguments, result_type, input_rows_count))
+            || (res = executeTyped<UUID, UUID>(cond_col, arguments, result_type, input_rows_count))
             || (res = executeString(cond_col, arguments, result_type))
             || (res = executeGenericArray(cond_col, arguments, result_type))
             || (res = executeTuple(arguments, result_type, input_rows_count))))
diff --git a/src/Functions/isDecimalOverflow.cpp b/src/Functions/isDecimalOverflow.cpp
index 16d6752e6a5..ed69f28711f 100644
--- a/src/Functions/isDecimalOverflow.cpp
+++ b/src/Functions/isDecimalOverflow.cpp
@@ -85,7 +85,7 @@ public:
 
         auto result_column = ColumnUInt8::create();
 
-        auto call = [&](const auto & types) -> bool
+        auto call = [&](const auto & types) -> bool //-V657
         {
             using Types = std::decay_t<decltype(types)>;
             using Type = typename Types::RightType;
diff --git a/src/Functions/isValidUTF8.cpp b/src/Functions/isValidUTF8.cpp
index d8c5d3cc580..e3158bb709c 100644
--- a/src/Functions/isValidUTF8.cpp
+++ b/src/Functions/isValidUTF8.cpp
@@ -277,7 +277,7 @@ SOFTWARE.
             len -= 16;
         };
 
-        while (len >= 16) // NOLINT
+        while (len >= 16) // NOLINT //-V1044
             check_packed(_mm_loadu_si128(reinterpret_cast<const __m128i *>(data)));
 
         /// 0 <= len <= 15 for now. Reading data from data - 1 because of right padding of 15 and left padding
diff --git a/src/Functions/lcm.cpp b/src/Functions/lcm.cpp
index f46e11dfa17..672d47d06b9 100644
--- a/src/Functions/lcm.cpp
+++ b/src/Functions/lcm.cpp
@@ -2,6 +2,9 @@
 #include <Functions/FunctionBinaryArithmetic.h>
 #include <Functions/GCDLCMImpl.h>
 
+#include <boost/integer/common_factor.hpp>
+
+
 namespace
 {
 
@@ -46,7 +49,7 @@ struct LCMImpl : public GCDLCMImpl<A, B, LCMImpl<A, B>, NameLCM>
           * (example: throw an exception or overflow in implementation specific way).
           */
 
-        Unsigned val1 = abs<Int>(a) / std::gcd(Int(a), Int(b));
+        Unsigned val1 = abs<Int>(a) / boost::integer::gcd(Int(a), Int(b));
         Unsigned val2 = abs<Int>(b);
 
         /// Overflow in implementation specific way.
diff --git a/src/Functions/least.cpp b/src/Functions/least.cpp
index ba87e4bd7e4..6ba7989a344 100644
--- a/src/Functions/least.cpp
+++ b/src/Functions/least.cpp
@@ -26,9 +26,13 @@ struct LeastBaseImpl
     static inline llvm::Value * compile(llvm::IRBuilder<> & b, llvm::Value * left, llvm::Value * right, bool is_signed)
     {
         if (!left->getType()->isIntegerTy())
-            /// XXX minnum is basically fmin(), it may or may not match whatever apply() does
+        {
+            /// Follows the IEEE-754 semantics for minNum, except for handling of signaling NaNs. This match’s the behavior of libc fmin.
             return b.CreateMinNum(left, right);
-        return b.CreateSelect(is_signed ? b.CreateICmpSLT(left, right) : b.CreateICmpULT(left, right), left, right);
+        }
+
+        auto * compare_value = is_signed ? b.CreateICmpSLT(left, right) : b.CreateICmpULT(left, right);
+        return b.CreateSelect(compare_value, left, right);
     }
 #endif
 };
diff --git a/src/Functions/multiIf.cpp b/src/Functions/multiIf.cpp
index d9be4512851..92f05df472b 100644
--- a/src/Functions/multiIf.cpp
+++ b/src/Functions/multiIf.cpp
@@ -31,7 +31,7 @@ namespace
 ///
 /// Additionally the arguments, conditions or branches, support nullable types
 /// and the NULL value, with a NULL condition treated as false.
-class FunctionMultiIf final : public FunctionIfBase</*null_is_false=*/true>
+class FunctionMultiIf final : public FunctionIfBase
 {
 public:
     static constexpr auto name = "multiIf";
diff --git a/src/Functions/neighbor.cpp b/src/Functions/neighbor.cpp
index e841fe9e79b..0de7c480b18 100644
--- a/src/Functions/neighbor.cpp
+++ b/src/Functions/neighbor.cpp
@@ -178,7 +178,7 @@ public:
 
             for (size_t row = 0; row < input_rows_count; ++row)
             {
-                Int64 offset = offset_column->getInt(offset_is_constant ? 0 : row);
+                Int64 offset = offset_column->getInt(row);
 
                 /// Protection from possible overflow.
                 if (unlikely(offset > (1 << 30) || offset < -(1 << 30)))
diff --git a/src/Functions/reinterpretAs.cpp b/src/Functions/reinterpretAs.cpp
index f8a7b8eec84..94c9eec5868 100644
--- a/src/Functions/reinterpretAs.cpp
+++ b/src/Functions/reinterpretAs.cpp
@@ -409,6 +409,7 @@ struct NameReinterpretAsUInt8       { static constexpr auto name = "reinterpretA
 struct NameReinterpretAsUInt16      { static constexpr auto name = "reinterpretAsUInt16"; };
 struct NameReinterpretAsUInt32      { static constexpr auto name = "reinterpretAsUInt32"; };
 struct NameReinterpretAsUInt64      { static constexpr auto name = "reinterpretAsUInt64"; };
+struct NameReinterpretAsUInt128     { static constexpr auto name = "reinterpretAsUInt128"; };
 struct NameReinterpretAsUInt256     { static constexpr auto name = "reinterpretAsUInt256"; };
 struct NameReinterpretAsInt8        { static constexpr auto name = "reinterpretAsInt8"; };
 struct NameReinterpretAsInt16       { static constexpr auto name = "reinterpretAsInt16"; };
@@ -428,6 +429,7 @@ using FunctionReinterpretAsUInt8 = FunctionReinterpretAs<DataTypeUInt8, NameRein
 using FunctionReinterpretAsUInt16 = FunctionReinterpretAs<DataTypeUInt16, NameReinterpretAsUInt16>;
 using FunctionReinterpretAsUInt32 = FunctionReinterpretAs<DataTypeUInt32, NameReinterpretAsUInt32>;
 using FunctionReinterpretAsUInt64 = FunctionReinterpretAs<DataTypeUInt64, NameReinterpretAsUInt64>;
+using FunctionReinterpretAsUInt128 = FunctionReinterpretAs<DataTypeUInt128, NameReinterpretAsUInt128>;
 using FunctionReinterpretAsUInt256 = FunctionReinterpretAs<DataTypeUInt256, NameReinterpretAsUInt256>;
 using FunctionReinterpretAsInt8 = FunctionReinterpretAs<DataTypeInt8, NameReinterpretAsInt8>;
 using FunctionReinterpretAsInt16 = FunctionReinterpretAs<DataTypeInt16, NameReinterpretAsInt16>;
@@ -453,6 +455,7 @@ void registerFunctionsReinterpretAs(FunctionFactory & factory)
     factory.registerFunction<FunctionReinterpretAsUInt16>();
     factory.registerFunction<FunctionReinterpretAsUInt32>();
     factory.registerFunction<FunctionReinterpretAsUInt64>();
+    factory.registerFunction<FunctionReinterpretAsUInt128>();
     factory.registerFunction<FunctionReinterpretAsUInt256>();
     factory.registerFunction<FunctionReinterpretAsInt8>();
     factory.registerFunction<FunctionReinterpretAsInt16>();
diff --git a/src/Functions/roundToExp2.cpp b/src/Functions/roundToExp2.cpp
index 50a548e095e..2abe94b2b26 100644
--- a/src/Functions/roundToExp2.cpp
+++ b/src/Functions/roundToExp2.cpp
@@ -27,18 +27,6 @@ roundDownToPowerOfTwo(T x)
     return x <= 0 ? 0 : (T(1) << (63 - __builtin_clzll(x)));
 }
 
-template <typename T>
-inline std::enable_if_t<std::is_same_v<T, Int128>, T>
-roundDownToPowerOfTwo(T x)
-{
-    if (x <= 0)
-        return 0;
-
-    if (Int64 x64 = Int64(x >> 64))
-        return Int128(roundDownToPowerOfTwo(x64)) << 64;
-    return roundDownToPowerOfTwo(Int64(x));
-}
-
 template <typename T>
 inline std::enable_if_t<std::is_same_v<T, Float32>, T>
 roundDownToPowerOfTwo(T x)
diff --git a/src/Functions/runningAccumulate.cpp b/src/Functions/runningAccumulate.cpp
index 7c1b1f7162e..0fe354e30c0 100644
--- a/src/Functions/runningAccumulate.cpp
+++ b/src/Functions/runningAccumulate.cpp
@@ -120,8 +120,8 @@ public:
                     state_created = false;
                 }
 
-                agg_func.create(place.data());
-                state_created = true;
+                agg_func.create(place.data()); /// This function can throw.
+                state_created = true; //-V519
             }
 
             agg_func.merge(place.data(), state_to_add, arena.get());
diff --git a/src/Functions/sign.cpp b/src/Functions/sign.cpp
index 3c03f4e1f2e..8e2964c1859 100644
--- a/src/Functions/sign.cpp
+++ b/src/Functions/sign.cpp
@@ -1,7 +1,7 @@
 #include <Functions/FunctionFactory.h>
 #include <Functions/FunctionUnaryArithmetic.h>
 #include <DataTypes/NumberTraits.h>
-#include <Common/FieldVisitors.h>
+
 
 namespace DB
 {
diff --git a/src/Functions/toUnixTimestamp64Micro.cpp b/src/Functions/toUnixTimestamp64Micro.cpp
index e1a9382e69a..f91f04dc519 100644
--- a/src/Functions/toUnixTimestamp64Micro.cpp
+++ b/src/Functions/toUnixTimestamp64Micro.cpp
@@ -3,22 +3,12 @@
 
 namespace DB
 {
-namespace
-{
-
-struct TransformToMicro
-{
-    static constexpr auto name = "toUnixTimestamp64Micro";
-    static constexpr auto target_scale = 6;
-    using SourceDataType = DataTypeDateTime64;
-    using ResultDataType = DataTypeInt64;
-};
-
-}
 
 void registerToUnixTimestamp64Micro(FunctionFactory & factory)
 {
-    factory.registerFunction<FunctionUnixTimestamp64<TransformToMicro>>();
+    factory.registerFunction("toUnixTimestamp64Micro",
+        [](ContextPtr){ return std::make_unique<DefaultOverloadResolver>(
+            std::make_shared<FunctionToUnixTimestamp64>(6, "toUnixTimestamp64Micro")); });
 }
 
 }
diff --git a/src/Functions/toUnixTimestamp64Milli.cpp b/src/Functions/toUnixTimestamp64Milli.cpp
index b49b1c9042b..857ce973c56 100644
--- a/src/Functions/toUnixTimestamp64Milli.cpp
+++ b/src/Functions/toUnixTimestamp64Milli.cpp
@@ -3,22 +3,12 @@
 
 namespace DB
 {
-namespace
-{
-
-struct TransformToMilli
-{
-    static constexpr auto name = "toUnixTimestamp64Milli";
-    static constexpr auto target_scale = 3;
-    using SourceDataType = DataTypeDateTime64;
-    using ResultDataType = DataTypeInt64;
-};
-
-}
 
 void registerToUnixTimestamp64Milli(FunctionFactory & factory)
 {
-    factory.registerFunction<FunctionUnixTimestamp64<TransformToMilli>>();
+    factory.registerFunction("toUnixTimestamp64Milli",
+        [](ContextPtr){ return std::make_unique<DefaultOverloadResolver>(
+            std::make_shared<FunctionToUnixTimestamp64>(3, "toUnixTimestamp64Milli")); });
 }
 
 }
diff --git a/src/Functions/toUnixTimestamp64Nano.cpp b/src/Functions/toUnixTimestamp64Nano.cpp
index 832d845434c..7f065568f9f 100644
--- a/src/Functions/toUnixTimestamp64Nano.cpp
+++ b/src/Functions/toUnixTimestamp64Nano.cpp
@@ -3,22 +3,12 @@
 
 namespace DB
 {
-namespace
-{
-
-struct TransformToNano
-{
-    static constexpr auto name = "toUnixTimestamp64Nano";
-    static constexpr auto target_scale = 9;
-    using SourceDataType = DataTypeDateTime64;
-    using ResultDataType = DataTypeInt64;
-};
-
-}
 
 void registerToUnixTimestamp64Nano(FunctionFactory & factory)
 {
-    factory.registerFunction<FunctionUnixTimestamp64<TransformToNano>>();
+    factory.registerFunction("toUnixTimestamp64Nano",
+        [](ContextPtr){ return std::make_unique<DefaultOverloadResolver>(
+            std::make_shared<FunctionToUnixTimestamp64>(9, "toUnixTimestamp64Nano")); });
 }
 
 }
diff --git a/src/IO/CompressionMethod.cpp b/src/IO/CompressionMethod.cpp
index 6e437e34c10..c6bb5232c0c 100644
--- a/src/IO/CompressionMethod.cpp
+++ b/src/IO/CompressionMethod.cpp
@@ -46,7 +46,6 @@ std::string toContentEncodingName(CompressionMethod method)
     __builtin_unreachable();
 }
 
-
 CompressionMethod chooseCompressionMethod(const std::string & path, const std::string & hint)
 {
     std::string file_extension;
diff --git a/src/IO/MMappedFileCache.h b/src/IO/MMappedFileCache.h
index cbd1977350b..adbb85a18cf 100644
--- a/src/IO/MMappedFileCache.h
+++ b/src/IO/MMappedFileCache.h
@@ -1,8 +1,9 @@
 #pragma once
 
+#include <Core/Types.h>
+#include <Common/HashTable/Hash.h>
 #include <Common/LRUCache.h>
 #include <Common/SipHash.h>
-#include <Common/UInt128.h>
 #include <Common/ProfileEvents.h>
 #include <IO/MMappedFile.h>
 
@@ -39,8 +40,7 @@ public:
         hash.update(offset);
         hash.update(length);
 
-        hash.get128(key.low, key.high);
-
+        hash.get128(key);
         return key;
     }
 
diff --git a/src/IO/MySQLBinlogEventReadBuffer.h b/src/IO/MySQLBinlogEventReadBuffer.h
index d31e19d82b8..7212a548844 100644
--- a/src/IO/MySQLBinlogEventReadBuffer.h
+++ b/src/IO/MySQLBinlogEventReadBuffer.h
@@ -11,11 +11,11 @@ protected:
     static const size_t MAX_CHECKSUM_SIGNATURE_LENGTH = 4;
 
     ReadBuffer & in;
-    size_t checksum_signature_length;
+    size_t checksum_signature_length = 0;
 
     size_t checksum_buff_size = 0;
     size_t checksum_buff_limit = 0;
-    char checksum_buf[MAX_CHECKSUM_SIGNATURE_LENGTH];
+    char checksum_buf[MAX_CHECKSUM_SIGNATURE_LENGTH]{};
 
     bool nextImpl() override;
 
diff --git a/src/IO/ReadBufferAIO.cpp b/src/IO/ReadBufferAIO.cpp
index 39e3c26826a..c064e0d4ed9 100644
--- a/src/IO/ReadBufferAIO.cpp
+++ b/src/IO/ReadBufferAIO.cpp
@@ -106,7 +106,7 @@ bool ReadBufferAIO::nextImpl()
         ProfileInfo info;
         info.bytes_requested = requested_byte_count;
         info.bytes_read = bytes_read;
-        info.nanoseconds = watch->elapsed();
+        info.nanoseconds = watch->elapsed(); //-V1007
         profile_callback(info);
     }
 
diff --git a/src/IO/ReadHelpers.cpp b/src/IO/ReadHelpers.cpp
index 72ffd74a42d..8e9a14a20fb 100644
--- a/src/IO/ReadHelpers.cpp
+++ b/src/IO/ReadHelpers.cpp
@@ -81,11 +81,6 @@ void parseUUIDWithoutSeparator(const UInt8 * src36, std::reverse_iterator<UInt8
     parseHex(&src36[16], dst16, 8);
 }
 
-UInt128 stringToUUID(const String & str)
-{
-    return parseFromString<UUID>(str);
-}
-
 void NO_INLINE throwAtAssertionFailed(const char * s, ReadBuffer & buf)
 {
     WriteBufferFromOwnString out;
diff --git a/src/IO/ReadHelpers.h b/src/IO/ReadHelpers.h
index cf25b819e6c..9003ec2d9ed 100644
--- a/src/IO/ReadHelpers.h
+++ b/src/IO/ReadHelpers.h
@@ -21,7 +21,6 @@
 #include <Common/Exception.h>
 #include <Common/StringUtils/StringUtils.h>
 #include <Common/Arena.h>
-#include <Common/UInt128.h>
 #include <Common/intExp.h>
 
 #include <Formats/FormatSettings.h>
@@ -51,7 +50,6 @@ namespace ErrorCodes
     extern const int CANNOT_PARSE_UUID;
     extern const int CANNOT_READ_ARRAY_FROM_TEXT;
     extern const int CANNOT_PARSE_NUMBER;
-    extern const int ILLEGAL_TYPE_OF_ARGUMENT;
     extern const int INCORRECT_DATA;
 }
 
@@ -257,13 +255,12 @@ enum class ReadIntTextCheckOverflow
 template <typename T, typename ReturnType = void, ReadIntTextCheckOverflow check_overflow = ReadIntTextCheckOverflow::DO_NOT_CHECK_OVERFLOW>
 ReturnType readIntTextImpl(T & x, ReadBuffer & buf)
 {
-    /// TODO: disabled for big ints cause of 127 vs 128 bit conversion
-    using UnsignedT = std::conditional_t<is_big_int_v<T>, T, make_unsigned_t<T>>;
+    using UnsignedT = make_unsigned_t<T>;
 
     static constexpr bool throw_exception = std::is_same_v<ReturnType, void>;
 
     bool negative = false;
-    UnsignedT res = 0;
+    UnsignedT res{};
     if (buf.eof())
     {
         if constexpr (throw_exception)
@@ -305,7 +302,7 @@ ReturnType readIntTextImpl(T & x, ReadBuffer & buf)
             case '8': [[fallthrough]];
             case '9':
             {
-                if constexpr (check_overflow == ReadIntTextCheckOverflow::CHECK_OVERFLOW)
+                if constexpr (check_overflow == ReadIntTextCheckOverflow::CHECK_OVERFLOW && !is_big_int_v<T>)
                 {
                     /// Perform relativelly slow overflow check only when
                     /// number of decimal digits so far is close to the max for given type.
@@ -318,12 +315,8 @@ ReturnType readIntTextImpl(T & x, ReadBuffer & buf)
                             || common::addOverflow<T>(signed_res, (*buf.position() - '0'), signed_res))
                             return ReturnType(false);
 
-                        /// Cannot assign signed to unsigned for big ints. Ignore fast path.
-                        if constexpr (!is_big_int_v<T>)
-                        {
-                            res = signed_res;
-                            break;
-                        }
+                        res = signed_res;
+                        break;
                     }
                 }
                 res *= 10;
@@ -535,9 +528,6 @@ void parseUUIDWithoutSeparator(const UInt8 * src36, UInt8 * dst16);
 void parseUUID(const UInt8 * src36, std::reverse_iterator<UInt8 *> dst16);
 void parseUUIDWithoutSeparator(const UInt8 * src36, std::reverse_iterator<UInt8 *> dst16);
 
-template <typename IteratorSrc, typename IteratorDst>
-void formatHex(IteratorSrc src, IteratorDst dst, size_t num_bytes);
-
 
 template <typename ReturnType>
 ReturnType readDateTextFallback(LocalDate & date, ReadBuffer & buf);
@@ -686,13 +676,6 @@ inline T parseFromString(const std::string_view & str)
     return parse<T>(str.data(), str.size());
 }
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wredundant-decls"
-// Just dont mess with it. If the redundant redeclaration is removed then ReaderHelpers.h should be included.
-// This leads to Arena.h inclusion which has a problem with ASAN stuff included properly and messing macro definition
-// which intefrers with... You dont want to know, really.
-UInt128 stringToUUID(const String & str);
-#pragma GCC diagnostic pop
 
 template <typename ReturnType = void>
 ReturnType readDateTimeTextFallback(time_t & datetime, ReadBuffer & buf, const DateLUTImpl & date_lut);
@@ -839,16 +822,15 @@ readBinary(T & x, ReadBuffer & buf) { readPODBinary(x, buf); }
 
 inline void readBinary(String & x, ReadBuffer & buf) { readStringBinary(x, buf); }
 inline void readBinary(Int128 & x, ReadBuffer & buf) { readPODBinary(x, buf); }
+inline void readBinary(Int256 & x, ReadBuffer & buf) { readPODBinary(x, buf); }
 inline void readBinary(UInt128 & x, ReadBuffer & buf) { readPODBinary(x, buf); }
-inline void readBinary(DummyUInt256 & x, ReadBuffer & buf) { readPODBinary(x, buf); }
+inline void readBinary(UInt256 & x, ReadBuffer & buf) { readPODBinary(x, buf); }
 inline void readBinary(Decimal32 & x, ReadBuffer & buf) { readPODBinary(x, buf); }
 inline void readBinary(Decimal64 & x, ReadBuffer & buf) { readPODBinary(x, buf); }
 inline void readBinary(Decimal128 & x, ReadBuffer & buf) { readPODBinary(x, buf); }
 inline void readBinary(Decimal256 & x, ReadBuffer & buf) { readPODBinary(x.value, buf); }
 inline void readBinary(LocalDate & x, ReadBuffer & buf) { readPODBinary(x, buf); }
 
-inline void readBinary(UInt256 & x, ReadBuffer & buf) { readPODBinary(x, buf); }
-inline void readBinary(Int256 & x, ReadBuffer & buf) { readPODBinary(x, buf); }
 
 template <typename T>
 inline std::enable_if_t<is_arithmetic_v<T> && (sizeof(T) <= 8), void>
@@ -889,13 +871,6 @@ inline void readText(String & x, ReadBuffer & buf) { readEscapedString(x, buf);
 inline void readText(LocalDate & x, ReadBuffer & buf) { readDateText(x, buf); }
 inline void readText(LocalDateTime & x, ReadBuffer & buf) { readDateTimeText(x, buf); }
 inline void readText(UUID & x, ReadBuffer & buf) { readUUIDText(x, buf); }
-[[noreturn]] inline void readText(UInt128 &, ReadBuffer &)
-{
-    /** Because UInt128 isn't a natural type, without arithmetic operator and only use as an intermediary type -for UUID-
-     *  it should never arrive here. But because we used the DataTypeNumber class we should have at least a definition of it.
-     */
-    throw Exception("UInt128 cannot be read as a text", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
-}
 
 /// Generic methods to read value in text format,
 ///  possibly in single quotes (only for data types that use quotes in VALUES format of INSERT statement in SQL).
@@ -975,13 +950,8 @@ inline void readCSV(String & x, ReadBuffer & buf, const FormatSettings::CSV & se
 inline void readCSV(LocalDate & x, ReadBuffer & buf) { readCSVSimple(x, buf); }
 inline void readCSV(LocalDateTime & x, ReadBuffer & buf) { readCSVSimple(x, buf); }
 inline void readCSV(UUID & x, ReadBuffer & buf) { readCSVSimple(x, buf); }
-[[noreturn]] inline void readCSV(UInt128 &, ReadBuffer &)
-{
-    /** Because UInt128 isn't a natural type, without arithmetic operator and only use as an intermediary type -for UUID-
-     *  it should never arrive here. But because we used the DataTypeNumber class we should have at least a definition of it.
-     */
-    throw Exception("UInt128 cannot be read as a text", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
-}
+inline void readCSV(UInt128 & x, ReadBuffer & buf) { readCSVSimple(x, buf); }
+inline void readCSV(Int128 & x, ReadBuffer & buf) { readCSVSimple(x, buf); }
 inline void readCSV(UInt256 & x, ReadBuffer & buf) { readCSVSimple(x, buf); }
 inline void readCSV(Int256 & x, ReadBuffer & buf) { readCSVSimple(x, buf); }
 
diff --git a/src/IO/ReadWriteBufferFromHTTP.h b/src/IO/ReadWriteBufferFromHTTP.h
index 9cd37bd00f8..2f0d598cd6e 100644
--- a/src/IO/ReadWriteBufferFromHTTP.h
+++ b/src/IO/ReadWriteBufferFromHTTP.h
@@ -92,6 +92,7 @@ namespace detail
     protected:
         Poco::URI uri;
         std::string method;
+        std::string content_encoding;
 
         UpdatableSessionPtr session;
         std::istream * istr; /// owned by session
@@ -137,6 +138,7 @@ namespace detail
                 istr = receiveResponse(*sess, request, response, true);
                 response.getCookies(cookies);
 
+                content_encoding = response.get("Content-Encoding", "");
                 return istr;
 
             }
@@ -230,6 +232,11 @@ namespace detail
             /// Some data maybe already read
             next_callback(count());
         }
+
+        const std::string & getCompressionMethod() const
+        {
+            return content_encoding;
+        }
     };
 }
 
diff --git a/src/IO/S3/PocoHTTPClient.cpp b/src/IO/S3/PocoHTTPClient.cpp
index 6df8d5ec5ad..f2b5c77a6c1 100644
--- a/src/IO/S3/PocoHTTPClient.cpp
+++ b/src/IO/S3/PocoHTTPClient.cpp
@@ -47,9 +47,11 @@ namespace DB::S3
 {
 
 PocoHTTPClientConfiguration::PocoHTTPClientConfiguration(
+        const String & force_region_,
         const RemoteHostFilter & remote_host_filter_,
         unsigned int s3_max_redirects_)
-    : remote_host_filter(remote_host_filter_)
+    : force_region(force_region_)
+    , remote_host_filter(remote_host_filter_)
     , s3_max_redirects(s3_max_redirects_)
 {
 }
@@ -63,15 +65,23 @@ void PocoHTTPClientConfiguration::updateSchemeAndRegion()
         if (uri.getScheme() == "http")
             scheme = Aws::Http::Scheme::HTTP;
 
-        String matched_region;
-        if (re2::RE2::PartialMatch(uri.getHost(), region_pattern, &matched_region))
+        if (force_region.empty())
         {
-            boost::algorithm::to_lower(matched_region);
-            region = matched_region;
+            String matched_region;
+            if (re2::RE2::PartialMatch(uri.getHost(), region_pattern, &matched_region))
+            {
+                boost::algorithm::to_lower(matched_region);
+                region = matched_region;
+            }
+            else
+            {
+                /// In global mode AWS C++ SDK send `us-east-1` but accept switching to another one if being suggested.
+                region = Aws::Region::AWS_GLOBAL;
+            }
         }
         else
         {
-            region = Aws::Region::AWS_GLOBAL;
+            region = force_region;
         }
     }
 }
@@ -176,7 +186,32 @@ void PocoHTTPClient::makeRequestInternal(
 
             Poco::Net::HTTPRequest poco_request(Poco::Net::HTTPRequest::HTTP_1_1);
 
-            poco_request.setURI(target_uri.getPathAndQuery());
+            /** Aws::Http::URI will encode URL in appropriate way for AWS S3 server.
+              * Poco::URI also does that correctly but it's not compatible with AWS.
+              * For example, `+` symbol will not be converted to `%2B` by Poco and would
+              * be received as space symbol.
+              *
+              * References:
+              * https://github.com/aws/aws-sdk-java/issues/1946
+              * https://forums.aws.amazon.com/thread.jspa?threadID=55746
+              *
+              * Example:
+              * Suppose we are requesting a file: abc+def.txt
+              * To correctly do it, we need to construct an URL containing either:
+              * - abc%2Bdef.txt
+              * this is also technically correct:
+              * - abc+def.txt
+              * but AWS servers don't support it properly, interpreting plus character as whitespace
+              * although it is in path part, not in query string.
+              * e.g. this is not correct:
+              * - abc%20def.txt
+              *
+              * Poco will keep plus character as is (which is correct) while AWS servers will treat it as whitespace, which is not what is intended.
+              * To overcome this limitation, we encode URL with "Aws::Http::URI" and then pass already prepared URL to Poco.
+              */
+
+            Aws::Http::URI aws_target_uri(uri);
+            poco_request.setURI(aws_target_uri.GetPath() + aws_target_uri.GetQueryString());
 
             switch (request.GetMethod())
             {
diff --git a/src/IO/S3/PocoHTTPClient.h b/src/IO/S3/PocoHTTPClient.h
index 34b8ea801bd..a3e10494284 100644
--- a/src/IO/S3/PocoHTTPClient.h
+++ b/src/IO/S3/PocoHTTPClient.h
@@ -29,13 +29,14 @@ class ClientFactory;
 
 struct PocoHTTPClientConfiguration : public Aws::Client::ClientConfiguration
 {
+    String force_region;
     const RemoteHostFilter & remote_host_filter;
     unsigned int s3_max_redirects;
 
     void updateSchemeAndRegion();
 
 private:
-    PocoHTTPClientConfiguration(const RemoteHostFilter & remote_host_filter_, unsigned int s3_max_redirects_);
+    PocoHTTPClientConfiguration(const String & force_region_, const RemoteHostFilter & remote_host_filter_, unsigned int s3_max_redirects_);
 
     /// Constructor of Aws::Client::ClientConfiguration must be called after AWS SDK initialization.
     friend ClientFactory;
diff --git a/src/IO/S3Common.cpp b/src/IO/S3Common.cpp
index 8e93c375573..ff9eafc9bc7 100644
--- a/src/IO/S3Common.cpp
+++ b/src/IO/S3Common.cpp
@@ -410,7 +410,7 @@ public:
             }
             else if (Aws::Utils::StringUtils::ToLower(ec2_metadata_disabled.c_str()) != "true")
             {
-                DB::S3::PocoHTTPClientConfiguration aws_client_configuration = DB::S3::ClientFactory::instance().createClientConfiguration(configuration.remote_host_filter, configuration.s3_max_redirects);
+                DB::S3::PocoHTTPClientConfiguration aws_client_configuration = DB::S3::ClientFactory::instance().createClientConfiguration(configuration.region, configuration.remote_host_filter, configuration.s3_max_redirects);
 
                 /// See MakeDefaultHttpResourceClientConfiguration().
                 /// This is part of EC2 metadata client, but unfortunately it can't be accessed from outside
@@ -590,10 +590,11 @@ namespace S3
     }
 
     PocoHTTPClientConfiguration ClientFactory::createClientConfiguration( // NOLINT
+        const String & force_region,
         const RemoteHostFilter & remote_host_filter,
         unsigned int s3_max_redirects)
     {
-        return PocoHTTPClientConfiguration(remote_host_filter, s3_max_redirects);
+        return PocoHTTPClientConfiguration(force_region, remote_host_filter, s3_max_redirects);
     }
 
     URI::URI(const Poco::URI & uri_)
diff --git a/src/IO/S3Common.h b/src/IO/S3Common.h
index 981218643ea..a2f5717941d 100644
--- a/src/IO/S3Common.h
+++ b/src/IO/S3Common.h
@@ -42,6 +42,7 @@ public:
         bool use_insecure_imds_request);
 
     PocoHTTPClientConfiguration createClientConfiguration(
+        const String & force_region,
         const RemoteHostFilter & remote_host_filter,
         unsigned int s3_max_redirects);
 
diff --git a/src/IO/UncompressedCache.h b/src/IO/UncompressedCache.h
index b2f62ef2ada..5826b7f020a 100644
--- a/src/IO/UncompressedCache.h
+++ b/src/IO/UncompressedCache.h
@@ -2,8 +2,8 @@
 
 #include <Common/LRUCache.h>
 #include <Common/SipHash.h>
-#include <Common/UInt128.h>
 #include <Common/ProfileEvents.h>
+#include <Common/HashTable/Hash.h>
 #include <IO/BufferWithOwnMemory.h>
 
 
@@ -53,7 +53,7 @@ public:
         SipHash hash;
         hash.update(path_to_file.data(), path_to_file.size() + 1);
         hash.update(offset);
-        hash.get128(key.low, key.high);
+        hash.get128(key);
 
         return key;
     }
diff --git a/src/IO/WriteHelpers.h b/src/IO/WriteHelpers.h
index 0f8b5adee1a..3a79951e144 100644
--- a/src/IO/WriteHelpers.h
+++ b/src/IO/WriteHelpers.h
@@ -6,12 +6,14 @@
 #include <algorithm>
 #include <iterator>
 
+#include <pcg-random/pcg_random.hpp>
+
 #include <common/DateLUT.h>
 #include <common/LocalDate.h>
 #include <common/LocalDateTime.h>
 #include <common/find_symbols.h>
 #include <common/StringRef.h>
-#include <common/wide_integer_to_string.h>
+#include <common/DecomposedFloat.h>
 
 #include <Core/DecimalFunctions.h>
 #include <Core/Types.h>
@@ -19,7 +21,6 @@
 
 #include <Common/Exception.h>
 #include <Common/StringUtils/StringUtils.h>
-#include <Common/UInt128.h>
 #include <Common/NaNUtils.h>
 
 #include <IO/CompressionMethod.h>
@@ -48,14 +49,8 @@ namespace DB
 namespace ErrorCodes
 {
     extern const int CANNOT_PRINT_FLOAT_OR_DOUBLE_NUMBER;
-    extern const int ILLEGAL_TYPE_OF_ARGUMENT;
 }
 
-template <typename T>
-inline std::string bigintToString(const T & x)
-{
-    return to_string(x);
-}
 
 /// Helper functions for formatted and binary output.
 
@@ -137,81 +132,6 @@ inline void writeBoolText(bool x, WriteBuffer & buf)
 }
 
 
-struct DecomposedFloat64
-{
-    DecomposedFloat64(double x)
-    {
-        memcpy(&x_uint, &x, sizeof(x));
-    }
-
-    uint64_t x_uint;
-
-    bool sign() const
-    {
-        return x_uint >> 63;
-    }
-
-    uint16_t exponent() const
-    {
-        return (x_uint >> 52) & 0x7FF;
-    }
-
-    int16_t normalized_exponent() const
-    {
-        return int16_t(exponent()) - 1023;
-    }
-
-    uint64_t mantissa() const
-    {
-        return x_uint & 0x5affffffffffffful;
-    }
-
-    /// NOTE Probably floating point instructions can be better.
-    bool is_inside_int64() const
-    {
-        return x_uint == 0
-            || (normalized_exponent() >= 0 && normalized_exponent() <= 52
-                && ((mantissa() & ((1ULL << (52 - normalized_exponent())) - 1)) == 0));
-    }
-};
-
-struct DecomposedFloat32
-{
-    DecomposedFloat32(float x)
-    {
-        memcpy(&x_uint, &x, sizeof(x));
-    }
-
-    uint32_t x_uint;
-
-    bool sign() const
-    {
-        return x_uint >> 31;
-    }
-
-    uint16_t exponent() const
-    {
-        return (x_uint >> 23) & 0xFF;
-    }
-
-    int16_t normalized_exponent() const
-    {
-        return int16_t(exponent()) - 127;
-    }
-
-    uint32_t mantissa() const
-    {
-        return x_uint & 0x7fffff;
-    }
-
-    bool is_inside_int32() const
-    {
-        return x_uint == 0
-            || (normalized_exponent() >= 0 && normalized_exponent() <= 23
-                && ((mantissa() & ((1ULL << (23 - normalized_exponent())) - 1)) == 0));
-    }
-};
-
 template <typename T>
 inline size_t writeFloatTextFastPath(T x, char * buffer)
 {
@@ -222,14 +142,14 @@ inline size_t writeFloatTextFastPath(T x, char * buffer)
         /// The library Ryu has low performance on integers.
         /// This workaround improves performance 6..10 times.
 
-        if (DecomposedFloat64(x).is_inside_int64())
+        if (DecomposedFloat64(x).is_integer_in_representable_range())
             result = itoa(Int64(x), buffer) - buffer;
         else
             result = jkj::dragonbox::to_chars_n(x, buffer) - buffer;
     }
     else
     {
-        if (DecomposedFloat32(x).is_inside_int32())
+        if (DecomposedFloat32(x).is_integer_in_representable_range())
             result = itoa(Int32(x), buffer) - buffer;
         else
             result = jkj::dragonbox::to_chars_n(x, buffer) - buffer;
@@ -742,13 +662,12 @@ void formatUUID(std::reverse_iterator<const UInt8 *> src16, UInt8 * dst36);
 inline void writeUUIDText(const UUID & uuid, WriteBuffer & buf)
 {
     char s[36];
-
     formatUUID(std::reverse_iterator<const UInt8 *>(reinterpret_cast<const UInt8 *>(&uuid) + 16), reinterpret_cast<UInt8 *>(s));
     buf.write(s, sizeof(s));
 }
 
-template<typename DecimalType>
-inline void writeDecimalTypeFractionalText(typename DecimalType::NativeType fractional, UInt32 scale, WriteBuffer & buf)
+template <typename DecimalType>
+inline void writeDateTime64FractionalText(typename DecimalType::NativeType fractional, UInt32 scale, WriteBuffer & buf)
 {
     static constexpr UInt32 MaxScale = DecimalUtils::max_precision<DecimalType>;
 
@@ -878,7 +797,7 @@ inline void writeDateTimeText(DateTime64 datetime64, UInt32 scale, WriteBuffer &
     if (scale > 0)
     {
         buf.write(fractional_time_delimiter);
-        writeDecimalTypeFractionalText<DateTime64>(components.fractional, scale, buf);
+        writeDateTime64FractionalText<DateTime64>(components.fractional, scale, buf);
     }
 }
 
@@ -931,7 +850,7 @@ inline void writeDateTimeUnixTimestamp(DateTime64 datetime64, UInt32 scale, Writ
     if (scale > 0) //-V547
     {
         buf.write('.');
-        writeDecimalTypeFractionalText<DateTime64>(components.fractional, scale, buf);
+        writeDateTime64FractionalText<DateTime64>(components.fractional, scale, buf);
     }
 }
 
@@ -943,23 +862,17 @@ writeBinary(const T & x, WriteBuffer & buf) { writePODBinary(x, buf); }
 inline void writeBinary(const String & x, WriteBuffer & buf) { writeStringBinary(x, buf); }
 inline void writeBinary(const StringRef & x, WriteBuffer & buf) { writeStringBinary(x, buf); }
 inline void writeBinary(const std::string_view & x, WriteBuffer & buf) { writeStringBinary(x, buf); }
-inline void writeBinary(const Int128 & x, WriteBuffer & buf) { writePODBinary(x, buf); }
-inline void writeBinary(const UInt128 & x, WriteBuffer & buf) { writePODBinary(x, buf); }
-inline void writeBinary(const UUID & x, WriteBuffer & buf) { writePODBinary(x, buf); }
-inline void writeBinary(const DummyUInt256 & x, WriteBuffer & buf) { writePODBinary(x, buf); }
 inline void writeBinary(const Decimal32 & x, WriteBuffer & buf) { writePODBinary(x, buf); }
 inline void writeBinary(const Decimal64 & x, WriteBuffer & buf) { writePODBinary(x, buf); }
 inline void writeBinary(const Decimal128 & x, WriteBuffer & buf) { writePODBinary(x, buf); }
 inline void writeBinary(const Decimal256 & x, WriteBuffer & buf) { writePODBinary(x.value, buf); }
 inline void writeBinary(const LocalDate & x, WriteBuffer & buf) { writePODBinary(x, buf); }
 inline void writeBinary(const LocalDateTime & x, WriteBuffer & buf) { writePODBinary(x, buf); }
-
-inline void writeBinary(const UInt256 & x, WriteBuffer & buf) { writePODBinary(x, buf); }
-inline void writeBinary(const Int256 & x, WriteBuffer & buf) { writePODBinary(x, buf); }
+inline void writeBinary(const UUID & x, WriteBuffer & buf) { writePODBinary(x, buf); }
 
 /// Methods for outputting the value in text form for a tab-separated format.
 template <typename T>
-inline std::enable_if_t<is_integer_v<T> && !is_big_int_v<T>, void>
+inline std::enable_if_t<is_integer_v<T>, void>
 writeText(const T & x, WriteBuffer & buf) { writeIntText(x, buf); }
 
 template <typename T>
@@ -980,23 +893,18 @@ inline void writeText(const DayNum & x, WriteBuffer & buf) { writeDateText(Local
 inline void writeText(const LocalDate & x, WriteBuffer & buf) { writeDateText(x, buf); }
 inline void writeText(const LocalDateTime & x, WriteBuffer & buf) { writeDateTimeText(x, buf); }
 inline void writeText(const UUID & x, WriteBuffer & buf) { writeUUIDText(x, buf); }
-inline void writeText(const UInt128 & x, WriteBuffer & buf) { writeText(UUID(x), buf); }
-inline void writeText(const UInt256 & x, WriteBuffer & buf) { writeText(bigintToString(x), buf); }
-inline void writeText(const Int256 & x, WriteBuffer & buf) { writeText(bigintToString(x), buf); }
 
 template <typename T>
 String decimalFractional(const T & x, UInt32 scale)
 {
     if constexpr (std::is_same_v<T, Int256>)
     {
-        static constexpr Int128 max_int128 = (Int128(0x7fffffffffffffffll) << 64) + 0xffffffffffffffffll;
-
         if (x <= std::numeric_limits<UInt32>::max())
             return decimalFractional(static_cast<UInt32>(x), scale);
         else if (x <= std::numeric_limits<UInt64>::max())
             return decimalFractional(static_cast<UInt64>(x), scale);
-        else if (x <= max_int128)
-            return decimalFractional(static_cast<Int128>(x), scale);
+        else if (x <= std::numeric_limits<UInt128>::max())
+            return decimalFractional(static_cast<UInt128>(x), scale);
     }
     else if constexpr (std::is_same_v<T, Int128>)
     {
@@ -1023,10 +931,7 @@ void writeText(Decimal<T> x, UInt32 scale, WriteBuffer & ostr)
         writeChar('-', ostr); /// avoid crop leading minus when whole part is zero
     }
 
-    if constexpr (std::is_same_v<T, Int256>)
-        writeText(part, ostr);
-    else
-        writeIntText(part, ostr);
+    writeIntText(part, ostr);
 
     if (scale)
     {
@@ -1069,19 +974,6 @@ inline void writeQuoted(const UUID & x, WriteBuffer & buf)
     writeChar('\'', buf);
 }
 
-inline void writeQuoted(const UInt256 & x, WriteBuffer & buf)
-{
-    writeChar('\'', buf);
-    writeText(x, buf);
-    writeChar('\'', buf);
-}
-
-inline void writeQuoted(const Int256 & x, WriteBuffer & buf)
-{
-    writeChar('\'', buf);
-    writeText(x, buf);
-    writeChar('\'', buf);
-}
 
 /// String, date, datetime are in double quotes with C-style escaping. Numbers - without.
 template <typename T>
@@ -1125,13 +1017,6 @@ inline void writeCSV(const String & x, WriteBuffer & buf) { writeCSVString<>(x,
 inline void writeCSV(const LocalDate & x, WriteBuffer & buf) { writeDoubleQuoted(x, buf); }
 inline void writeCSV(const LocalDateTime & x, WriteBuffer & buf) { writeDoubleQuoted(x, buf); }
 inline void writeCSV(const UUID & x, WriteBuffer & buf) { writeDoubleQuoted(x, buf); }
-[[noreturn]] inline void writeCSV(const UInt128, WriteBuffer &)
-{
-    /** Because UInt128 isn't a natural type, without arithmetic operator and only use as an intermediary type -for UUID-
-     *  it should never arrive here. But because we used the DataTypeNumber class we should have at least a definition of it.
-     */
-    throw Exception("UInt128 cannot be write as a text", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
-}
 
 template <typename T>
 void writeBinary(const std::vector<T> & x, WriteBuffer & buf)
diff --git a/src/IO/WriteIntText.h b/src/IO/WriteIntText.h
index 93444e7df73..456aed350fc 100644
--- a/src/IO/WriteIntText.h
+++ b/src/IO/WriteIntText.h
@@ -4,8 +4,24 @@
 #include <IO/WriteBuffer.h>
 #include <common/itoa.h>
 
-/// 40 digits or 39 digits and a sign
-#define WRITE_HELPERS_MAX_INT_WIDTH 40U
+
+namespace
+{
+    template <typename T> constexpr size_t max_int_width = 20;
+    template <> inline constexpr size_t max_int_width<UInt8> = 3;    /// 255
+    template <> inline constexpr size_t max_int_width<Int8> = 4;     /// -128
+    template <> inline constexpr size_t max_int_width<UInt16> = 5;   /// 65535
+    template <> inline constexpr size_t max_int_width<Int16> = 6;    /// -32768
+    template <> inline constexpr size_t max_int_width<UInt32> = 10;  /// 4294967295
+    template <> inline constexpr size_t max_int_width<Int32> = 11;   /// -2147483648
+    template <> inline constexpr size_t max_int_width<UInt64> = 20;  /// 18446744073709551615
+    template <> inline constexpr size_t max_int_width<Int64> = 20;   /// -9223372036854775808
+    template <> inline constexpr size_t max_int_width<UInt128> = 39; /// 340282366920938463463374607431768211455
+    template <> inline constexpr size_t max_int_width<Int128> = 40;  /// -170141183460469231731687303715884105728
+    template <> inline constexpr size_t max_int_width<UInt256> = 78; /// 115792089237316195423570985008687907853269984665640564039457584007913129639935
+    template <> inline constexpr size_t max_int_width<Int256> = 78;  /// -57896044618658097711785492504343953926634992332820282019728792003956564819968
+}
+
 
 namespace DB
 {
@@ -15,16 +31,16 @@ namespace detail
     template <typename T>
     void NO_INLINE writeUIntTextFallback(T x, WriteBuffer & buf)
     {
-        char tmp[WRITE_HELPERS_MAX_INT_WIDTH];
-        int len = itoa(x, tmp) - tmp;
-        buf.write(tmp, len);
+        char tmp[max_int_width<T>];
+        char * end = itoa(x, tmp);
+        buf.write(tmp, end - tmp);
     }
 }
 
 template <typename T>
 void writeIntText(T x, WriteBuffer & buf)
 {
-    if (likely(reinterpret_cast<intptr_t>(buf.position()) + WRITE_HELPERS_MAX_INT_WIDTH < reinterpret_cast<intptr_t>(buf.buffer().end())))
+    if (likely(reinterpret_cast<uintptr_t>(buf.position()) + max_int_width<T> < reinterpret_cast<uintptr_t>(buf.buffer().end())))
         buf.position() = itoa(x, buf.position());
     else
         detail::writeUIntTextFallback(x, buf);
diff --git a/src/IO/readDecimalText.h b/src/IO/readDecimalText.h
index 203d8e3963b..6545155aa6e 100644
--- a/src/IO/readDecimalText.h
+++ b/src/IO/readDecimalText.h
@@ -3,6 +3,7 @@
 #include <limits>
 #include <IO/ReadHelpers.h>
 #include <Common/intExp.h>
+#include <common/wide_integer_to_string.h>
 
 
 namespace DB
@@ -160,7 +161,7 @@ inline void readDecimalText(ReadBuffer & buf, T & x, uint32_t precision, uint32_
             " Expected to read decimal with scale {} and precision {}";
 
         if constexpr (is_big_int_v<typename T::NativeType>)
-            throw Exception(fmt::format(pattern, digits, bigintToString(x.value), exponent, scale, precision), ErrorCodes::ARGUMENT_OUT_OF_BOUND);
+            throw Exception(fmt::format(pattern, digits, x.value, exponent, scale, precision), ErrorCodes::ARGUMENT_OUT_OF_BOUND);
         else
             throw Exception(fmt::format(pattern, digits, x, exponent, scale, precision), ErrorCodes::ARGUMENT_OUT_OF_BOUND);
     }
diff --git a/src/IO/tests/gtest_cascade_and_memory_write_buffer.cpp b/src/IO/tests/gtest_cascade_and_memory_write_buffer.cpp
index d013077b7c2..656e40b2ad7 100644
--- a/src/IO/tests/gtest_cascade_and_memory_write_buffer.cpp
+++ b/src/IO/tests/gtest_cascade_and_memory_write_buffer.cpp
@@ -42,10 +42,9 @@ static void testCascadeBufferRedability(
         if (!wbuf)
             continue;
 
-        auto * wbuf_readable = dynamic_cast<IReadableWriteBuffer *>(wbuf.get());
-        ASSERT_FALSE(!wbuf_readable);
+        auto & wbuf_readable = dynamic_cast<IReadableWriteBuffer &>(*wbuf);
 
-        auto rbuf = wbuf_readable->tryGetReadBuffer();
+        auto rbuf = wbuf_readable.tryGetReadBuffer();
         ASSERT_FALSE(!rbuf);
 
         read_buffers.emplace_back(rbuf);
diff --git a/src/Interpreters/ActionsDAG.cpp b/src/Interpreters/ActionsDAG.cpp
index d9a8bfaf462..60aeef7ee59 100644
--- a/src/Interpreters/ActionsDAG.cpp
+++ b/src/Interpreters/ActionsDAG.cpp
@@ -681,9 +681,13 @@ std::string ActionsDAG::dumpDAG() const
         out << " " << (node.column ? node.column->getName() : "(no column)");
         out << " " << (node.result_type ? node.result_type->getName() : "(no type)");
         out << " " << (!node.result_name.empty() ? node.result_name : "(no name)");
+
         if (node.function_base)
             out << " [" << node.function_base->getName() << "]";
 
+        if (node.is_function_compiled)
+            out << " [compiled]";
+
         out << "\n";
     }
 
@@ -1195,10 +1199,9 @@ ActionsDAG::SplitResult ActionsDAG::split(std::unordered_set<const Node *> split
 
 ActionsDAG::SplitResult ActionsDAG::splitActionsBeforeArrayJoin(const NameSet & array_joined_columns) const
 {
-
     struct Frame
     {
-        const Node * node;
+        const Node * node = nullptr;
         size_t next_child_to_visit = 0;
     };
 
@@ -1294,7 +1297,7 @@ ConjunctionNodes getConjunctionNodes(ActionsDAG::Node * predicate, std::unordere
 
     struct Frame
     {
-        const ActionsDAG::Node * node;
+        const ActionsDAG::Node * node = nullptr;
         bool is_predicate = false;
         size_t next_child_to_visit = 0;
         size_t num_allowed_children = 0;
@@ -1410,7 +1413,7 @@ ActionsDAGPtr ActionsDAG::cloneActionsForConjunction(NodeRawConstPtrs conjunctio
 
     struct Frame
     {
-        const ActionsDAG::Node * node;
+        const ActionsDAG::Node * node = nullptr;
         size_t next_child_to_visit = 0;
     };
 
diff --git a/src/Interpreters/ActionsDAG.h b/src/Interpreters/ActionsDAG.h
index 645f1aaeeb7..049cce69da3 100644
--- a/src/Interpreters/ActionsDAG.h
+++ b/src/Interpreters/ActionsDAG.h
@@ -73,7 +73,7 @@ public:
     {
         NodeRawConstPtrs children;
 
-        ActionType type;
+        ActionType type{};
 
         std::string result_name;
         DataTypePtr result_type;
diff --git a/src/Interpreters/ActionsVisitor.cpp b/src/Interpreters/ActionsVisitor.cpp
index b7d679a81f1..b00c74601f1 100644
--- a/src/Interpreters/ActionsVisitor.cpp
+++ b/src/Interpreters/ActionsVisitor.cpp
@@ -205,7 +205,9 @@ static Block createBlockFromAST(const ASTPtr & node, const DataTypes & types, Co
                 tuple = &literal->value.get<Tuple>();
             }
 
-            size_t tuple_size = tuple ? tuple->size() : func->arguments->children.size();
+            assert(tuple || func);
+
+            size_t tuple_size = tuple ? tuple->size() : func->arguments->children.size(); //-V1004
             if (tuple_size != num_columns)
                 throw Exception("Incorrect size of tuple in set: " + toString(tuple_size) + " instead of " + toString(num_columns),
                     ErrorCodes::INCORRECT_ELEMENT_OF_SET);
diff --git a/src/Interpreters/AggregationCommon.h b/src/Interpreters/AggregationCommon.h
index 43b0671f661..dc94c2981b3 100644
--- a/src/Interpreters/AggregationCommon.h
+++ b/src/Interpreters/AggregationCommon.h
@@ -4,7 +4,6 @@
 
 #include <Common/SipHash.h>
 #include <Common/Arena.h>
-#include <Common/UInt128.h>
 #include <Common/HashTable/Hash.h>
 #include <Common/memcpySmall.h>
 #include <Common/assert_cast.h>
@@ -265,7 +264,7 @@ static inline UInt128 ALWAYS_INLINE hash128(
     for (size_t j = 0; j < keys_size; ++j)
         key_columns[j]->updateHashWithValue(i, hash);
 
-    hash.get128(key.low, key.high);
+    hash.get128(key);
 
     return key;
 }
diff --git a/src/Interpreters/Aggregator.cpp b/src/Interpreters/Aggregator.cpp
index 984b55e6e60..18482a2ef0a 100644
--- a/src/Interpreters/Aggregator.cpp
+++ b/src/Interpreters/Aggregator.cpp
@@ -325,7 +325,7 @@ AggregatedDataVariants::Type Aggregator::chooseAggregationMethod()
             /// into a fixed 16- or 32-byte blob.
             if (std::tuple_size<KeysNullMap<UInt128>>::value + keys_bytes <= 16)
                 return AggregatedDataVariants::Type::nullable_keys128;
-            if (std::tuple_size<KeysNullMap<DummyUInt256>>::value + keys_bytes <= 32)
+            if (std::tuple_size<KeysNullMap<UInt256>>::value + keys_bytes <= 32)
                 return AggregatedDataVariants::Type::nullable_keys256;
         }
 
@@ -837,7 +837,12 @@ void Aggregator::writeToTemporaryFile(AggregatedDataVariants & data_variants, co
     data_variants.init(data_variants.type);
     data_variants.aggregates_pools = Arenas(1, std::make_shared<Arena>());
     data_variants.aggregates_pool = data_variants.aggregates_pools.back().get();
-    data_variants.without_key = nullptr;
+    if (params.overflow_row || data_variants.type == AggregatedDataVariants::Type::without_key)
+    {
+        AggregateDataPtr place = data_variants.aggregates_pool->alignedAlloc(total_size_of_aggregate_states, align_aggregate_states);
+        createAggregateStates(place);
+        data_variants.without_key = place;
+    }
 
     block_out.flush();
     compressed_buf.next();
@@ -858,9 +863,9 @@ void Aggregator::writeToTemporaryFile(AggregatedDataVariants & data_variants, co
     ProfileEvents::increment(ProfileEvents::ExternalAggregationUncompressedBytes, uncompressed_bytes);
 
     LOG_DEBUG(log,
-        "Written part in {} sec., {} rows, {} uncompressed, {} compressed,"
-        " {} uncompressed bytes per row, {} compressed bytes per row, compression rate: {}"
-        " ({} rows/sec., {}/sec. uncompressed, {}/sec. compressed)",
+        "Written part in {:.3f} sec., {} rows, {} uncompressed, {} compressed,"
+        " {:.3f} uncompressed bytes per row, {:.3f} compressed bytes per row, compression rate: {:.3f}"
+        " ({:.3f} rows/sec., {}/sec. uncompressed, {}/sec. compressed)",
         elapsed_seconds,
         rows,
         ReadableSize(uncompressed_bytes),
@@ -1297,6 +1302,9 @@ Block Aggregator::prepareBlockAndFillWithoutKey(AggregatedDataVariants & data_va
         {
             AggregatedDataWithoutKey & data = data_variants.without_key;
 
+            if (!data)
+                throw Exception("Wrong data variant passed.", ErrorCodes::LOGICAL_ERROR);
+
             if (!final_)
             {
                 for (size_t i = 0; i < params.aggregates_size; ++i)
@@ -1493,7 +1501,7 @@ BlocksList Aggregator::convertToBlocks(AggregatedDataVariants & data_variants, b
 
     double elapsed_seconds = watch.elapsedSeconds();
     LOG_DEBUG(log,
-        "Converted aggregated data to blocks. {} rows, {} in {} sec. ({} rows/sec., {}/sec.)",
+        "Converted aggregated data to blocks. {} rows, {} in {} sec. ({:.3f} rows/sec., {}/sec.)",
         rows, ReadableSize(bytes),
         elapsed_seconds, rows / elapsed_seconds,
         ReadableSize(bytes / elapsed_seconds));
@@ -2097,7 +2105,7 @@ Block Aggregator::mergeBlocks(BlocksList & blocks, bool final)
     size_t rows = block.rows();
     size_t bytes = block.bytes();
     double elapsed_seconds = watch.elapsedSeconds();
-    LOG_DEBUG(log, "Merged partially aggregated blocks. {} rows, {}. in {} sec. ({} rows/sec., {}/sec.)",
+    LOG_DEBUG(log, "Merged partially aggregated blocks. {} rows, {}. in {} sec. ({:.3f} rows/sec., {}/sec.)",
         rows, ReadableSize(bytes),
         elapsed_seconds, rows / elapsed_seconds,
         ReadableSize(bytes / elapsed_seconds));
diff --git a/src/Interpreters/Aggregator.h b/src/Interpreters/Aggregator.h
index 31eefe03b3c..38b80d8923b 100644
--- a/src/Interpreters/Aggregator.h
+++ b/src/Interpreters/Aggregator.h
@@ -15,7 +15,6 @@
 #include <Common/HashTable/TwoLevelStringHashMap.h>
 
 #include <Common/ThreadPool.h>
-#include <Common/UInt128.h>
 #include <Common/ColumnsHashing.h>
 #include <Common/assert_cast.h>
 #include <Common/filesystemHelpers.h>
@@ -78,7 +77,7 @@ using AggregatedDataWithShortStringKey = StringHashMap<AggregateDataPtr>;
 using AggregatedDataWithStringKey = HashMapWithSavedHash<StringRef, AggregateDataPtr>;
 
 using AggregatedDataWithKeys128 = HashMap<UInt128, AggregateDataPtr, UInt128HashCRC32>;
-using AggregatedDataWithKeys256 = HashMap<DummyUInt256, AggregateDataPtr, UInt256HashCRC32>;
+using AggregatedDataWithKeys256 = HashMap<UInt256, AggregateDataPtr, UInt256HashCRC32>;
 
 using AggregatedDataWithUInt32KeyTwoLevel = TwoLevelHashMap<UInt32, AggregateDataPtr, HashCRC32<UInt32>>;
 using AggregatedDataWithUInt64KeyTwoLevel = TwoLevelHashMap<UInt64, AggregateDataPtr, HashCRC32<UInt64>>;
@@ -88,7 +87,7 @@ using AggregatedDataWithShortStringKeyTwoLevel = TwoLevelStringHashMap<Aggregate
 using AggregatedDataWithStringKeyTwoLevel = TwoLevelHashMapWithSavedHash<StringRef, AggregateDataPtr>;
 
 using AggregatedDataWithKeys128TwoLevel = TwoLevelHashMap<UInt128, AggregateDataPtr, UInt128HashCRC32>;
-using AggregatedDataWithKeys256TwoLevel = TwoLevelHashMap<DummyUInt256, AggregateDataPtr, UInt256HashCRC32>;
+using AggregatedDataWithKeys256TwoLevel = TwoLevelHashMap<UInt256, AggregateDataPtr, UInt256HashCRC32>;
 
 /** Variants with better hash function, using more than 32 bits for hash.
   * Using for merging phase of external aggregation, where number of keys may be far greater than 4 billion,
@@ -100,7 +99,7 @@ using AggregatedDataWithKeys256TwoLevel = TwoLevelHashMap<DummyUInt256, Aggregat
 using AggregatedDataWithUInt64KeyHash64 = HashMap<UInt64, AggregateDataPtr, DefaultHash<UInt64>>;
 using AggregatedDataWithStringKeyHash64 = HashMapWithSavedHash<StringRef, AggregateDataPtr, StringRefHash64>;
 using AggregatedDataWithKeys128Hash64 = HashMap<UInt128, AggregateDataPtr, UInt128Hash>;
-using AggregatedDataWithKeys256Hash64 = HashMap<DummyUInt256, AggregateDataPtr, UInt256Hash>;
+using AggregatedDataWithKeys256Hash64 = HashMap<UInt256, AggregateDataPtr, UInt256Hash>;
 
 template <typename Base>
 struct AggregationDataWithNullKey : public Base
diff --git a/src/Interpreters/ArithmeticOperationsInAgrFuncOptimize.cpp b/src/Interpreters/ArithmeticOperationsInAgrFuncOptimize.cpp
index 5c071ed9134..bdd9ce32707 100644
--- a/src/Interpreters/ArithmeticOperationsInAgrFuncOptimize.cpp
+++ b/src/Interpreters/ArithmeticOperationsInAgrFuncOptimize.cpp
@@ -64,6 +64,8 @@ Field zeroField(const Field & value)
         case Field::Types::Float64: return Float64(0);
         case Field::Types::UInt128: return UInt128(0);
         case Field::Types::Int128: return Int128(0);
+        case Field::Types::UInt256: return UInt256(0);
+        case Field::Types::Int256: return Int256(0);
         default:
             break;
     }
diff --git a/src/Interpreters/AsynchronousMetricLog.cpp b/src/Interpreters/AsynchronousMetricLog.cpp
index d2c81c9dfc5..6c20a04d291 100644
--- a/src/Interpreters/AsynchronousMetricLog.cpp
+++ b/src/Interpreters/AsynchronousMetricLog.cpp
@@ -1,9 +1,10 @@
-#include <Interpreters/AsynchronousMetricLog.h>
-#include <DataTypes/DataTypesNumber.h>
 #include <DataTypes/DataTypeDate.h>
 #include <DataTypes/DataTypeDateTime.h>
 #include <DataTypes/DataTypeDateTime64.h>
+#include <DataTypes/DataTypeLowCardinality.h>
 #include <DataTypes/DataTypeString.h>
+#include <DataTypes/DataTypesNumber.h>
+#include <Interpreters/AsynchronousMetricLog.h>
 #include <Interpreters/AsynchronousMetrics.h>
 
 
@@ -17,7 +18,7 @@ Block AsynchronousMetricLogElement::createBlock()
     columns.emplace_back(std::make_shared<DataTypeDate>(),          "event_date");
     columns.emplace_back(std::make_shared<DataTypeDateTime>(),      "event_time");
     columns.emplace_back(std::make_shared<DataTypeDateTime64>(6),   "event_time_microseconds");
-    columns.emplace_back(std::make_shared<DataTypeString>(),        "name");
+    columns.emplace_back(std::make_shared<DataTypeLowCardinality>(std::make_shared<DataTypeString>()), "name");
     columns.emplace_back(std::make_shared<DataTypeFloat64>(),       "value");
 
     return Block(columns);
diff --git a/src/Interpreters/AsynchronousMetrics.cpp b/src/Interpreters/AsynchronousMetrics.cpp
index 6eb143d17df..2216be4390c 100644
--- a/src/Interpreters/AsynchronousMetrics.cpp
+++ b/src/Interpreters/AsynchronousMetrics.cpp
@@ -197,7 +197,10 @@ void AsynchronousMetrics::update()
 #if USE_EMBEDDED_COMPILER
     {
         if (auto * compiled_expression_cache = CompiledExpressionCacheFactory::instance().tryGetCache())
+        {
+            new_values["CompiledExpressionCacheBytes"] = compiled_expression_cache->weight();
             new_values["CompiledExpressionCacheCount"]  = compiled_expression_cache->count();
+        }
     }
 #endif
 
diff --git a/src/Interpreters/BloomFilterHash.h b/src/Interpreters/BloomFilterHash.h
index b64f7bae79d..b88ca36ad84 100644
--- a/src/Interpreters/BloomFilterHash.h
+++ b/src/Interpreters/BloomFilterHash.h
@@ -93,7 +93,7 @@ struct BloomFilterHash
         else if (which.isDateTime()) return build_hash_column(getNumberTypeHash<UInt64, UInt32>(field));
         else if (which.isFloat32()) return build_hash_column(getNumberTypeHash<Float64, Float64>(field));
         else if (which.isFloat64()) return build_hash_column(getNumberTypeHash<Float64, Float64>(field));
-        else if (which.isUUID()) return build_hash_column(getNumberTypeHash<UInt128, UInt128>(field));
+        else if (which.isUUID()) return build_hash_column(getNumberTypeHash<UUID, UUID>(field));
         else if (which.isString()) return build_hash_column(getStringTypeHash(field));
         else if (which.isFixedString()) return build_hash_column(getFixedStringTypeHash(field, data_type));
         else throw Exception("Unexpected type " + data_type->getName() + " of bloom filter index.", ErrorCodes::BAD_ARGUMENTS);
@@ -154,7 +154,7 @@ struct BloomFilterHash
         else if (which.isDateTime()) getNumberTypeHash<UInt32, is_first>(column, vec, pos);
         else if (which.isFloat32()) getNumberTypeHash<Float32, is_first>(column, vec, pos);
         else if (which.isFloat64()) getNumberTypeHash<Float64, is_first>(column, vec, pos);
-        else if (which.isUUID()) getNumberTypeHash<UInt128, is_first>(column, vec, pos);
+        else if (which.isUUID()) getNumberTypeHash<UUID, is_first>(column, vec, pos);
         else if (which.isString()) getStringTypeHash<is_first>(column, vec, pos);
         else if (which.isFixedString()) getStringTypeHash<is_first>(column, vec, pos);
         else throw Exception("Unexpected type " + data_type->getName() + " of bloom filter index.", ErrorCodes::BAD_ARGUMENTS);
diff --git a/src/Interpreters/ClientInfo.cpp b/src/Interpreters/ClientInfo.cpp
index 223837aaf3d..248c8cc6b80 100644
--- a/src/Interpreters/ClientInfo.cpp
+++ b/src/Interpreters/ClientInfo.cpp
@@ -71,7 +71,7 @@ void ClientInfo::write(WriteBuffer & out, const UInt64 server_protocol_revision)
 
     if (server_protocol_revision >= DBMS_MIN_REVISION_WITH_OPENTELEMETRY)
     {
-        if (client_trace_context.trace_id)
+        if (client_trace_context.trace_id != UUID())
         {
             // Have OpenTelemetry header.
             writeBinary(uint8_t(1), out);
diff --git a/src/Interpreters/ClientInfo.h b/src/Interpreters/ClientInfo.h
index 60abb0dd671..b4579877ef6 100644
--- a/src/Interpreters/ClientInfo.h
+++ b/src/Interpreters/ClientInfo.h
@@ -2,7 +2,6 @@
 
 #include <Core/UUID.h>
 #include <Poco/Net/SocketAddress.h>
-#include <Common/UInt128.h>
 #include <common/types.h>
 #include <Common/OpenTelemetryTraceContext.h>
 
diff --git a/src/Interpreters/Context.cpp b/src/Interpreters/Context.cpp
index 0a0c6f9638d..973d351cf6a 100644
--- a/src/Interpreters/Context.cpp
+++ b/src/Interpreters/Context.cpp
@@ -453,6 +453,12 @@ struct ContextSharedPart
             /// TODO: Get rid of this.
 
             delete_system_logs = std::move(system_logs);
+
+            #if USE_EMBEDDED_COMPILER
+            if (auto * cache = CompiledExpressionCacheFactory::instance().tryGetCache())
+                cache->reset();
+            #endif
+
             embedded_dictionaries.reset();
             external_dictionaries_loader.reset();
             models_repository_guard.reset();
@@ -1225,13 +1231,13 @@ void Context::setCurrentQueryId(const String & query_id)
             UInt64 a;
             UInt64 b;
         } words;
-        __uint128_t uuid;
+        UUID uuid{};
     } random;
 
     random.words.a = thread_local_rng(); //-V656
     random.words.b = thread_local_rng(); //-V656
 
-    if (client_info.client_trace_context.trace_id != 0)
+    if (client_info.client_trace_context.trace_id != UUID())
     {
         // Use the OpenTelemetry trace context we received from the client, and
         // create a new span for the query.
diff --git a/src/Interpreters/Context.h b/src/Interpreters/Context.h
index 680ee7c779f..16b6653aa56 100644
--- a/src/Interpreters/Context.h
+++ b/src/Interpreters/Context.h
@@ -116,10 +116,6 @@ struct BackgroundTaskSchedulingSettings;
 class ZooKeeperMetadataTransaction;
 using ZooKeeperMetadataTransactionPtr = std::shared_ptr<ZooKeeperMetadataTransaction>;
 
-#if USE_EMBEDDED_COMPILER
-class CompiledExpressionCache;
-#endif
-
 /// Callback for external tables initializer
 using ExternalTablesInitializer = std::function<void(ContextPtr)>;
 
diff --git a/src/Interpreters/ConvertStringsToEnumVisitor.cpp b/src/Interpreters/ConvertStringsToEnumVisitor.cpp
new file mode 100644
index 00000000000..fa2e0b6613a
--- /dev/null
+++ b/src/Interpreters/ConvertStringsToEnumVisitor.cpp
@@ -0,0 +1,186 @@
+#include <Interpreters/ConvertStringsToEnumVisitor.h>
+#include <Parsers/ASTFunction.h>
+#include <Parsers/ASTLiteral.h>
+#include <Parsers/IAST.h>
+#include <Common/typeid_cast.h>
+
+
+namespace DB
+{
+
+namespace
+{
+
+/// @note We place strings in ascending order here under the assumption it colud speed up String to Enum conversion.
+String makeStringsEnum(const std::set<String> & values)
+{
+    String enum_string = "Enum8(";
+    if (values.size() >= 255)
+        enum_string = "Enum16(";
+
+    size_t number = 1;
+    for (const auto & item : values)
+    {
+        enum_string += "\'" + item + "\' = " + std::to_string(number++);
+
+        if (number <= values.size())
+            enum_string += ", ";
+    }
+
+    enum_string += ")";
+    return enum_string;
+}
+
+void changeIfArguments(ASTPtr & first, ASTPtr & second)
+{
+    String first_value = first->as<ASTLiteral>()->value.get<String>();
+    String second_value = second->as<ASTLiteral>()->value.get<String>();
+
+    std::set<String> values;
+    values.insert(first_value);
+    values.insert(second_value);
+
+    String enum_string = makeStringsEnum(values);
+    auto enum_literal = std::make_shared<ASTLiteral>(enum_string);
+
+    auto first_cast = makeASTFunction("CAST");
+    first_cast->arguments->children.push_back(first);
+    first_cast->arguments->children.push_back(enum_literal);
+
+    auto second_cast = makeASTFunction("CAST");
+    second_cast->arguments->children.push_back(second);
+    second_cast->arguments->children.push_back(enum_literal);
+
+    first = first_cast;
+    second = second_cast;
+}
+
+void changeTransformArguments(ASTPtr & array_to, ASTPtr & other)
+{
+    std::set<String> values;
+
+    for (const auto & item : array_to->as<ASTLiteral>()->value.get<Array>())
+        values.insert(item.get<String>());
+    values.insert(other->as<ASTLiteral>()->value.get<String>());
+
+    String enum_string = makeStringsEnum(values);
+
+    auto array_cast = makeASTFunction("CAST");
+    array_cast->arguments->children.push_back(array_to);
+    array_cast->arguments->children.push_back(std::make_shared<ASTLiteral>("Array(" + enum_string + ")"));
+    array_to = array_cast;
+
+    auto other_cast = makeASTFunction("CAST");
+    other_cast->arguments->children.push_back(other);
+    other_cast->arguments->children.push_back(std::make_shared<ASTLiteral>(enum_string));
+    other = other_cast;
+}
+
+bool checkSameType(const Array & array, const String & type)
+{
+    for (const auto & item : array)
+        if (item.getTypeName() != type)
+            return false;
+    return true;
+}
+
+}
+
+
+bool FindUsedFunctionsMatcher::needChildVisit(const ASTPtr & node, const ASTPtr &)
+{
+    return !(node->as<ASTFunction>());
+}
+
+void FindUsedFunctionsMatcher::visit(const ASTPtr & ast, Data & data)
+{
+    if (auto * func = ast->as<ASTFunction>())
+        visit(*func, data);
+}
+
+void FindUsedFunctionsMatcher::visit(const ASTFunction & func, Data & data)
+{
+    if (data.names.count(func.name) && !data.call_stack.empty())
+    {
+        String alias = func.tryGetAlias();
+        if (!alias.empty())
+        {
+            data.used_functions.insert(alias);
+        }
+    }
+
+    data.call_stack.push_back(func.name);
+
+    /// Visit children with known call stack
+    Visitor(data).visit(func.arguments);
+
+    data.call_stack.pop_back();
+}
+
+
+bool ConvertStringsToEnumMatcher::needChildVisit(const ASTPtr & node, const ASTPtr &)
+{
+    return !(node->as<ASTFunction>());
+}
+
+void ConvertStringsToEnumMatcher::visit(ASTPtr & ast, Data & data)
+{
+    if (auto * func = ast->as<ASTFunction>())
+        visit(*func, data);
+}
+
+void ConvertStringsToEnumMatcher::visit(ASTFunction & function_node, Data & data)
+{
+    if (!function_node.arguments)
+        return;
+
+    /// We are not sure we could change the type of function result
+    /// cause it is present in other function as argument
+    if (data.used_functions.count(function_node.tryGetAlias()))
+        return;
+
+    if (function_node.name == "if")
+    {
+        if (function_node.arguments->children.size() != 2)
+            return;
+
+        const ASTLiteral * literal1 = function_node.arguments->children[1]->as<ASTLiteral>();
+        const ASTLiteral * literal2 = function_node.arguments->children[2]->as<ASTLiteral>();
+        if (!literal1 || !literal2)
+            return;
+
+        if (literal1->value.getTypeName() != std::string_view{"String"}
+            || literal2->value.getTypeName() != std::string_view{"String"})
+            return;
+
+        changeIfArguments(function_node.arguments->children[1],
+                            function_node.arguments->children[2]);
+    }
+    else if (function_node.name == "transform")
+    {
+        if (function_node.arguments->children.size() != 4)
+            return;
+
+        const ASTLiteral * literal_to = function_node.arguments->children[2]->as<ASTLiteral>();
+        const ASTLiteral * literal_other = function_node.arguments->children[3]->as<ASTLiteral>();
+        if (!literal_to || !literal_other)
+            return;
+
+        if (literal_to->value.getTypeName() != std::string_view{"Array"}
+            || literal_other->value.getTypeName() != std::string_view{"String"})
+            return;
+
+        Array array_to = literal_to->value.get<Array>();
+        if (array_to.empty())
+            return;
+
+        bool to_strings = checkSameType(array_to, "String");
+        if (!to_strings)
+            return;
+
+        changeTransformArguments(function_node.arguments->children[2], function_node.arguments->children[3]);
+    }
+}
+
+}
+
diff --git a/src/Interpreters/ConvertStringsToEnumVisitor.h b/src/Interpreters/ConvertStringsToEnumVisitor.h
index adf408f87bd..b1389f40654 100644
--- a/src/Interpreters/ConvertStringsToEnumVisitor.h
+++ b/src/Interpreters/ConvertStringsToEnumVisitor.h
@@ -1,98 +1,17 @@
 #pragma once
 
-#include <Functions/FunctionFactory.h>
-#include <IO/WriteHelpers.h>
+#include <vector>
+#include <unordered_map>
+#include <unordered_set>
+
 #include <Interpreters/InDepthNodeVisitor.h>
-#include <Parsers/ASTFunction.h>
-#include <Parsers/ASTLiteral.h>
-#include <Parsers/ASTSelectQuery.h>
-#include <Parsers/ASTSetQuery.h>
-#include <Parsers/ASTTablesInSelectQuery.h>
-#include <Parsers/ASTWithAlias.h>
-#include <Parsers/ASTExpressionList.h>
-#include <Parsers/IAST.h>
-#include <Common/typeid_cast.h>
+#include <Parsers/IAST_fwd.h>
+
 
 namespace DB
 {
 
-namespace
-{
-
-/// @note We place strings in ascending order here under the assumption it colud speed up String to Enum conversion.
-String makeStringsEnum(const std::set<String> & values)
-{
-    String enum_string = "Enum8(";
-    if (values.size() >= 255)
-        enum_string = "Enum16(";
-
-    size_t number = 1;
-    for (const auto & item : values)
-    {
-        enum_string += "\'" + item + "\' = " + std::to_string(number++);
-
-        if (number <= values.size())
-            enum_string += ", ";
-    }
-
-    enum_string += ")";
-    return enum_string;
-}
-
-void changeIfArguments(ASTPtr & first, ASTPtr & second)
-{
-    String first_value = first->as<ASTLiteral>()->value.get<String>();
-    String second_value = second->as<ASTLiteral>()->value.get<String>();
-
-    std::set<String> values;
-    values.insert(first_value);
-    values.insert(second_value);
-
-    String enum_string = makeStringsEnum(values);
-    auto enum_literal = std::make_shared<ASTLiteral>(enum_string);
-
-    auto first_cast = makeASTFunction("CAST");
-    first_cast->arguments->children.push_back(first);
-    first_cast->arguments->children.push_back(enum_literal);
-
-    auto second_cast = makeASTFunction("CAST");
-    second_cast->arguments->children.push_back(second);
-    second_cast->arguments->children.push_back(enum_literal);
-
-    first = first_cast;
-    second = second_cast;
-}
-
-void changeTransformArguments(ASTPtr & array_to, ASTPtr & other)
-{
-    std::set<String> values;
-
-    for (const auto & item : array_to->as<ASTLiteral>()->value.get<Array>())
-        values.insert(item.get<String>());
-    values.insert(other->as<ASTLiteral>()->value.get<String>());
-
-    String enum_string = makeStringsEnum(values);
-
-    auto array_cast = makeASTFunction("CAST");
-    array_cast->arguments->children.push_back(array_to);
-    array_cast->arguments->children.push_back(std::make_shared<ASTLiteral>("Array(" + enum_string + ")"));
-    array_to = array_cast;
-
-    auto other_cast = makeASTFunction("CAST");
-    other_cast->arguments->children.push_back(other);
-    other_cast->arguments->children.push_back(std::make_shared<ASTLiteral>(enum_string));
-    other = other_cast;
-}
-
-bool checkSameType(const Array & array, const String & type)
-{
-    for (const auto & item : array)
-        if (item.getTypeName() != type)
-            return false;
-    return true;
-}
-
-}
+class ASTFunction;
 
 struct FindUsedFunctionsMatcher
 {
@@ -105,35 +24,9 @@ struct FindUsedFunctionsMatcher
         std::vector<String> call_stack = {};
     };
 
-    static bool needChildVisit(const ASTPtr & node, const ASTPtr &)
-    {
-        return !(node->as<ASTFunction>());
-    }
-
-    static void visit(const ASTPtr & ast, Data & data)
-    {
-        if (auto * func = ast->as<ASTFunction>())
-            visit(*func, data);
-    }
-
-    static void visit(const ASTFunction & func, Data & data)
-    {
-        if (data.names.count(func.name) && !data.call_stack.empty())
-        {
-            String alias = func.tryGetAlias();
-            if (!alias.empty())
-            {
-                data.used_functions.insert(alias);
-            }
-        }
-
-        data.call_stack.push_back(func.name);
-
-        /// Visit children with known call stack
-        Visitor(data).visit(func.arguments);
-
-        data.call_stack.pop_back();
-    }
+    static bool needChildVisit(const ASTPtr & node, const ASTPtr &);
+    static void visit(const ASTPtr & ast, Data & data);
+    static void visit(const ASTFunction & func, Data & data);
 };
 
 using FindUsedFunctionsVisitor = FindUsedFunctionsMatcher::Visitor;
@@ -145,70 +38,9 @@ struct ConvertStringsToEnumMatcher
         std::unordered_set<String> & used_functions;
     };
 
-    static bool needChildVisit(const ASTPtr & node, const ASTPtr &)
-    {
-        return !(node->as<ASTFunction>());
-    }
-
-    static void visit(ASTPtr & ast, Data & data)
-    {
-        if (auto * func = ast->as<ASTFunction>())
-            visit(*func, data);
-    }
-
-    static void visit(ASTFunction & function_node, Data & data)
-    {
-        if (!function_node.arguments)
-            return;
-
-        /// We are not sure we could change the type of function result
-        /// cause it is present in other function as argument
-        if (data.used_functions.count(function_node.tryGetAlias()))
-            return;
-
-        if (function_node.name == "if")
-        {
-            if (function_node.arguments->children.size() != 2)
-                return;
-
-            auto literal1 = function_node.arguments->children[1]->as<ASTLiteral>();
-            auto literal2 = function_node.arguments->children[2]->as<ASTLiteral>();
-            if (!literal1 || !literal2)
-                return;
-
-            if (String(literal1->value.getTypeName()) != "String" ||
-                String(literal2->value.getTypeName()) != "String")
-                return;
-
-            changeIfArguments(function_node.arguments->children[1],
-                              function_node.arguments->children[2]);
-        }
-        else if (function_node.name == "transform")
-        {
-            if (function_node.arguments->children.size() != 4)
-                return;
-
-            auto literal_to = function_node.arguments->children[2]->as<ASTLiteral>();
-            auto literal_other = function_node.arguments->children[3]->as<ASTLiteral>();
-            if (!literal_to || !literal_other)
-                return;
-
-            if (String(literal_to->value.getTypeName()) != "Array" ||
-                String(literal_other->value.getTypeName()) != "String")
-                return;
-
-            Array array_to = literal_to->value.get<Array>();
-            if (array_to.size() == 0)
-                return;
-
-            bool to_strings = checkSameType(array_to, "String");
-            if (!to_strings)
-                return;
-
-            changeTransformArguments(function_node.arguments->children[2],
-                                     function_node.arguments->children[3]);
-        }
-    }
+    static bool needChildVisit(const ASTPtr & node, const ASTPtr &);
+    static void visit(ASTPtr & ast, Data & data);
+    static void visit(ASTFunction & function_node, Data & data);
 };
 
 using ConvertStringsToEnumVisitor = InDepthNodeVisitor<ConvertStringsToEnumMatcher, true>;
diff --git a/src/Interpreters/DDLTask.h b/src/Interpreters/DDLTask.h
index 9e314eb84c6..4fae70f6a69 100644
--- a/src/Interpreters/DDLTask.h
+++ b/src/Interpreters/DDLTask.h
@@ -129,8 +129,8 @@ private:
     String cluster_name;
     ClusterPtr cluster;
     Cluster::Address address_in_cluster;
-    size_t host_shard_num;
-    size_t host_replica_num;
+    size_t host_shard_num = 0;
+    size_t host_replica_num = 0;
 };
 
 struct DatabaseReplicatedTask : public DDLTaskBase
diff --git a/src/Interpreters/DatabaseCatalog.cpp b/src/Interpreters/DatabaseCatalog.cpp
index 9c7a39db7df..6d6b8107f0c 100644
--- a/src/Interpreters/DatabaseCatalog.cpp
+++ b/src/Interpreters/DatabaseCatalog.cpp
@@ -56,7 +56,7 @@ TemporaryTableHolder::TemporaryTableHolder(ContextPtr context_, const TemporaryT
     ASTPtr original_create;
     ASTCreateQuery * create = dynamic_cast<ASTCreateQuery *>(query.get());
     String global_name;
-    if (query)
+    if (create)
     {
         original_create = create->clone();
         if (create->uuid == UUIDHelpers::Nil)
diff --git a/src/Interpreters/DatabaseCatalog.h b/src/Interpreters/DatabaseCatalog.h
index 388079b54f2..5f6936f8b18 100644
--- a/src/Interpreters/DatabaseCatalog.h
+++ b/src/Interpreters/DatabaseCatalog.h
@@ -226,7 +226,7 @@ private:
 
     static inline size_t getFirstLevelIdx(const UUID & uuid)
     {
-        return uuid.toUnderType().low >> (64 - bits_for_first_level);
+        return uuid.toUnderType().items[0] >> (64 - bits_for_first_level);
     }
 
     struct TableMarkedAsDropped
@@ -234,7 +234,7 @@ private:
         StorageID table_id = StorageID::createEmpty();
         StoragePtr table;
         String metadata_path;
-        time_t drop_time;
+        time_t drop_time{};
     };
     using TablesMarkedAsDropped = std::list<TableMarkedAsDropped>;
 
diff --git a/src/Interpreters/DuplicateOrderByVisitor.h b/src/Interpreters/DuplicateOrderByVisitor.h
index 4f95854e17b..4231b2600af 100644
--- a/src/Interpreters/DuplicateOrderByVisitor.h
+++ b/src/Interpreters/DuplicateOrderByVisitor.h
@@ -93,7 +93,7 @@ public:
                     bool is_stateful = false;
                     ASTFunctionStatefulVisitor::Data data{context, is_stateful};
                     ASTFunctionStatefulVisitor(data).visit(elem);
-                    if (is_stateful)
+                    if (is_stateful) //-V547
                         return;
                 }
             }
diff --git a/src/Interpreters/ExpressionJIT.cpp b/src/Interpreters/ExpressionJIT.cpp
index 962d90f5d96..4169d95bfa4 100644
--- a/src/Interpreters/ExpressionJIT.cpp
+++ b/src/Interpreters/ExpressionJIT.cpp
@@ -5,62 +5,22 @@
 #include <optional>
 #include <stack>
 
+#include <common/logger_useful.h>
 #include <Columns/ColumnConst.h>
 #include <Columns/ColumnNullable.h>
 #include <Columns/ColumnVector.h>
 #include <Common/typeid_cast.h>
 #include <Common/assert_cast.h>
-#include <Common/ProfileEvents.h>
-#include <Common/Stopwatch.h>
 #include <DataTypes/DataTypeNullable.h>
 #include <DataTypes/DataTypesNumber.h>
+#include <Functions/FunctionsComparison.h>
 #include <DataTypes/Native.h>
 #include <Functions/IFunctionAdaptors.h>
-#include <IO/WriteBufferFromString.h>
-#include <IO/Operators.h>
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-parameter"
-#pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
-
-#include <llvm/Analysis/TargetTransformInfo.h>
-#include <llvm/IR/BasicBlock.h>
-#include <llvm/IR/DataLayout.h>
-#include <llvm/IR/DerivedTypes.h>
-#include <llvm/IR/Function.h>
-#include <llvm/IR/IRBuilder.h>
-#include <llvm/IR/LLVMContext.h>
-#include <llvm/IR/Mangler.h>
-#include <llvm/IR/Module.h>
-#include <llvm/IR/Type.h>
-#include <llvm/IR/LegacyPassManager.h>
-#include <llvm/ExecutionEngine/ExecutionEngine.h>
-#include <llvm/ExecutionEngine/JITSymbol.h>
-#include <llvm/ExecutionEngine/SectionMemoryManager.h>
-#include <llvm/ExecutionEngine/Orc/CompileUtils.h>
-#include <llvm/ExecutionEngine/Orc/IRCompileLayer.h>
-#include <llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h>
-#include <llvm/Target/TargetMachine.h>
-#include <llvm/MC/SubtargetFeature.h>
-#include <llvm/Support/DynamicLibrary.h>
-#include <llvm/Support/Host.h>
-#include <llvm/Support/TargetRegistry.h>
-#include <llvm/Support/TargetSelect.h>
-#include <llvm/Transforms/IPO/PassManagerBuilder.h>
-
-#pragma GCC diagnostic pop
-
-/// 'LegacyRTDyldObjectLinkingLayer' is deprecated: ORCv1 layers (layers with the 'Legacy' prefix) are deprecated. Please use ORCv2
-/// 'LegacyIRCompileLayer' is deprecated: ORCv1 layers (layers with the 'Legacy' prefix) are deprecated. Please use the ORCv2 IRCompileLayer instead
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-
-
-namespace ProfileEvents
-{
-    extern const Event CompileFunction;
-    extern const Event CompileExpressionsMicroseconds;
-    extern const Event CompileExpressionsBytes;
-}
+#include <Interpreters/JIT/CHJIT.h>
+#include <Interpreters/JIT/CompileDAG.h>
+#include <Interpreters/JIT/compileFunction.h>
+#include <Interpreters/ActionsDAG.h>
 
 namespace DB
 {
@@ -68,207 +28,29 @@ namespace DB
 namespace ErrorCodes
 {
     extern const int LOGICAL_ERROR;
-    extern const int CANNOT_COMPILE_CODE;
+    extern const int NOT_IMPLEMENTED;
 }
 
-namespace
+static CHJIT & getJITInstance()
 {
-    struct ColumnData
-    {
-        const char * data = nullptr;
-        const char * null = nullptr;
-        size_t stride = 0;
-    };
-
-    struct ColumnDataPlaceholder
-    {
-        llvm::Value * data_init; /// first row
-        llvm::Value * null_init;
-        llvm::Value * stride;
-        llvm::PHINode * data; /// current row
-        llvm::PHINode * null;
-    };
+    static CHJIT jit;
+    return jit;
 }
 
-static ColumnData getColumnData(const IColumn * column)
+static Poco::Logger * getLogger()
 {
-    ColumnData result;
-    const bool is_const = isColumnConst(*column);
-    if (is_const)
-        column = &reinterpret_cast<const ColumnConst *>(column)->getDataColumn();
-    if (const auto * nullable = typeid_cast<const ColumnNullable *>(column))
-    {
-        result.null = nullable->getNullMapColumn().getRawData().data;
-        column = &nullable->getNestedColumn();
-    }
-    result.data = column->getRawData().data;
-    result.stride = is_const ? 0 : column->sizeOfValueIfFixed();
-    return result;
-}
-
-static void applyFunction(IFunctionBase & function, Field & value)
-{
-    const auto & type = function.getArgumentTypes().at(0);
-    ColumnsWithTypeAndName args{{type->createColumnConst(1, value), type, "x" }};
-    auto col = function.execute(args, function.getResultType(), 1);
-    col->get(0, value);
-}
-
-static llvm::TargetMachine * getNativeMachine()
-{
-    std::string error;
-    auto cpu = llvm::sys::getHostCPUName();
-    auto triple = llvm::sys::getProcessTriple();
-    const auto * target = llvm::TargetRegistry::lookupTarget(triple, error);
-    if (!target)
-        throw Exception("Could not initialize native target: " + error, ErrorCodes::CANNOT_COMPILE_CODE);
-    llvm::SubtargetFeatures features;
-    llvm::StringMap<bool> feature_map;
-    if (llvm::sys::getHostCPUFeatures(feature_map))
-        for (auto & f : feature_map)
-            features.AddFeature(f.first(), f.second);
-    llvm::TargetOptions options;
-    return target->createTargetMachine(
-        triple, cpu, features.getString(), options, llvm::None,
-        llvm::None, llvm::CodeGenOpt::Default, /*jit=*/true
-    );
-}
-
-
-struct SymbolResolver : public llvm::orc::SymbolResolver
-{
-    llvm::LegacyJITSymbolResolver & impl;
-
-    explicit SymbolResolver(llvm::LegacyJITSymbolResolver & impl_) : impl(impl_) {}
-
-    llvm::orc::SymbolNameSet getResponsibilitySet(const llvm::orc::SymbolNameSet & symbols) final
-    {
-        return symbols;
-    }
-
-    llvm::orc::SymbolNameSet lookup(std::shared_ptr<llvm::orc::AsynchronousSymbolQuery> query, llvm::orc::SymbolNameSet symbols) final
-    {
-        llvm::orc::SymbolNameSet missing;
-        for (const auto & symbol : symbols)
-        {
-            bool has_resolved = false;
-            impl.lookup({*symbol}, [&](llvm::Expected<llvm::JITSymbolResolver::LookupResult> resolved)
-            {
-                if (resolved && !resolved->empty())
-                {
-                    query->notifySymbolMetRequiredState(symbol, resolved->begin()->second);
-                    has_resolved = true;
-                }
-            });
-
-            if (!has_resolved)
-                missing.insert(symbol);
-        }
-        return missing;
-    }
-};
-
-
-struct LLVMContext
-{
-    std::shared_ptr<llvm::LLVMContext> context {std::make_shared<llvm::LLVMContext>()};
-    std::unique_ptr<llvm::Module> module {std::make_unique<llvm::Module>("jit", *context)};
-    std::unique_ptr<llvm::TargetMachine> machine {getNativeMachine()};
-    llvm::DataLayout layout {machine->createDataLayout()};
-    llvm::IRBuilder<> builder {*context};
-
-    llvm::orc::ExecutionSession execution_session;
-
-    std::shared_ptr<llvm::SectionMemoryManager> memory_manager;
-    llvm::orc::LegacyRTDyldObjectLinkingLayer object_layer;
-    llvm::orc::LegacyIRCompileLayer<decltype(object_layer), llvm::orc::SimpleCompiler> compile_layer;
-
-    std::unordered_map<std::string, void *> symbols;
-
-    LLVMContext()
-        : memory_manager(std::make_shared<llvm::SectionMemoryManager>())
-        , object_layer(execution_session, [this](llvm::orc::VModuleKey)
-        {
-            return llvm::orc::LegacyRTDyldObjectLinkingLayer::Resources{memory_manager, std::make_shared<SymbolResolver>(*memory_manager)};
-        })
-        , compile_layer(object_layer, llvm::orc::SimpleCompiler(*machine))
-    {
-        module->setDataLayout(layout);
-        module->setTargetTriple(machine->getTargetTriple().getTriple());
-    }
-
-    /// returns used memory
-    void compileAllFunctionsToNativeCode()
-    {
-        if (module->empty())
-            return;
-        llvm::PassManagerBuilder pass_manager_builder;
-        llvm::legacy::PassManager mpm;
-        llvm::legacy::FunctionPassManager fpm(module.get());
-        pass_manager_builder.OptLevel = 3;
-        pass_manager_builder.SLPVectorize = true;
-        pass_manager_builder.LoopVectorize = true;
-        pass_manager_builder.RerollLoops = true;
-        pass_manager_builder.VerifyInput = true;
-        pass_manager_builder.VerifyOutput = true;
-        machine->adjustPassManager(pass_manager_builder);
-        fpm.add(llvm::createTargetTransformInfoWrapperPass(machine->getTargetIRAnalysis()));
-        mpm.add(llvm::createTargetTransformInfoWrapperPass(machine->getTargetIRAnalysis()));
-        pass_manager_builder.populateFunctionPassManager(fpm);
-        pass_manager_builder.populateModulePassManager(mpm);
-        fpm.doInitialization();
-        for (auto & function : *module)
-            fpm.run(function);
-        fpm.doFinalization();
-        mpm.run(*module);
-
-        std::vector<std::string> functions;
-        functions.reserve(module->size());
-        for (const auto & function : *module)
-            functions.emplace_back(function.getName());
-
-        llvm::orc::VModuleKey module_key = execution_session.allocateVModule();
-        if (compile_layer.addModule(module_key, std::move(module)))
-            throw Exception("Cannot add module to compile layer", ErrorCodes::CANNOT_COMPILE_CODE);
-
-        for (const auto & name : functions)
-        {
-            std::string mangled_name;
-            llvm::raw_string_ostream mangled_name_stream(mangled_name);
-            llvm::Mangler::getNameWithPrefix(mangled_name_stream, name, layout);
-            mangled_name_stream.flush();
-            auto symbol = compile_layer.findSymbol(mangled_name, false);
-            if (!symbol)
-                continue; /// external function (e.g. an intrinsic that calls into libc)
-            auto address = symbol.getAddress();
-            if (!address)
-                throw Exception("Function " + name + " failed to link", ErrorCodes::CANNOT_COMPILE_CODE);
-            symbols[name] = reinterpret_cast<void *>(*address);
-        }
-    }
-};
-
-
-template <typename... Ts>
-static bool castToEitherWithNullable(IColumn * column)
-{
-    return ((typeid_cast<Ts *>(column)
-            || (typeid_cast<ColumnNullable *>(column) && typeid_cast<Ts *>(&(typeid_cast<ColumnNullable *>(column)->getNestedColumn())))) || ...);
+    static Poco::Logger & logger = Poco::Logger::get("ExpressionJIT");
+    return &logger;
 }
 
 class LLVMExecutableFunction : public IExecutableFunctionImpl
 {
-    std::string name;
-    void * function;
-
 public:
-    LLVMExecutableFunction(const std::string & name_, const std::unordered_map<std::string, void *> & symbols)
+
+    explicit LLVMExecutableFunction(const std::string & name_, JITCompiledFunction function_)
         : name(name_)
+        , function(function_)
     {
-        auto it = symbols.find(name);
-        if (symbols.end() == it)
-            throw Exception("Cannot find symbol " + name + " in LLVMContext", ErrorCodes::LOGICAL_ERROR);
-        function = it->second;
     }
 
     String getName() const override { return name; }
@@ -277,490 +59,209 @@ public:
 
     bool useDefaultImplementationForConstants() const override { return true; }
 
-    ColumnPtr execute(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t block_size) const override
+    ColumnPtr execute(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count) const override
     {
-        auto col_res = result_type->createColumn();
+        if (!canBeNativeType(*result_type))
+            throw Exception(ErrorCodes::LOGICAL_ERROR, "LLVMExecutableFunction unexpected result type in: {}", result_type->getName());
 
-        if (block_size)
+        auto result_column = result_type->createColumn();
+
+        if (input_rows_count)
         {
-            if (!castToEitherWithNullable<
-                ColumnUInt8, ColumnUInt16, ColumnUInt32, ColumnUInt64,
-                ColumnInt8, ColumnInt16, ColumnInt32, ColumnInt64,
-                ColumnFloat32, ColumnFloat64>(col_res.get()))
-                throw Exception("Unexpected column in LLVMExecutableFunction: " + col_res->getName(), ErrorCodes::LOGICAL_ERROR);
-            col_res = col_res->cloneResized(block_size);
+            result_column = result_column->cloneResized(input_rows_count);
+
             std::vector<ColumnData> columns(arguments.size() + 1);
+            std::vector<ColumnPtr> columns_backup;
+
             for (size_t i = 0; i < arguments.size(); ++i)
             {
-                const auto * column = arguments[i].column.get();
-                if (!column)
-                    throw Exception("Column " + arguments[i].name + " is missing", ErrorCodes::LOGICAL_ERROR);
-                columns[i] = getColumnData(column);
+                auto column = arguments[i].column->convertToFullColumnIfConst();
+                columns_backup.emplace_back(column);
+                columns[i] = getColumnData(column.get());
             }
-            columns[arguments.size()] = getColumnData(col_res.get());
-            reinterpret_cast<void (*) (size_t, ColumnData *)>(function)(block_size, columns.data());
-        }
 
-        return col_res;
-    }
-};
+            columns[arguments.size()] = getColumnData(result_column.get());
+            function(input_rows_count, columns.data());
 
-static void compileFunctionToLLVMByteCode(LLVMContext & context, const IFunctionBaseImpl & f)
-{
-    ProfileEvents::increment(ProfileEvents::CompileFunction);
+            #if defined(MEMORY_SANITIZER)
+            /// Memory sanitizer don't know about stores from JIT-ed code.
+            /// But maybe we can generate this code with MSan instrumentation?
 
-    const auto & arg_types = f.getArgumentTypes();
-    auto & b = context.builder;
-    auto * size_type = b.getIntNTy(sizeof(size_t) * 8);
-    auto * data_type = llvm::StructType::get(b.getInt8PtrTy(), b.getInt8PtrTy(), size_type);
-    auto * func_type = llvm::FunctionType::get(b.getVoidTy(), { size_type, data_type->getPointerTo() }, /*isVarArg=*/false);
-    auto * func = llvm::Function::Create(func_type, llvm::Function::ExternalLinkage, f.getName(), context.module.get());
-    auto * args = func->args().begin();
-    llvm::Value * counter_arg = &*args++;
-    llvm::Value * columns_arg = &*args++;
-
-    auto * entry = llvm::BasicBlock::Create(b.getContext(), "entry", func);
-    b.SetInsertPoint(entry);
-    std::vector<ColumnDataPlaceholder> columns(arg_types.size() + 1);
-    for (size_t i = 0; i <= arg_types.size(); ++i)
-    {
-        const auto & type = i == arg_types.size() ? f.getResultType() : arg_types[i];
-        auto * data = b.CreateLoad(b.CreateConstInBoundsGEP1_32(data_type, columns_arg, i));
-        columns[i].data_init = b.CreatePointerCast(b.CreateExtractValue(data, {0}), toNativeType(b, removeNullable(type))->getPointerTo());
-        columns[i].null_init = type->isNullable() ? b.CreateExtractValue(data, {1}) : nullptr;
-        columns[i].stride = b.CreateExtractValue(data, {2});
-    }
-
-    /// assume nonzero initial value in `counter_arg`
-    auto * loop = llvm::BasicBlock::Create(b.getContext(), "loop", func);
-    b.CreateBr(loop);
-    b.SetInsertPoint(loop);
-    auto * counter_phi = b.CreatePHI(counter_arg->getType(), 2);
-    counter_phi->addIncoming(counter_arg, entry);
-    for (auto & col : columns)
-    {
-        col.data = b.CreatePHI(col.data_init->getType(), 2);
-        col.data->addIncoming(col.data_init, entry);
-        if (col.null_init)
-        {
-            col.null = b.CreatePHI(col.null_init->getType(), 2);
-            col.null->addIncoming(col.null_init, entry);
-        }
-    }
-    ValuePlaceholders arguments(arg_types.size());
-    for (size_t i = 0; i < arguments.size(); ++i) // NOLINT
-    {
-        arguments[i] = [&b, &col = columns[i], &type = arg_types[i]]() -> llvm::Value *
-        {
-            auto * value = b.CreateLoad(col.data);
-            if (!col.null)
-                return value;
-            auto * is_null = b.CreateICmpNE(b.CreateLoad(col.null), b.getInt8(0));
-            auto * nullable = llvm::Constant::getNullValue(toNativeType(b, type));
-            return b.CreateInsertValue(b.CreateInsertValue(nullable, value, {0}), is_null, {1});
-        };
-    }
-    auto * result = f.compile(b, std::move(arguments));
-    if (columns.back().null)
-    {
-        b.CreateStore(b.CreateExtractValue(result, {0}), columns.back().data);
-        b.CreateStore(b.CreateSelect(b.CreateExtractValue(result, {1}), b.getInt8(1), b.getInt8(0)), columns.back().null);
-    }
-    else
-    {
-        b.CreateStore(result, columns.back().data);
-    }
-    auto * cur_block = b.GetInsertBlock();
-    for (auto & col : columns)
-    {
-        /// stride is either 0 or size of native type; output column is never constant; neither is at least one input
-        auto * is_const = &col == &columns.back() || columns.size() <= 2 ? b.getFalse() : b.CreateICmpEQ(col.stride, llvm::ConstantInt::get(size_type, 0));
-        col.data->addIncoming(b.CreateSelect(is_const, col.data, b.CreateConstInBoundsGEP1_32(nullptr, col.data, 1)), cur_block);
-        if (col.null)
-            col.null->addIncoming(b.CreateSelect(is_const, col.null, b.CreateConstInBoundsGEP1_32(nullptr, col.null, 1)), cur_block);
-    }
-    counter_phi->addIncoming(b.CreateSub(counter_phi, llvm::ConstantInt::get(size_type, 1)), cur_block);
-
-    auto * end = llvm::BasicBlock::Create(b.getContext(), "end", func);
-    b.CreateCondBr(b.CreateICmpNE(counter_phi, llvm::ConstantInt::get(size_type, 1)), loop, end);
-    b.SetInsertPoint(end);
-    b.CreateRetVoid();
-}
-
-static llvm::Constant * getNativeValue(llvm::Type * type, const IColumn & column, size_t i)
-{
-    if (!type || column.size() <= i)
-        return nullptr;
-    if (const auto * constant = typeid_cast<const ColumnConst *>(&column))
-        return getNativeValue(type, constant->getDataColumn(), 0);
-    if (const auto * nullable = typeid_cast<const ColumnNullable *>(&column))
-    {
-        auto * value = getNativeValue(type->getContainedType(0), nullable->getNestedColumn(), i);
-        auto * is_null = llvm::ConstantInt::get(type->getContainedType(1), nullable->isNullAt(i));
-        return value ? llvm::ConstantStruct::get(static_cast<llvm::StructType *>(type), value, is_null) : nullptr;
-    }
-    if (type->isFloatTy())
-        return llvm::ConstantFP::get(type, assert_cast<const ColumnVector<Float32> &>(column).getElement(i));
-    if (type->isDoubleTy())
-        return llvm::ConstantFP::get(type, assert_cast<const ColumnVector<Float64> &>(column).getElement(i));
-    if (type->isIntegerTy())
-        return llvm::ConstantInt::get(type, column.getUInt(i));
-    /// TODO: if (type->isVectorTy())
-    return nullptr;
-}
-
-/// Same as IFunctionBase::compile, but also for constants and input columns.
-using CompilableExpression = std::function<llvm::Value * (llvm::IRBuilderBase &, const ValuePlaceholders &)>;
-
-static CompilableExpression subexpression(ColumnPtr c, DataTypePtr type)
-{
-    return [=](llvm::IRBuilderBase & b, const ValuePlaceholders &) { return getNativeValue(toNativeType(b, type), *c, 0); };
-}
-
-static CompilableExpression subexpression(size_t i)
-{
-    return [=](llvm::IRBuilderBase &, const ValuePlaceholders & inputs) { return inputs[i](); };
-}
-
-static CompilableExpression subexpression(const IFunctionBase & f, std::vector<CompilableExpression> args)
-{
-    return [&, args = std::move(args)](llvm::IRBuilderBase & builder, const ValuePlaceholders & inputs)
-    {
-        ValuePlaceholders input;
-        for (const auto & arg : args)
-            input.push_back([&]() { return arg(builder, inputs); });
-        auto * result = f.compile(builder, input);
-        if (result->getType() != toNativeType(builder, f.getResultType()))
-            throw Exception("Function " + f.getName() + " generated an llvm::Value of invalid type", ErrorCodes::LOGICAL_ERROR);
-        return result;
-    };
-}
-
-struct LLVMModuleState
-{
-    std::unordered_map<std::string, void *> symbols;
-    std::shared_ptr<llvm::LLVMContext> major_context;
-    std::shared_ptr<llvm::SectionMemoryManager> memory_manager;
-};
-
-LLVMFunction::LLVMFunction(const CompileDAG & dag)
-    : name(dag.dump())
-    , module_state(std::make_unique<LLVMModuleState>())
-{
-    LLVMContext context;
-    std::vector<CompilableExpression> expressions;
-    expressions.reserve(dag.size());
-
-    for (const auto & node : dag)
-    {
-        switch (node.type)
-        {
-            case CompileNode::NodeType::CONSTANT:
+            if (const auto * nullable_column = typeid_cast<const ColumnNullable *>(result_column.get()))
             {
-                const auto * col = typeid_cast<const ColumnConst *>(node.column.get());
+                const auto & nested_column = nullable_column->getNestedColumn();
+                const auto & null_map_column = nullable_column->getNullMapColumn();
 
-                /// TODO: implement `getNativeValue` for all types & replace the check with `c.column && toNativeType(...)`
-                if (!getNativeValue(toNativeType(context.builder, node.result_type), col->getDataColumn(), 0))
-                    throw Exception(ErrorCodes::LOGICAL_ERROR,
-                                    "Cannot compile constant of type {} = {}",
-                                    node.result_type->getName(),
-                                    applyVisitor(FieldVisitorToString(), col->getDataColumn()[0]));
+                auto nested_column_raw_data = nested_column.getRawData();
+                __msan_unpoison(nested_column_raw_data.data, nested_column_raw_data.size);
 
-                expressions.emplace_back(subexpression(col->getDataColumnPtr(), node.result_type));
-                break;
+                auto null_map_column_raw_data = null_map_column.getRawData();
+                __msan_unpoison(null_map_column_raw_data.data, null_map_column_raw_data.size);
             }
-            case CompileNode::NodeType::FUNCTION:
-            {
-                std::vector<CompilableExpression> args;
-                args.reserve(node.arguments.size());
-
-                for (auto arg : node.arguments)
-                    args.emplace_back(expressions[arg]);
-
-                originals.push_back(node.function);
-                expressions.emplace_back(subexpression(*node.function, std::move(args)));
-                break;
-            }
-            case CompileNode::NodeType::INPUT:
-            {
-                expressions.emplace_back(subexpression(arg_types.size()));
-                arg_types.push_back(node.result_type);
-                break;
-            }
-        }
-    }
-
-    expression = std::move(expressions.back());
-
-    compileFunctionToLLVMByteCode(context, *this);
-    context.compileAllFunctionsToNativeCode();
-
-    module_state->symbols = context.symbols;
-    module_state->major_context = context.context;
-    module_state->memory_manager = context.memory_manager;
-}
-
-llvm::Value * LLVMFunction::compile(llvm::IRBuilderBase & builder, ValuePlaceholders values) const
-{
-    return expression(builder, values);
-}
-
-ExecutableFunctionImplPtr LLVMFunction::prepare(const ColumnsWithTypeAndName &) const { return std::make_unique<LLVMExecutableFunction>(name, module_state->symbols); }
-
-bool LLVMFunction::isDeterministic() const
-{
-    for (const auto & f : originals)
-        if (!f->isDeterministic())
-            return false;
-    return true;
-}
-
-bool LLVMFunction::isDeterministicInScopeOfQuery() const
-{
-    for (const auto & f : originals)
-        if (!f->isDeterministicInScopeOfQuery())
-            return false;
-    return true;
-}
-
-bool LLVMFunction::isSuitableForConstantFolding() const
-{
-    for (const auto & f : originals)
-        if (!f->isSuitableForConstantFolding())
-            return false;
-    return true;
-}
-
-bool LLVMFunction::isInjective(const ColumnsWithTypeAndName & sample_block) const
-{
-    for (const auto & f : originals)
-        if (!f->isInjective(sample_block))
-            return false;
-    return true;
-}
-
-bool LLVMFunction::hasInformationAboutMonotonicity() const
-{
-    for (const auto & f : originals)
-        if (!f->hasInformationAboutMonotonicity())
-            return false;
-    return true;
-}
-
-LLVMFunction::Monotonicity LLVMFunction::getMonotonicityForRange(const IDataType & type, const Field & left, const Field & right) const
-{
-    const IDataType * type_ptr = &type;
-    Field left_mut = left;
-    Field right_mut = right;
-    Monotonicity result(true, true, true);
-    /// monotonicity is only defined for unary functions, so the chain must describe a sequence of nested calls
-    for (size_t i = 0; i < originals.size(); ++i)
-    {
-        Monotonicity m = originals[i]->getMonotonicityForRange(*type_ptr, left_mut, right_mut);
-        if (!m.is_monotonic)
-            return m;
-        result.is_positive ^= !m.is_positive;
-        result.is_always_monotonic &= m.is_always_monotonic;
-        if (i + 1 < originals.size())
-        {
-            if (left_mut != Field())
-                applyFunction(*originals[i], left_mut);
-            if (right_mut != Field())
-                applyFunction(*originals[i], right_mut);
-            if (!m.is_positive)
-                std::swap(left_mut, right_mut);
-            type_ptr = originals[i]->getResultType().get();
-        }
-    }
-    return result;
-}
-
-
-static bool isCompilable(const IFunctionBase & function)
-{
-    if (!canBeNativeType(*function.getResultType()))
-        return false;
-    for (const auto & type : function.getArgumentTypes())
-        if (!canBeNativeType(*type))
-            return false;
-    return function.isCompilable();
-}
-
-static bool isCompilableConstant(const ActionsDAG::Node & node)
-{
-    return node.column && isColumnConst(*node.column) && canBeNativeType(*node.result_type) && node.allow_constant_folding;
-}
-
-static bool isCompilableFunction(const ActionsDAG::Node & node)
-{
-    return node.type == ActionsDAG::ActionType::FUNCTION && isCompilable(*node.function_base);
-}
-
-static LLVMFunction::CompileDAG getCompilableDAG(
-    const ActionsDAG::Node * root,
-    ActionsDAG::NodeRawConstPtrs & children,
-    const std::unordered_set<const ActionsDAG::Node *> & used_in_result)
-{
-    LLVMFunction::CompileDAG dag;
-
-    std::unordered_map<const ActionsDAG::Node *, size_t> positions;
-    struct Frame
-    {
-        const ActionsDAG::Node * node;
-        size_t next_child_to_visit = 0;
-    };
-
-    std::stack<Frame> stack;
-    stack.push(Frame{.node = root});
-
-    while (!stack.empty())
-    {
-        auto & frame = stack.top();
-        bool is_const = isCompilableConstant(*frame.node);
-        bool can_inline = stack.size() == 1 || !used_in_result.count(frame.node);
-        bool is_compilable_function = !is_const && can_inline && isCompilableFunction(*frame.node);
-
-        while (is_compilable_function && frame.next_child_to_visit < frame.node->children.size())
-        {
-            const auto * child = frame.node->children[frame.next_child_to_visit];
-
-            if (positions.count(child))
-                ++frame.next_child_to_visit;
             else
             {
-                stack.emplace(Frame{.node = child});
-                break;
+                __msan_unpoison(result_column->getRawData().data, result_column->getRawData().size);
             }
+
+            #endif
         }
 
-        if (!is_compilable_function || frame.next_child_to_visit == frame.node->children.size())
-        {
-            LLVMFunction::CompileNode node;
-            node.function = frame.node->function_base;
-            node.result_type = frame.node->result_type;
-            node.type = is_const ? LLVMFunction::CompileNode::NodeType::CONSTANT
-                                 : (is_compilable_function ? LLVMFunction::CompileNode::NodeType::FUNCTION
-                                                           : LLVMFunction::CompileNode::NodeType::INPUT);
-
-            if (node.type == LLVMFunction::CompileNode::NodeType::FUNCTION)
-                for (const auto * child : frame.node->children)
-                    node.arguments.push_back(positions[child]);
-
-            if (node.type == LLVMFunction::CompileNode::NodeType::CONSTANT)
-                node.column = frame.node->column;
-
-            if (node.type == LLVMFunction::CompileNode::NodeType::INPUT)
-                children.emplace_back(frame.node);
-
-            positions[frame.node] = dag.size();
-            dag.push_back(std::move(node));
-            stack.pop();
-        }
+        return result_column;
     }
 
-    return dag;
-}
+private:
+    std::string name;
+    JITCompiledFunction function = nullptr;
+};
 
-std::string LLVMFunction::CompileDAG::dump() const
+class LLVMFunction : public IFunctionBaseImpl
 {
-    WriteBufferFromOwnString out;
-    bool first = true;
-    for (const auto & node : *this)
+public:
+
+    explicit LLVMFunction(const CompileDAG & dag_)
+        : name(dag_.dump())
+        , dag(dag_)
     {
-        if (!first)
-            out << " ; ";
-        first = false;
-
-        switch (node.type)
+        for (size_t i = 0; i < dag.getNodesCount(); ++i)
         {
-            case CompileNode::NodeType::CONSTANT:
-            {
-                const auto * column = typeid_cast<const ColumnConst *>(node.column.get());
-                const auto & data = column->getDataColumn();
-                out << node.result_type->getName() << " = " << applyVisitor(FieldVisitorToString(), data[0]);
-                break;
-            }
-            case CompileNode::NodeType::FUNCTION:
-            {
-                out << node.result_type->getName() << " = ";
-                out << node.function->getName() << "(";
+            const auto & node = dag[i];
 
-                for (size_t i = 0; i < node.arguments.size(); ++i)
-                {
-                    if (i)
-                        out << ", ";
-
-                    out << node.arguments[i];
-                }
-
-                out << ")";
-                break;
-            }
-            case CompileNode::NodeType::INPUT:
-            {
-                out << node.result_type->getName();
-                break;
-            }
+            if (node.type == CompileDAG::CompileType::FUNCTION)
+                nested_functions.emplace_back(node.function);
+            else if (node.type == CompileDAG::CompileType::INPUT)
+                argument_types.emplace_back(node.result_type);
         }
+
+        module_info = compileFunction(getJITInstance(), *this);
     }
 
-    return out.str();
-}
-
-UInt128 LLVMFunction::CompileDAG::hash() const
-{
-    SipHash hash;
-    for (const auto & node : *this)
+    ~LLVMFunction() override
     {
-        hash.update(node.type);
-        hash.update(node.result_type->getName());
-
-        switch (node.type)
-        {
-            case CompileNode::NodeType::CONSTANT:
-            {
-                typeid_cast<const ColumnConst *>(node.column.get())->getDataColumn().updateHashWithValue(0, hash);
-                break;
-            }
-            case CompileNode::NodeType::FUNCTION:
-            {
-                hash.update(node.function->getName());
-                for (size_t arg : node.arguments)
-                    hash.update(arg);
-
-                break;
-            }
-            case CompileNode::NodeType::INPUT:
-            {
-                break;
-            }
-        }
+        getJITInstance().deleteCompiledModule(module_info);
     }
 
-    UInt128 result;
-    hash.get128(result.low, result.high);
-    return result;
-}
+    size_t getCompiledSize() const { return module_info.size; }
+
+    bool isCompilable() const override { return true; }
+
+    llvm::Value * compile(llvm::IRBuilderBase & builder, Values values) const override
+    {
+        return dag.compile(builder, values);
+    }
+
+    String getName() const override { return name; }
+
+    const DataTypes & getArgumentTypes() const override { return argument_types; }
+
+    const DataTypePtr & getResultType() const override { return dag.back().result_type; }
+
+    ExecutableFunctionImplPtr prepare(const ColumnsWithTypeAndName &) const override
+    {
+        void * function = getJITInstance().findCompiledFunction(module_info, name);
+
+        if (!function)
+            throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Cannot find compiled function {}", name);
+
+        JITCompiledFunction function_typed = reinterpret_cast<JITCompiledFunction>(function);
+        return std::make_unique<LLVMExecutableFunction>(name, function_typed);
+    }
+
+    bool isDeterministic() const override
+    {
+        for (const auto & f : nested_functions)
+            if (!f->isDeterministic())
+                return false;
+
+        return true;
+    }
+
+    bool isDeterministicInScopeOfQuery() const override
+    {
+        for (const auto & f : nested_functions)
+            if (!f->isDeterministicInScopeOfQuery())
+                return false;
+
+        return true;
+    }
+
+    bool isSuitableForConstantFolding() const override
+    {
+        for (const auto & f : nested_functions)
+            if (!f->isSuitableForConstantFolding())
+                return false;
+
+        return true;
+    }
+
+    bool isInjective(const ColumnsWithTypeAndName & sample_block) const override
+    {
+        for (const auto & f : nested_functions)
+            if (!f->isInjective(sample_block))
+                return false;
+
+        return true;
+    }
+
+    bool hasInformationAboutMonotonicity() const override
+    {
+        for (const auto & f : nested_functions)
+            if (!f->hasInformationAboutMonotonicity())
+                return false;
+
+        return true;
+    }
+
+    Monotonicity getMonotonicityForRange(const IDataType & type, const Field & left, const Field & right) const override
+    {
+        const IDataType * type_ptr = &type;
+        Field left_mut = left;
+        Field right_mut = right;
+        Monotonicity result(true, true, true);
+        /// monotonicity is only defined for unary functions, so the chain must describe a sequence of nested calls
+        for (size_t i = 0; i < nested_functions.size(); ++i)
+        {
+            Monotonicity m = nested_functions[i]->getMonotonicityForRange(*type_ptr, left_mut, right_mut);
+            if (!m.is_monotonic)
+                return m;
+            result.is_positive ^= !m.is_positive;
+            result.is_always_monotonic &= m.is_always_monotonic;
+            if (i + 1 < nested_functions.size())
+            {
+                if (left_mut != Field())
+                    applyFunction(*nested_functions[i], left_mut);
+                if (right_mut != Field())
+                    applyFunction(*nested_functions[i], right_mut);
+                if (!m.is_positive)
+                    std::swap(left_mut, right_mut);
+                type_ptr = nested_functions[i]->getResultType().get();
+            }
+        }
+        return result;
+    }
+
+    static void applyFunction(IFunctionBase & function, Field & value)
+    {
+        const auto & type = function.getArgumentTypes().at(0);
+        ColumnsWithTypeAndName args{{type->createColumnConst(1, value), type, "x" }};
+        auto col = function.execute(args, function.getResultType(), 1);
+        col->get(0, value);
+    }
+
+private:
+    std::string name;
+    CompileDAG dag;
+    DataTypes argument_types;
+    std::vector<FunctionBasePtr> nested_functions;
+    CHJIT::CompiledModuleInfo module_info;
+};
 
 static FunctionBasePtr compile(
-    const LLVMFunction::CompileDAG & dag,
+    const CompileDAG & dag,
     size_t min_count_to_compile_expression)
 {
-    static std::unordered_map<UInt128, UInt32, UInt128Hash> counter;
+    static std::unordered_map<UInt128, UInt64, UInt128Hash> counter;
     static std::mutex mutex;
 
-    struct LLVMTargetInitializer
-    {
-        LLVMTargetInitializer()
-        {
-            llvm::InitializeNativeTarget();
-            llvm::InitializeNativeTargetAsmPrinter();
-            llvm::sys::DynamicLibrary::LoadLibraryPermanently(nullptr);
-        }
-    };
-
-    static LLVMTargetInitializer initializer;
-
     auto hash_key = dag.hash();
     {
         std::lock_guard lock(mutex);
@@ -768,50 +269,194 @@ static FunctionBasePtr compile(
             return nullptr;
     }
 
+    LOG_TRACE(getLogger(), "Try to compile expression {}", dag.dump());
+
     FunctionBasePtr fn;
+
     if (auto * compilation_cache = CompiledExpressionCacheFactory::instance().tryGetCache())
     {
-        std::tie(fn, std::ignore) = compilation_cache->getOrSet(hash_key, [&dag] ()
+        auto [compiled_function, was_inserted] = compilation_cache->getOrSet(hash_key, [&dag] ()
         {
-            Stopwatch watch;
-            FunctionBasePtr result_fn;
-            result_fn = std::make_shared<FunctionBaseAdaptor>(std::make_unique<LLVMFunction>(dag));
-            ProfileEvents::increment(ProfileEvents::CompileExpressionsMicroseconds, watch.elapsedMicroseconds());
-            return result_fn;
+            auto llvm_function = std::make_unique<LLVMFunction>(dag);
+            size_t compiled_size = llvm_function->getCompiledSize();
+
+            FunctionBasePtr llvm_function_wrapper = std::make_shared<FunctionBaseAdaptor>(std::move(llvm_function));
+            CompiledFunction function
+            {
+                .function = llvm_function_wrapper,
+                .compiled_size = compiled_size
+            };
+
+            return std::make_shared<CompiledFunction>(function);
         });
+
+        if (was_inserted)
+            LOG_TRACE(getLogger(),
+                "Put compiled expression {} in cache used cache size {} total cache size {}",
+                compiled_function->function->getName(),
+                compilation_cache->weight(),
+                compilation_cache->maxSize());
+        else
+            LOG_TRACE(getLogger(), "Get compiled expression {} from cache", compiled_function->function->getName());
+
+        fn = compiled_function->function;
     }
     else
     {
-        Stopwatch watch;
         fn = std::make_shared<FunctionBaseAdaptor>(std::make_unique<LLVMFunction>(dag));
-        ProfileEvents::increment(ProfileEvents::CompileExpressionsMicroseconds, watch.elapsedMicroseconds());
     }
 
+    LOG_TRACE(getLogger(), "Use compiled expression {}", fn->getName());
+
     return fn;
 }
 
+static bool isCompilableConstant(const ActionsDAG::Node & node)
+{
+    return node.column && isColumnConst(*node.column) && canBeNativeType(*node.result_type) && node.allow_constant_folding;
+}
+
+static bool checkIfFunctionIsComparisonEdgeCase(const ActionsDAG::Node & node, const IFunctionBase & impl)
+{
+    static std::unordered_set<std::string_view> comparison_functions
+    {
+        NameEquals::name,
+        NameNotEquals::name,
+        NameLess::name,
+        NameGreater::name,
+        NameLessOrEquals::name,
+        NameGreaterOrEquals::name
+    };
+
+    auto it = comparison_functions.find(impl.getName());
+    if (it == comparison_functions.end())
+        return false;
+
+    const auto * lhs_node = node.children[0];
+    const auto * rhs_node = node.children[1];
+
+    return lhs_node == rhs_node && !isTuple(lhs_node->result_type);
+}
+
+static bool isCompilableFunction(const ActionsDAG::Node & node)
+{
+    if (node.type != ActionsDAG::ActionType::FUNCTION)
+        return false;
+
+    auto & function = *node.function_base;
+
+    if (!canBeNativeType(*function.getResultType()))
+        return false;
+
+    for (const auto & type : function.getArgumentTypes())
+    {
+        if (!canBeNativeType(*type))
+            return false;
+    }
+
+    if (checkIfFunctionIsComparisonEdgeCase(node, *node.function_base))
+        return false;
+
+    return function.isCompilable();
+}
+
+static bool isCompilableInput(const ActionsDAG::Node & node)
+{
+    return node.type == ActionsDAG::ActionType::INPUT || node.type == ActionsDAG::ActionType::ALIAS;
+}
+
+static CompileDAG getCompilableDAG(
+    const ActionsDAG::Node * root,
+    ActionsDAG::NodeRawConstPtrs & children)
+{
+    /// Extract CompileDAG from root actions dag node, it is important that each root child is compilable.
+
+    CompileDAG dag;
+
+    std::unordered_map<const ActionsDAG::Node *, size_t> visited_node_to_compile_dag_position;
+
+    struct Frame
+    {
+        const ActionsDAG::Node * node;
+        size_t next_child_to_visit = 0;
+    };
+
+    std::stack<Frame> stack;
+    stack.emplace(Frame{.node = root});
+
+    while (!stack.empty())
+    {
+        auto & frame = stack.top();
+        const auto * node = frame.node;
+
+        while (frame.next_child_to_visit < node->children.size())
+        {
+            const auto & child = node->children[frame.next_child_to_visit];
+
+            if (visited_node_to_compile_dag_position.contains(child))
+            {
+                ++frame.next_child_to_visit;
+                continue;
+            }
+
+            stack.emplace(Frame{.node = child});
+            break;
+        }
+
+        bool all_children_visited = frame.next_child_to_visit == node->children.size();
+
+        if (!all_children_visited)
+            continue;
+
+        CompileDAG::Node compile_node;
+        compile_node.function = node->function_base;
+        compile_node.result_type = node->result_type;
+
+        if (isCompilableConstant(*node))
+        {
+            compile_node.type = CompileDAG::CompileType::CONSTANT;
+            compile_node.column = node->column;
+        }
+        else if (node->type == ActionsDAG::ActionType::FUNCTION)
+        {
+            compile_node.type = CompileDAG::CompileType::FUNCTION;
+            for (const auto * child : node->children)
+                compile_node.arguments.push_back(visited_node_to_compile_dag_position[child]);
+        }
+        else
+        {
+            compile_node.type = CompileDAG::CompileType::INPUT;
+            children.emplace_back(node);
+        }
+
+        visited_node_to_compile_dag_position[node] = dag.getNodesCount();
+
+        dag.addNode(std::move(compile_node));
+        stack.pop();
+    }
+
+    return dag;
+}
+
 void ActionsDAG::compileFunctions(size_t min_count_to_compile_expression)
 {
     struct Data
     {
-        bool is_compilable = false;
+        bool is_compilable_in_isolation = false;
+        bool all_children_compilable = false;
         bool all_parents_compilable = true;
-        size_t num_inlineable_nodes = 0;
+        size_t children_size = 0;
     };
 
-    std::unordered_map<const Node *, Data> data;
-    std::unordered_set<const Node *> used_in_result;
+    std::unordered_map<const Node *, Data> node_to_data;
+
+    /// Check which nodes can be compiled in isolation
 
     for (const auto & node : nodes)
-        data[&node].is_compilable = isCompilableConstant(node) || isCompilableFunction(node);
-
-    for (const auto & node : nodes)
-        if (!data[&node].is_compilable)
-            for (const auto * child : node.children)
-                data[child].all_parents_compilable = false;
-
-    for (const auto * node : index)
-        used_in_result.insert(node);
+    {
+        bool node_is_compilable_in_isolation = isCompilableConstant(node) || isCompilableFunction(node) || isCompilableInput(node);
+        node_to_data[&node].is_compilable_in_isolation = node_is_compilable_in_isolation;
+    }
 
     struct Frame
     {
@@ -820,83 +465,124 @@ void ActionsDAG::compileFunctions(size_t min_count_to_compile_expression)
     };
 
     std::stack<Frame> stack;
-    std::unordered_set<const Node *> visited;
+    std::unordered_set<const Node *> visited_nodes;
+
+    /** Algorithm is to iterate over each node in ActionsDAG, and update node compilable status.
+      * Node is compilable if all its children are compilable and node is also compilable.
+      * After this procedure data for each node is initialized.
+      */
 
     for (auto & node : nodes)
     {
-        if (visited.count(&node))
+        if (visited_nodes.contains(&node))
             continue;
 
         stack.emplace(Frame{.node = &node});
+
         while (!stack.empty())
         {
-            auto & frame = stack.top();
+            auto & current_frame = stack.top();
+            auto & current_node = current_frame.node;
 
-            while (frame.next_child_to_visit < frame.node->children.size())
+            while (current_frame.next_child_to_visit < current_node->children.size())
             {
-                const auto * child = frame.node->children[frame.next_child_to_visit];
+                const auto & child = node.children[current_frame.next_child_to_visit];
 
-                if (visited.count(child))
-                    ++frame.next_child_to_visit;
-                else
+                if (visited_nodes.contains(child))
                 {
-                    stack.emplace(Frame{.node = child});
-                    break;
-                }
-            }
-
-            if (frame.next_child_to_visit == frame.node->children.size())
-            {
-                auto & cur = data[frame.node];
-                if (cur.is_compilable)
-                {
-                    cur.num_inlineable_nodes = 1;
-
-                    if (!isCompilableConstant(*frame.node))
-                        for (const auto * child : frame.node->children)
-                            if (!used_in_result.count(child))
-                                cur.num_inlineable_nodes += data[child].num_inlineable_nodes;
-
-                    /// Check if we should inline current node.
-                    bool should_compile = true;
-
-                    /// Inline parents instead of node is possible.
-                    if (!used_in_result.count(frame.node) && cur.all_parents_compilable)
-                        should_compile = false;
-
-                    /// There is no reason to inline single node.
-                    /// The result of compiling function in isolation is pretty much the same as its `execute` method.
-                    if (cur.num_inlineable_nodes <= 1)
-                        should_compile = false;
-
-                    if (should_compile)
-                    {
-                        NodeRawConstPtrs new_children;
-                        auto dag = getCompilableDAG(frame.node, new_children, used_in_result);
-
-                        if (auto fn = compile(dag, min_count_to_compile_expression))
-                        {
-                            /// Replace current node to compilable function.
-
-                            ColumnsWithTypeAndName arguments;
-                            arguments.reserve(new_children.size());
-                            for (const auto * child : new_children)
-                                arguments.emplace_back(child->column, child->result_type, child->result_name);
-
-                            auto * frame_node = const_cast<Node *>(frame.node);
-                            frame_node->type = ActionsDAG::ActionType::FUNCTION;
-                            frame_node->function_base = fn;
-                            frame_node->function = fn->prepare(arguments);
-                            frame_node->children.swap(new_children);
-                            frame_node->is_function_compiled = true;
-                            frame_node->column = nullptr; /// Just in case.
-                        }
-                    }
+                    ++current_frame.next_child_to_visit;
+                    continue;
                 }
 
-                visited.insert(frame.node);
-                stack.pop();
+                stack.emplace(Frame{.node=child});
+                break;
             }
+
+            bool all_children_visited = current_frame.next_child_to_visit == current_node->children.size();
+
+            if (!all_children_visited)
+                continue;
+
+            auto & current_node_data = node_to_data[current_node];
+
+            current_node_data.all_children_compilable = true;
+
+            if (current_node_data.is_compilable_in_isolation)
+            {
+                for (const auto * child : current_node->children)
+                {
+                    current_node_data.all_children_compilable &= node_to_data[child].is_compilable_in_isolation;
+                    current_node_data.all_children_compilable &= node_to_data[child].all_children_compilable;
+                    current_node_data.children_size += node_to_data[child].children_size;
+                }
+
+                current_node_data.children_size += current_node->children.size();
+            }
+
+            visited_nodes.insert(current_node);
+            stack.pop();
+        }
+    }
+
+    for (const auto & node : nodes)
+    {
+        auto & node_data = node_to_data[&node];
+        bool is_compilable = node_data.is_compilable_in_isolation && node_data.all_children_compilable;
+
+        for (const auto & child : node.children)
+            node_to_data[child].all_parents_compilable &= is_compilable;
+    }
+
+    for (const auto & node : index)
+    {
+        /// Force result nodes to compile
+        node_to_data[node].all_parents_compilable = false;
+    }
+
+    std::vector<Node *> nodes_to_compile;
+
+    for (auto & node : nodes)
+    {
+        auto & node_data = node_to_data[&node];
+
+        bool node_is_valid_for_compilation = !isCompilableConstant(node) && node.children.size() > 1;
+        bool can_be_compiled = node_data.is_compilable_in_isolation && node_data.all_children_compilable && node_is_valid_for_compilation;
+
+        /// If all parents are compilable then this node should not be standalone compiled
+        bool should_compile = can_be_compiled && !node_data.all_parents_compilable;
+
+        if (!should_compile)
+            continue;
+
+        nodes_to_compile.emplace_back(&node);
+    }
+
+    /** Sort nodes before compilation using their children size to avoid compiling subexpression before compile parent expression.
+      * This is needed to avoid compiling expression more than once with different names because of compilation order.
+      */
+    std::sort(nodes_to_compile.begin(), nodes_to_compile.end(), [&](const Node * lhs, const Node * rhs) { return node_to_data[lhs].children_size > node_to_data[rhs].children_size; });
+
+    for (auto & node : nodes_to_compile)
+    {
+        NodeRawConstPtrs new_children;
+        auto dag = getCompilableDAG(node, new_children);
+
+        if (dag.getInputNodesCount() == 0)
+            continue;
+
+        if (auto fn = compile(dag, min_count_to_compile_expression))
+        {
+            ColumnsWithTypeAndName arguments;
+            arguments.reserve(new_children.size());
+            for (const auto * child : new_children)
+                arguments.emplace_back(child->column, child->result_type, child->result_name);
+
+            node->type = ActionsDAG::ActionType::FUNCTION;
+            node->function_base = fn;
+            node->function = fn->prepare(arguments);
+            node->children.swap(new_children);
+            node->is_function_compiled = true;
+            node->column = nullptr;
         }
     }
 }
diff --git a/src/Interpreters/ExpressionJIT.h b/src/Interpreters/ExpressionJIT.h
index 793c19b4fe7..b7a7dd64cdd 100644
--- a/src/Interpreters/ExpressionJIT.h
+++ b/src/Interpreters/ExpressionJIT.h
@@ -5,98 +5,35 @@
 #endif
 
 #if USE_EMBEDDED_COMPILER
-#    include <set>
 #    include <Functions/IFunctionImpl.h>
-#    include <Interpreters/Context.h>
-#    include <Interpreters/ExpressionActions.h>
 #    include <Common/LRUCache.h>
+#    include <Common/HashTable/Hash.h>
 
 
 namespace DB
 {
 
-using CompilableExpression = std::function<llvm::Value * (llvm::IRBuilderBase &, const ValuePlaceholders &)>;
-
-struct LLVMModuleState;
-
-class LLVMFunction : public IFunctionBaseImpl
+struct CompiledFunction
 {
-    std::string name;
-    DataTypes arg_types;
+    FunctionBasePtr function;
+    size_t compiled_size;
+};
 
-    std::vector<FunctionBasePtr> originals;
-    CompilableExpression expression;
-
-    std::unique_ptr<LLVMModuleState> module_state;
-
-public:
-
-    /// LLVMFunction is a compiled part of ActionsDAG.
-    /// We store this part as independent DAG with minial required information to compile it.
-    struct CompileNode
+struct CompiledFunctionWeightFunction
+{
+    size_t operator()(const CompiledFunction & compiled_function) const
     {
-        enum class NodeType
-        {
-            INPUT = 0,
-            CONSTANT = 1,
-            FUNCTION = 2,
-        };
-
-        NodeType type;
-        DataTypePtr result_type;
-
-        /// For CONSTANT
-        ColumnPtr column;
-
-        /// For FUNCTION
-        FunctionBasePtr function;
-        std::vector<size_t> arguments;
-    };
-
-    /// DAG is represented as list of nodes stored in in-order traverse order.
-    /// Expression (a + 1) + (b + 1) will be represented like chain: a, 1, a + 1, b, b + 1, (a + 1) + (b + 1).
-    struct CompileDAG : public std::vector<CompileNode>
-    {
-        std::string dump() const;
-        UInt128 hash() const;
-    };
-
-    explicit LLVMFunction(const CompileDAG & dag);
-
-    bool isCompilable() const override { return true; }
-
-    llvm::Value * compile(llvm::IRBuilderBase & builder, ValuePlaceholders values) const override;
-
-    String getName() const override { return name; }
-
-    const DataTypes & getArgumentTypes() const override { return arg_types; }
-
-    const DataTypePtr & getResultType() const override { return originals.back()->getResultType(); }
-
-    ExecutableFunctionImplPtr prepare(const ColumnsWithTypeAndName &) const override;
-
-    bool isDeterministic() const override;
-
-    bool isDeterministicInScopeOfQuery() const override;
-
-    bool isSuitableForConstantFolding() const override;
-
-    bool isInjective(const ColumnsWithTypeAndName & sample_block) const override;
-
-    bool hasInformationAboutMonotonicity() const override;
-
-    Monotonicity getMonotonicityForRange(const IDataType & type, const Field & left, const Field & right) const override;
-
-    const LLVMModuleState * getLLVMModuleState() const { return module_state.get(); }
+        return compiled_function.compiled_size;
+    }
 };
 
 /** This child of LRUCache breaks one of it's invariants: total weight may be changed after insertion.
  * We have to do so, because we don't known real memory consumption of generated LLVM code for every function.
  */
-class CompiledExpressionCache : public LRUCache<UInt128, IFunctionBase, UInt128Hash>
+class CompiledExpressionCache : public LRUCache<UInt128, CompiledFunction, UInt128Hash, CompiledFunctionWeightFunction>
 {
 public:
-    using Base = LRUCache<UInt128, IFunctionBase, UInt128Hash>;
+    using Base = LRUCache<UInt128, CompiledFunction, UInt128Hash, CompiledFunctionWeightFunction>;
     using Base::Base;
 };
 
diff --git a/src/Interpreters/GroupByFunctionKeysVisitor.h b/src/Interpreters/GroupByFunctionKeysVisitor.h
index 0c745be33ed..855723307d6 100644
--- a/src/Interpreters/GroupByFunctionKeysVisitor.h
+++ b/src/Interpreters/GroupByFunctionKeysVisitor.h
@@ -97,7 +97,7 @@ public:
         KeepFunctionVisitor::Data keep_data{data.key_names_to_keep, keep_key};
         KeepFunctionVisitor(keep_data).visit(function_node->arguments);
 
-        if (!keep_key)
+        if (!keep_key) //-V547
             (data.key_names_to_keep).erase(function_node->getColumnName());
     }
 
diff --git a/src/Interpreters/HashJoin.cpp b/src/Interpreters/HashJoin.cpp
index d6163ff773a..51373ea49d4 100644
--- a/src/Interpreters/HashJoin.cpp
+++ b/src/Interpreters/HashJoin.cpp
@@ -384,7 +384,7 @@ template <typename Value, typename Mapped> struct KeyGetterForTypeImpl<HashJoin:
 };
 template <typename Value, typename Mapped> struct KeyGetterForTypeImpl<HashJoin::Type::keys256, Value, Mapped>
 {
-    using Type = ColumnsHashing::HashMethodKeysFixed<Value, DummyUInt256, Mapped, false, false, false, use_offset>;
+    using Type = ColumnsHashing::HashMethodKeysFixed<Value, UInt256, Mapped, false, false, false, use_offset>;
 };
 template <typename Value, typename Mapped> struct KeyGetterForTypeImpl<HashJoin::Type::hashed, Value, Mapped>
 {
diff --git a/src/Interpreters/HashJoin.h b/src/Interpreters/HashJoin.h
index c0a699d0a12..5ec8ed92f10 100644
--- a/src/Interpreters/HashJoin.h
+++ b/src/Interpreters/HashJoin.h
@@ -224,15 +224,15 @@ public:
     template <typename Mapped>
     struct MapsTemplate
     {
-        std::unique_ptr<FixedHashMap<UInt8, Mapped>>   key8;
-        std::unique_ptr<FixedHashMap<UInt16, Mapped>> key16;
-        std::unique_ptr<HashMap<UInt32, Mapped, HashCRC32<UInt32>>>                     key32;
-        std::unique_ptr<HashMap<UInt64, Mapped, HashCRC32<UInt64>>>                     key64;
-        std::unique_ptr<HashMapWithSavedHash<StringRef, Mapped>>                        key_string;
-        std::unique_ptr<HashMapWithSavedHash<StringRef, Mapped>>                        key_fixed_string;
-        std::unique_ptr<HashMap<UInt128, Mapped, UInt128HashCRC32>>                     keys128;
-        std::unique_ptr<HashMap<DummyUInt256, Mapped, UInt256HashCRC32>>                keys256;
-        std::unique_ptr<HashMap<UInt128, Mapped, UInt128TrivialHash>>                   hashed;
+        std::unique_ptr<FixedHashMap<UInt8, Mapped>>                  key8;
+        std::unique_ptr<FixedHashMap<UInt16, Mapped>>                 key16;
+        std::unique_ptr<HashMap<UInt32, Mapped, HashCRC32<UInt32>>>   key32;
+        std::unique_ptr<HashMap<UInt64, Mapped, HashCRC32<UInt64>>>   key64;
+        std::unique_ptr<HashMapWithSavedHash<StringRef, Mapped>>      key_string;
+        std::unique_ptr<HashMapWithSavedHash<StringRef, Mapped>>      key_fixed_string;
+        std::unique_ptr<HashMap<UInt128, Mapped, UInt128HashCRC32>>   keys128;
+        std::unique_ptr<HashMap<UInt256, Mapped, UInt256HashCRC32>>   keys256;
+        std::unique_ptr<HashMap<UInt128, Mapped, UInt128TrivialHash>> hashed;
 
         void create(Type which)
         {
diff --git a/src/Interpreters/InJoinSubqueriesPreprocessor.cpp b/src/Interpreters/InJoinSubqueriesPreprocessor.cpp
index 8dc5d95bd89..e173f1554f4 100644
--- a/src/Interpreters/InJoinSubqueriesPreprocessor.cpp
+++ b/src/Interpreters/InJoinSubqueriesPreprocessor.cpp
@@ -178,7 +178,7 @@ private:
             std::vector<ASTPtr> renamed;
             NonGlobalTableVisitor::Data table_data(data.getContext(), data.checker, renamed, &node, nullptr);
             NonGlobalTableVisitor(table_data).visit(subquery);
-            if (!renamed.empty())
+            if (!renamed.empty()) //-V547
                 data.renamed_tables.emplace_back(subquery, std::move(renamed));
         }
     }
@@ -196,7 +196,7 @@ private:
                 std::vector<ASTPtr> renamed;
                 NonGlobalTableVisitor::Data table_data(data.getContext(), data.checker, renamed, nullptr, table_join);
                 NonGlobalTableVisitor(table_data).visit(subquery);
-                if (!renamed.empty())
+                if (!renamed.empty()) //-V547
                     data.renamed_tables.emplace_back(subquery, std::move(renamed));
             }
         }
diff --git a/src/Interpreters/InterpreterShowAccessEntitiesQuery.cpp b/src/Interpreters/InterpreterShowAccessEntitiesQuery.cpp
index afd685ea983..c2c2305f976 100644
--- a/src/Interpreters/InterpreterShowAccessEntitiesQuery.cpp
+++ b/src/Interpreters/InterpreterShowAccessEntitiesQuery.cpp
@@ -33,9 +33,11 @@ String InterpreterShowAccessEntitiesQuery::getRewrittenQuery() const
 {
     auto & query = query_ptr->as<ASTShowAccessEntitiesQuery &>();
     query.replaceEmptyDatabase(getContext()->getCurrentDatabase());
+
     String origin;
     String expr = "*";
-    String filter, order;
+    String filter;
+    String order;
 
     switch (query.type)
     {
@@ -43,8 +45,10 @@ String InterpreterShowAccessEntitiesQuery::getRewrittenQuery() const
         {
             origin = "row_policies";
             expr = "name";
+
             if (!query.short_name.empty())
-                filter += String{filter.empty() ? "" : " AND "} + "short_name = " + quoteString(query.short_name);
+                filter = "short_name = " + quoteString(query.short_name);
+
             if (query.database_and_table_name)
             {
                 const String & database = query.database_and_table_name->first;
diff --git a/src/Interpreters/InterpreterWatchQuery.cpp b/src/Interpreters/InterpreterWatchQuery.cpp
index 84959f2f624..edf0f37c00e 100644
--- a/src/Interpreters/InterpreterWatchQuery.cpp
+++ b/src/Interpreters/InterpreterWatchQuery.cpp
@@ -77,7 +77,7 @@ BlockIO InterpreterWatchQuery::execute()
     if (IBlockInputStream * stream = dynamic_cast<IBlockInputStream *>(streams[0].get()))
     {
         StreamLocalLimits limits;
-        limits.mode = LimitsMode::LIMITS_CURRENT;
+        limits.mode = LimitsMode::LIMITS_CURRENT; //-V1048
         limits.size_limits.max_rows = settings.max_result_rows;
         limits.size_limits.max_bytes = settings.max_result_bytes;
         limits.size_limits.overflow_mode = settings.result_overflow_mode;
diff --git a/src/Interpreters/JIT/CHJIT.cpp b/src/Interpreters/JIT/CHJIT.cpp
new file mode 100644
index 00000000000..72a2ede5853
--- /dev/null
+++ b/src/Interpreters/JIT/CHJIT.cpp
@@ -0,0 +1,382 @@
+#include "CHJIT.h"
+
+#if USE_EMBEDDED_COMPILER
+
+#include <llvm/Analysis/TargetTransformInfo.h>
+#include <llvm/IR/BasicBlock.h>
+#include <llvm/IR/DataLayout.h>
+#include <llvm/IR/DerivedTypes.h>
+#include <llvm/IR/Function.h>
+#include <llvm/IR/IRBuilder.h>
+#include <llvm/IR/Mangler.h>
+#include <llvm/IR/Type.h>
+#include <llvm/IR/LegacyPassManager.h>
+#include <llvm/ExecutionEngine/JITSymbol.h>
+#include <llvm/ExecutionEngine/SectionMemoryManager.h>
+#include <llvm/ExecutionEngine/JITEventListener.h>
+#include <llvm/MC/SubtargetFeature.h>
+#include <llvm/Support/DynamicLibrary.h>
+#include <llvm/Support/Host.h>
+#include <llvm/Support/TargetRegistry.h>
+#include <llvm/Support/TargetSelect.h>
+#include <llvm/Transforms/IPO/PassManagerBuilder.h>
+#include <llvm/Support/SmallVectorMemoryBuffer.h>
+
+#include <Common/Exception.h>
+
+namespace DB
+{
+
+namespace ErrorCodes
+{
+    extern const int CANNOT_COMPILE_CODE;
+    extern const int LOGICAL_ERROR;
+}
+
+/** Simple module to object file compiler.
+  * Result object cannot be used as machine code directly, it should be passed to linker.
+  */
+class JITCompiler
+{
+public:
+
+    explicit JITCompiler(llvm::TargetMachine &target_machine_)
+    : target_machine(target_machine_)
+    {
+    }
+
+    std::unique_ptr<llvm::MemoryBuffer> compile(llvm::Module & module)
+    {
+        auto materialize_error = module.materializeAll();
+        if (materialize_error)
+        {
+            std::string error_message;
+            handleAllErrors(std::move(materialize_error),
+                [&](const llvm::ErrorInfoBase & error_info) { error_message = error_info.message(); });
+
+            throw Exception(ErrorCodes::CANNOT_COMPILE_CODE, "Cannot materialize module: {}", error_message);
+        }
+
+        llvm::SmallVector<char, 4096> object_buffer;
+
+        llvm::raw_svector_ostream object_stream(object_buffer);
+        llvm::legacy::PassManager pass_manager;
+        llvm::MCContext * machine_code_context = nullptr;
+
+        if (target_machine.addPassesToEmitMC(pass_manager, machine_code_context, object_stream))
+            throw Exception(ErrorCodes::CANNOT_COMPILE_CODE, "MachineCode is not supported for the platform");
+
+        pass_manager.run(module);
+
+        std::unique_ptr<llvm::MemoryBuffer> compiled_object_buffer = std::make_unique<llvm::SmallVectorMemoryBuffer>(
+            std::move(object_buffer), "<in memory object compiled from " + module.getModuleIdentifier() + ">");
+
+        return compiled_object_buffer;
+    }
+
+    ~JITCompiler() = default;
+
+private:
+    llvm::TargetMachine & target_machine;
+};
+
+/** MemoryManager for module.
+  * Keep total allocated size during RuntimeDyld linker execution.
+  * Actual compiled code memory is stored in llvm::SectionMemoryManager member, we cannot use ZeroBase optimization here
+  * because it is required for llvm::SectionMemoryManager::MemoryMapper to live longer than llvm::SectionMemoryManager.
+  */
+class JITModuleMemoryManager
+{
+    class DefaultMMapper final : public llvm::SectionMemoryManager::MemoryMapper
+    {
+    public:
+        llvm::sys::MemoryBlock allocateMappedMemory(
+            llvm::SectionMemoryManager::AllocationPurpose Purpose [[maybe_unused]],
+            size_t NumBytes,
+            const llvm::sys::MemoryBlock * const NearBlock,
+            unsigned Flags,
+            std::error_code & EC) override
+        {
+            auto allocated_memory_block = llvm::sys::Memory::allocateMappedMemory(NumBytes, NearBlock, Flags, EC);
+            allocated_size += allocated_memory_block.allocatedSize();
+            return allocated_memory_block;
+        }
+
+        std::error_code protectMappedMemory(const llvm::sys::MemoryBlock & Block, unsigned Flags) override
+        {
+            return llvm::sys::Memory::protectMappedMemory(Block, Flags);
+        }
+
+        std::error_code releaseMappedMemory(llvm::sys::MemoryBlock & M) override { return llvm::sys::Memory::releaseMappedMemory(M); }
+
+        size_t allocated_size = 0;
+    };
+
+public:
+    JITModuleMemoryManager() : manager(&mmaper) { }
+
+    inline size_t getAllocatedSize() const { return mmaper.allocated_size; }
+
+    inline llvm::SectionMemoryManager & getManager() { return manager; }
+
+private:
+    DefaultMMapper mmaper;
+    llvm::SectionMemoryManager manager;
+};
+
+class JITSymbolResolver : public llvm::LegacyJITSymbolResolver
+{
+public:
+    llvm::JITSymbol findSymbolInLogicalDylib(const std::string &) override { return nullptr; }
+
+    llvm::JITSymbol findSymbol(const std::string & Name) override
+    {
+        auto address_it = symbol_name_to_symbol_address.find(Name);
+        if (address_it == symbol_name_to_symbol_address.end())
+            throw Exception(ErrorCodes::CANNOT_COMPILE_CODE, "Could not find symbol {}", Name);
+
+        uint64_t symbol_address = reinterpret_cast<uint64_t>(address_it->second);
+        auto jit_symbol = llvm::JITSymbol(symbol_address, llvm::JITSymbolFlags::None);
+
+        return jit_symbol;
+    }
+
+    void registerSymbol(const std::string & symbol_name, void * symbol) { symbol_name_to_symbol_address[symbol_name] = symbol; }
+
+    ~JITSymbolResolver() override = default;
+
+private:
+    std::unordered_map<std::string, void *> symbol_name_to_symbol_address;
+};
+
+/// GDB JITEventListener. Can be used if result machine code need to be debugged.
+// class JITEventListener
+// {
+// public:
+//     JITEventListener()
+//         : gdb_listener(llvm::JITEventListener::createGDBRegistrationListener())
+//     {}
+
+//     void notifyObjectLoaded(
+//         llvm::JITEventListener::ObjectKey object_key,
+//         const llvm::object::ObjectFile & object_file,
+//         const llvm::RuntimeDyld::LoadedObjectInfo & loaded_object_Info)
+//     {
+//         gdb_listener->notifyObjectLoaded(object_key, object_file, loaded_object_Info);
+//     }
+
+//     void notifyFreeingObject(llvm::JITEventListener::ObjectKey object_key)
+//     {
+//         gdb_listener->notifyFreeingObject(object_key);
+//     }
+
+// private:
+//     llvm::JITEventListener * gdb_listener = nullptr;
+// };
+
+CHJIT::CHJIT()
+    : machine(getTargetMachine())
+    , layout(machine->createDataLayout())
+    , compiler(std::make_unique<JITCompiler>(*machine))
+    , symbol_resolver(std::make_unique<JITSymbolResolver>())
+{
+    /// Define common symbols that can be generated during compilation
+    /// Necessary for valid linker symbol resolution
+    symbol_resolver->registerSymbol("memset", reinterpret_cast<void *>(&memset));
+    symbol_resolver->registerSymbol("memcpy", reinterpret_cast<void *>(&memcpy));
+    symbol_resolver->registerSymbol("memcmp", reinterpret_cast<void *>(&memcmp));
+}
+
+CHJIT::~CHJIT() = default;
+
+CHJIT::CompiledModuleInfo CHJIT::compileModule(std::function<void (llvm::Module &)> compile_function)
+{
+    std::lock_guard<std::mutex> lock(jit_lock);
+
+    auto module = createModuleForCompilation();
+    compile_function(*module);
+    auto module_info = compileModule(std::move(module));
+
+    ++current_module_key;
+    return module_info;
+}
+
+std::unique_ptr<llvm::Module> CHJIT::createModuleForCompilation()
+{
+    std::unique_ptr<llvm::Module> module = std::make_unique<llvm::Module>("jit" + std::to_string(current_module_key), context);
+    module->setDataLayout(layout);
+    module->setTargetTriple(machine->getTargetTriple().getTriple());
+
+    return module;
+}
+
+CHJIT::CompiledModuleInfo CHJIT::compileModule(std::unique_ptr<llvm::Module> module)
+{
+    runOptimizationPassesOnModule(*module);
+
+    auto buffer = compiler->compile(*module);
+
+    llvm::Expected<std::unique_ptr<llvm::object::ObjectFile>> object = llvm::object::ObjectFile::createObjectFile(*buffer);
+
+    if (!object)
+    {
+        std::string error_message;
+        handleAllErrors(object.takeError(), [&](const llvm::ErrorInfoBase & error_info) { error_message = error_info.message(); });
+
+        throw Exception(ErrorCodes::CANNOT_COMPILE_CODE, "Cannot create object file from compiled buffer: {}", error_message);
+    }
+
+    std::unique_ptr<JITModuleMemoryManager> module_memory_manager = std::make_unique<JITModuleMemoryManager>();
+    llvm::RuntimeDyld dynamic_linker = {module_memory_manager->getManager(), *symbol_resolver};
+
+    std::unique_ptr<llvm::RuntimeDyld::LoadedObjectInfo> linked_object = dynamic_linker.loadObject(*object.get());
+
+    dynamic_linker.resolveRelocations();
+    module_memory_manager->getManager().finalizeMemory();
+
+    CompiledModuleInfo module_info;
+
+    for (const auto & function : *module)
+    {
+        if (function.isDeclaration())
+            continue;
+
+        auto function_name = std::string(function.getName());
+
+        auto mangled_name = getMangledName(function_name);
+        auto jit_symbol = dynamic_linker.getSymbol(mangled_name);
+
+        if (!jit_symbol)
+            throw Exception(ErrorCodes::CANNOT_COMPILE_CODE, "DynamicLinker could not found symbol {} after compilation", function_name);
+
+        auto * jit_symbol_address = reinterpret_cast<void *>(jit_symbol.getAddress());
+
+        std::string symbol_name = std::to_string(current_module_key) + '_' + function_name;
+        name_to_symbol[symbol_name] = jit_symbol_address;
+        module_info.compiled_functions.emplace_back(std::move(function_name));
+    }
+
+    module_info.size = module_memory_manager->getAllocatedSize();
+    module_info.identifier = current_module_key;
+
+    module_identifier_to_memory_manager[current_module_key] = std::move(module_memory_manager);
+
+    compiled_code_size.fetch_add(module_info.size, std::memory_order_relaxed);
+
+    return module_info;
+}
+
+void CHJIT::deleteCompiledModule(const CHJIT::CompiledModuleInfo & module_info)
+{
+    std::lock_guard<std::mutex> lock(jit_lock);
+
+    auto module_it = module_identifier_to_memory_manager.find(module_info.identifier);
+    if (module_it == module_identifier_to_memory_manager.end())
+        throw Exception(ErrorCodes::LOGICAL_ERROR, "There is no compiled module with identifier {}", module_info.identifier);
+
+    for (const auto & function : module_info.compiled_functions)
+        name_to_symbol.erase(function);
+
+    module_identifier_to_memory_manager.erase(module_it);
+    compiled_code_size.fetch_sub(module_info.size, std::memory_order_relaxed);
+}
+
+void * CHJIT::findCompiledFunction(const CompiledModuleInfo & module_info, const std::string & function_name) const
+{
+    std::lock_guard<std::mutex> lock(jit_lock);
+
+    std::string symbol_name = std::to_string(module_info.identifier) + '_' + function_name;
+    auto it = name_to_symbol.find(symbol_name);
+    if (it != name_to_symbol.end())
+        return it->second;
+
+    return nullptr;
+}
+
+void CHJIT::registerExternalSymbol(const std::string & symbol_name, void * address)
+{
+    std::lock_guard<std::mutex> lock(jit_lock);
+    symbol_resolver->registerSymbol(symbol_name, address);
+}
+
+std::string CHJIT::getMangledName(const std::string & name_to_mangle) const
+{
+    std::string mangled_name;
+    llvm::raw_string_ostream mangled_name_stream(mangled_name);
+    llvm::Mangler::getNameWithPrefix(mangled_name_stream, name_to_mangle, layout);
+    mangled_name_stream.flush();
+
+    return mangled_name;
+}
+
+void CHJIT::runOptimizationPassesOnModule(llvm::Module & module) const
+{
+    llvm::PassManagerBuilder pass_manager_builder;
+    llvm::legacy::PassManager mpm;
+    llvm::legacy::FunctionPassManager fpm(&module);
+    pass_manager_builder.OptLevel = 3;
+    pass_manager_builder.SLPVectorize = true;
+    pass_manager_builder.LoopVectorize = true;
+    pass_manager_builder.RerollLoops = true;
+    pass_manager_builder.VerifyInput = true;
+    pass_manager_builder.VerifyOutput = true;
+    machine->adjustPassManager(pass_manager_builder);
+
+    fpm.add(llvm::createTargetTransformInfoWrapperPass(machine->getTargetIRAnalysis()));
+    mpm.add(llvm::createTargetTransformInfoWrapperPass(machine->getTargetIRAnalysis()));
+
+    pass_manager_builder.populateFunctionPassManager(fpm);
+    pass_manager_builder.populateModulePassManager(mpm);
+
+    fpm.doInitialization();
+    for (auto & function : module)
+        fpm.run(function);
+    fpm.doFinalization();
+
+    mpm.run(module);
+}
+
+std::unique_ptr<llvm::TargetMachine> CHJIT::getTargetMachine()
+{
+    static std::once_flag llvm_target_initialized;
+    std::call_once(llvm_target_initialized, []()
+    {
+        llvm::InitializeNativeTarget();
+        llvm::InitializeNativeTargetAsmPrinter();
+        llvm::sys::DynamicLibrary::LoadLibraryPermanently(nullptr);
+    });
+
+    std::string error;
+    auto cpu = llvm::sys::getHostCPUName();
+    auto triple = llvm::sys::getProcessTriple();
+    const auto * target = llvm::TargetRegistry::lookupTarget(triple, error);
+    if (!target)
+        throw Exception(ErrorCodes::CANNOT_COMPILE_CODE, "Cannot find target triple {} error: {}", triple, error);
+
+    llvm::SubtargetFeatures features;
+    llvm::StringMap<bool> feature_map;
+    if (llvm::sys::getHostCPUFeatures(feature_map))
+        for (auto & f : feature_map)
+            features.AddFeature(f.first(), f.second);
+
+    llvm::TargetOptions options;
+
+    bool jit = true;
+    auto * target_machine = target->createTargetMachine(triple,
+        cpu,
+        features.getString(),
+        options,
+        llvm::None,
+        llvm::None,
+        llvm::CodeGenOpt::Aggressive,
+        jit);
+
+    if (!target_machine)
+        throw Exception(ErrorCodes::CANNOT_COMPILE_CODE, "Cannot create target machine");
+
+    return std::unique_ptr<llvm::TargetMachine>(target_machine);
+}
+
+}
+
+#endif
diff --git a/src/Interpreters/JIT/CHJIT.h b/src/Interpreters/JIT/CHJIT.h
new file mode 100644
index 00000000000..45a8aef50af
--- /dev/null
+++ b/src/Interpreters/JIT/CHJIT.h
@@ -0,0 +1,120 @@
+#pragma once
+
+#if !defined(ARCADIA_BUILD)
+#    include "config_core.h"
+#endif
+
+#if USE_EMBEDDED_COMPILER
+
+#include <unordered_map>
+#include <atomic>
+
+#include <llvm/IR/LLVMContext.h>
+#include <llvm/IR/Module.h>
+#include <llvm/Target/TargetMachine.h>
+
+namespace DB
+{
+
+class JITModuleMemoryManager;
+class JITSymbolResolver;
+class JITCompiler;
+
+/** Custom jit implementation
+  * Main use cases:
+  * 1. Compiled functions in module.
+  * 2. Release memory for compiled functions.
+  *
+  * In LLVM library there are 2 main JIT stacks MCJIT and ORCv2.
+  *
+  * Main reasons for custom implementation vs MCJIT
+  * MCJIT keeps llvm::Module and compiled object code before linking process after module was compiled.
+  * llvm::Module can be removed, but compiled object code cannot be removed. Memory for compiled code
+  * will be release only during MCJIT instance destruction. It is too expensive to create MCJIT
+  * instance for each compiled module.
+  * Also important reason is that if some error occurred during compilation steps, MCJIT can just terminate
+  * our program.
+  *
+  * Main reasons for custom implementation vs ORCv2.
+  * ORC is on request compiler, we do not need support for asynchronous compilation.
+  * It was possible to remove compiled code with ORCv1 but it was deprecated.
+  * In ORCv2 this probably can be done only with custom layer and materialization unit.
+  * But it is inconvenient, discard is only called for materialization units by JITDylib that are not yet materialized.
+  *
+  * CHJIT interface is thread safe, that means all functions can be called from multiple threads and state of CHJIT instance
+  * will not be broken.
+  * It is client responsibility to be sure and do not use compiled code after it was released.
+  */
+class CHJIT
+{
+public:
+    CHJIT();
+
+    ~CHJIT();
+
+    struct CompiledModuleInfo
+    {
+        /// Size of compiled module code in bytes
+        size_t size;
+        /// Module identifier. Should not be changed by client
+        uint64_t identifier;
+        /// Vector of compiled function nameds. Should not be changed by client
+        std::vector<std::string> compiled_functions;
+    };
+
+    /** Compile module. In compile function client responsibility is to fill module with necessary
+      * IR code, then it will be compiled by CHJIT instance.
+      * Return compiled module info.
+      */
+    CompiledModuleInfo compileModule(std::function<void (llvm::Module &)> compile_function);
+
+    /** Delete compiled module. Pointers to functions from module become invalid after this call.
+      * It is client responsibility to be sure that there are no pointers to compiled module code.
+      */
+    void deleteCompiledModule(const CompiledModuleInfo & module_info);
+
+    /** Find compiled function using module_info, and function_name.
+      * It is client responsibility to case result function to right signature.
+      * After call to deleteCompiledModule compiled functions from module become invalid.
+      */
+    void * findCompiledFunction(const CompiledModuleInfo & module_info, const std::string & function_name) const;
+
+    /** Register external symbol for CHJIT instance to use, during linking.
+      * It can be function, or global constant.
+      * It is client responsibility to be sure that address of symbol is valid during CHJIT instance lifetime.
+      */
+    void registerExternalSymbol(const std::string & symbol_name, void * address);
+
+    /** Total compiled code size for module that are currently valid.
+      */
+    inline size_t getCompiledCodeSize() const { return compiled_code_size.load(std::memory_order_relaxed); }
+
+private:
+
+    std::unique_ptr<llvm::Module> createModuleForCompilation();
+
+    CompiledModuleInfo compileModule(std::unique_ptr<llvm::Module> module);
+
+    std::string getMangledName(const std::string & name_to_mangle) const;
+
+    void runOptimizationPassesOnModule(llvm::Module & module) const;
+
+    static std::unique_ptr<llvm::TargetMachine> getTargetMachine();
+
+    llvm::LLVMContext context;
+    std::unique_ptr<llvm::TargetMachine> machine;
+    llvm::DataLayout layout;
+    std::unique_ptr<JITCompiler> compiler;
+    std::unique_ptr<JITSymbolResolver> symbol_resolver;
+
+    std::unordered_map<std::string, void *> name_to_symbol;
+    std::unordered_map<uint64_t, std::unique_ptr<JITModuleMemoryManager>> module_identifier_to_memory_manager;
+    uint64_t current_module_key = 0;
+    std::atomic<size_t> compiled_code_size = 0;
+    mutable std::mutex jit_lock;
+
+};
+
+}
+
+#endif
diff --git a/src/Interpreters/JIT/CompileDAG.cpp b/src/Interpreters/JIT/CompileDAG.cpp
new file mode 100644
index 00000000000..5fc88e7884c
--- /dev/null
+++ b/src/Interpreters/JIT/CompileDAG.cpp
@@ -0,0 +1,180 @@
+#include "CompileDAG.h"
+
+#if USE_EMBEDDED_COMPILER
+
+#include <llvm/IR/BasicBlock.h>
+#include <llvm/IR/Function.h>
+#include <llvm/IR/IRBuilder.h>
+
+#include <Common/SipHash.h>
+#include <Common/FieldVisitors.h>
+#include <Columns/ColumnConst.h>
+#include <DataTypes/Native.h>
+#include <IO/WriteBufferFromString.h>
+#include <IO/Operators.h>
+
+namespace DB
+{
+
+namespace ErrorCodes
+{
+    extern const int LOGICAL_ERROR;
+}
+
+llvm::Value * CompileDAG::compile(llvm::IRBuilderBase & builder, Values input_nodes_values) const
+{
+    assert(input_nodes_values.size() == getInputNodesCount());
+
+    llvm::IRBuilder<> & b = static_cast<llvm::IRBuilder<> &>(builder);
+
+    PaddedPODArray<llvm::Value *> compiled_values;
+    compiled_values.resize_fill(nodes.size());
+
+    size_t input_nodes_values_index = 0;
+    size_t compiled_values_index = 0;
+
+    size_t dag_size = nodes.size();
+
+    for (size_t i = 0; i < dag_size; ++i)
+    {
+        const auto & node = nodes[i];
+
+        switch (node.type)
+        {
+            case CompileType::CONSTANT:
+            {
+                auto * native_value = getColumnNativeValue(b, node.result_type, *node.column, 0);
+                if (!native_value)
+                    throw Exception(ErrorCodes::LOGICAL_ERROR,
+                    "Cannot find native value for constant column with type {}",
+                    node.result_type->getName());
+
+                compiled_values[compiled_values_index] = native_value;
+                break;
+            }
+            case CompileType::FUNCTION:
+            {
+                Values temporary_values;
+                temporary_values.reserve(node.arguments.size());
+
+                for (auto argument_index : node.arguments)
+                {
+                    assert(compiled_values[argument_index] != nullptr);
+                    temporary_values.emplace_back(compiled_values[argument_index]);
+                }
+
+                compiled_values[compiled_values_index] = node.function->compile(builder, temporary_values);
+                break;
+            }
+            case CompileType::INPUT:
+            {
+                compiled_values[compiled_values_index] = input_nodes_values[input_nodes_values_index];
+                ++input_nodes_values_index;
+                break;
+            }
+        }
+
+        ++compiled_values_index;
+    }
+
+    return compiled_values.back();
+}
+
+std::string CompileDAG::dump() const
+{
+    std::vector<std::string> dumped_values;
+    dumped_values.resize(nodes.size());
+
+    size_t dag_size = nodes.size();
+    for (size_t i = 0; i < dag_size; ++i)
+    {
+        const auto & node = nodes[i];
+
+        switch (node.type)
+        {
+            case CompileType::CONSTANT:
+            {
+                const auto * column = typeid_cast<const ColumnConst *>(node.column.get());
+                const auto & data = column->getDataColumn();
+
+                dumped_values[i] = applyVisitor(FieldVisitorToString(), data[0]) + " : " + node.result_type->getName();
+                break;
+            }
+            case CompileType::FUNCTION:
+            {
+                std::string function_dump = node.function->getName();
+                function_dump += '(';
+
+                for (auto argument_index : node.arguments)
+                {
+                    function_dump += dumped_values[argument_index];
+                    function_dump += ", ";
+                }
+
+                if (!node.arguments.empty())
+                {
+                    function_dump.pop_back();
+                    function_dump.pop_back();
+                }
+
+                function_dump += ')';
+
+                dumped_values[i] = std::move(function_dump);
+                break;
+            }
+            case CompileType::INPUT:
+            {
+                dumped_values[i] = node.result_type->getName();
+                break;
+            }
+        }
+    }
+
+    return dumped_values.back();
+}
+
+UInt128 CompileDAG::hash() const
+{
+    SipHash hash;
+    for (const auto & node : nodes)
+    {
+        hash.update(node.type);
+
+        const auto & result_type_name = node.result_type->getName();
+        hash.update(result_type_name.size());
+        hash.update(result_type_name);
+
+        switch (node.type)
+        {
+            case CompileType::CONSTANT:
+            {
+                assert_cast<const ColumnConst *>(node.column.get())->getDataColumn().updateHashWithValue(0, hash);
+                break;
+            }
+            case CompileType::FUNCTION:
+            {
+                const auto & function_name = node.function->getName();
+
+                hash.update(function_name.size());
+                hash.update(function_name);
+
+                for (size_t arg : node.arguments)
+                    hash.update(arg);
+
+                break;
+            }
+            case CompileType::INPUT:
+            {
+                break;
+            }
+        }
+    }
+
+    UInt128 result;
+    hash.get128(result);
+    return result;
+}
+
+}
+
+#endif
diff --git a/src/Interpreters/JIT/CompileDAG.h b/src/Interpreters/JIT/CompileDAG.h
new file mode 100644
index 00000000000..a981c801e30
--- /dev/null
+++ b/src/Interpreters/JIT/CompileDAG.h
@@ -0,0 +1,89 @@
+#pragma once
+
+#if !defined(ARCADIA_BUILD)
+#    include "config_core.h"
+#endif
+
+#if USE_EMBEDDED_COMPILER
+
+#include <vector>
+
+#include <Core/Types.h>
+
+#include <Columns/IColumn.h>
+#include <DataTypes/IDataType.h>
+#include <Functions/IFunctionImpl.h>
+
+namespace llvm
+{
+    class Value;
+    class IRBuilderBase;
+}
+
+namespace DB
+{
+
+/** This class is needed to compile part of ActionsDAG.
+  * For example we have expression (a + 1) + (b + 1) in actions dag.
+  * It must be added into CompileDAG in order of compile evaluation.
+  * Node a, Constant 1, Function add(a + 1), Input b, Constant 1, Function add(b, 1), Function add(add(a + 1), add(a + 1)).
+  *
+  * Compile function must be called with input_nodes_values equal to input nodes count.
+  * When compile method is called added nodes are compiled in order.
+  */
+class CompileDAG
+{
+public:
+
+    enum class CompileType
+    {
+        INPUT = 0,
+        CONSTANT = 1,
+        FUNCTION = 2,
+    };
+
+    struct Node
+    {
+        CompileType type;
+        DataTypePtr result_type;
+
+        /// For CONSTANT
+        ColumnPtr column;
+
+        /// For FUNCTION
+        FunctionBasePtr function;
+        std::vector<size_t> arguments;
+    };
+
+    llvm::Value * compile(llvm::IRBuilderBase & builder, Values input_nodes_values) const;
+
+    std::string dump() const;
+
+    UInt128 hash() const;
+
+    void addNode(Node node)
+    {
+        input_nodes_count += (node.type == CompileType::INPUT);
+        nodes.emplace_back(std::move(node));
+    }
+
+    inline size_t getNodesCount() const { return nodes.size(); }
+    inline size_t getInputNodesCount() const { return input_nodes_count; }
+
+    inline Node & operator[](size_t index) { return nodes[index]; }
+    inline const Node & operator[](size_t index) const { return nodes[index]; }
+
+    inline Node & front() { return nodes.front(); }
+    inline const Node & front() const { return nodes.front(); }
+
+    inline Node & back() { return nodes.back(); }
+    inline const Node & back() const { return nodes.back(); }
+
+private:
+    std::vector<Node> nodes;
+    size_t input_nodes_count = 0;
+};
+
+}
+
+#endif
diff --git a/src/Interpreters/JIT/compileFunction.cpp b/src/Interpreters/JIT/compileFunction.cpp
new file mode 100644
index 00000000000..a17591bc96f
--- /dev/null
+++ b/src/Interpreters/JIT/compileFunction.cpp
@@ -0,0 +1,187 @@
+#include "compileFunction.h"
+
+#if USE_EMBEDDED_COMPILER
+
+#include <llvm/IR/BasicBlock.h>
+#include <llvm/IR/Function.h>
+#include <llvm/IR/IRBuilder.h>
+
+#include <Common/Stopwatch.h>
+#include <Common/ProfileEvents.h>
+#include <DataTypes/Native.h>
+#include <Interpreters/JIT/CHJIT.h>
+
+namespace
+{
+    struct ColumnDataPlaceholder
+    {
+        llvm::Value * data_init = nullptr; /// first row
+        llvm::Value * null_init = nullptr;
+        llvm::PHINode * data = nullptr; /// current row
+        llvm::PHINode * null = nullptr;
+    };
+}
+
+namespace ProfileEvents
+{
+    extern const Event CompileFunction;
+    extern const Event CompileExpressionsMicroseconds;
+    extern const Event CompileExpressionsBytes;
+}
+
+namespace DB
+{
+
+namespace ErrorCodes
+{
+    extern const int LOGICAL_ERROR;
+}
+
+ColumnData getColumnData(const IColumn * column)
+{
+    ColumnData result;
+    const bool is_const = isColumnConst(*column);
+
+    if (is_const)
+        throw Exception(ErrorCodes::LOGICAL_ERROR, "Input columns should not be constant");
+
+    if (const auto * nullable = typeid_cast<const ColumnNullable *>(column))
+    {
+        result.null_data = nullable->getNullMapColumn().getRawData().data;
+        column = & nullable->getNestedColumn();
+    }
+
+    result.data = column->getRawData().data;
+
+    return result;
+}
+
+static void compileFunction(llvm::Module & module, const IFunctionBaseImpl & function)
+{
+    /** Algorithm is to create a loop that iterate over ColumnDataRowsSize size_t argument and
+     * over ColumnData data and null_data. On each step compiled expression from function
+     * will be executed over column data and null_data row.
+     */
+    ProfileEvents::increment(ProfileEvents::CompileFunction);
+
+    const auto & arg_types = function.getArgumentTypes();
+
+    llvm::IRBuilder<> b(module.getContext());
+    auto * size_type = b.getIntNTy(sizeof(size_t) * 8);
+    auto * data_type = llvm::StructType::get(b.getInt8PtrTy(), b.getInt8PtrTy());
+    auto * func_type = llvm::FunctionType::get(b.getVoidTy(), { size_type, data_type->getPointerTo() }, /*isVarArg=*/false);
+
+    /// Create function in module
+
+    auto * func = llvm::Function::Create(func_type, llvm::Function::ExternalLinkage, function.getName(), module);
+    auto * args = func->args().begin();
+    llvm::Value * counter_arg = &*args++;
+    llvm::Value * columns_arg = &*args++;
+
+    /// Initialize ColumnDataPlaceholder llvm representation of ColumnData
+
+    auto * entry = llvm::BasicBlock::Create(b.getContext(), "entry", func);
+    b.SetInsertPoint(entry);
+
+    std::vector<ColumnDataPlaceholder> columns(arg_types.size() + 1);
+    for (size_t i = 0; i <= arg_types.size(); ++i)
+    {
+        const auto & type = i == arg_types.size() ? function.getResultType() : arg_types[i];
+        auto * data = b.CreateLoad(b.CreateConstInBoundsGEP1_32(data_type, columns_arg, i));
+        columns[i].data_init = b.CreatePointerCast(b.CreateExtractValue(data, {0}), toNativeType(b, removeNullable(type))->getPointerTo());
+        columns[i].null_init = type->isNullable() ? b.CreateExtractValue(data, {1}) : nullptr;
+    }
+
+    /// Initialize loop
+
+    auto * loop = llvm::BasicBlock::Create(b.getContext(), "loop", func);
+    b.CreateBr(loop);
+    b.SetInsertPoint(loop);
+
+    auto * counter_phi = b.CreatePHI(counter_arg->getType(), 2);
+    counter_phi->addIncoming(counter_arg, entry);
+
+    for (auto & col : columns)
+    {
+        col.data = b.CreatePHI(col.data_init->getType(), 2);
+        col.data->addIncoming(col.data_init, entry);
+        if (col.null_init)
+        {
+            col.null = b.CreatePHI(col.null_init->getType(), 2);
+            col.null->addIncoming(col.null_init, entry);
+        }
+    }
+
+    /// Initialize column row values
+
+    Values arguments;
+    arguments.reserve(arg_types.size());
+
+    for (size_t i = 0; i < arg_types.size(); ++i)
+    {
+        auto & column = columns[i];
+        auto type = arg_types[i];
+
+        auto * value = b.CreateLoad(column.data);
+        if (!column.null)
+        {
+            arguments.emplace_back(value);
+            continue;
+        }
+
+        auto * is_null = b.CreateICmpNE(b.CreateLoad(column.null), b.getInt8(0));
+        auto * nullable_unitilized = llvm::Constant::getNullValue(toNativeType(b, type));
+        auto * nullable_value = b.CreateInsertValue(b.CreateInsertValue(nullable_unitilized, value, {0}), is_null, {1});
+        arguments.emplace_back(nullable_value);
+    }
+
+    /// Compile values for column rows and store compiled value in result column
+
+    auto * result = function.compile(b, std::move(arguments));
+    if (columns.back().null)
+    {
+        b.CreateStore(b.CreateExtractValue(result, {0}), columns.back().data);
+        b.CreateStore(b.CreateSelect(b.CreateExtractValue(result, {1}), b.getInt8(1), b.getInt8(0)), columns.back().null);
+    }
+    else
+    {
+        b.CreateStore(result, columns.back().data);
+    }
+
+    /// End of loop
+
+    auto * cur_block = b.GetInsertBlock();
+    for (auto & col : columns)
+    {
+        col.data->addIncoming(b.CreateConstInBoundsGEP1_32(nullptr, col.data, 1), cur_block);
+        if (col.null)
+            col.null->addIncoming(b.CreateConstInBoundsGEP1_32(nullptr, col.null, 1), cur_block);
+    }
+
+    counter_phi->addIncoming(b.CreateSub(counter_phi, llvm::ConstantInt::get(size_type, 1)), cur_block);
+
+    auto * end = llvm::BasicBlock::Create(b.getContext(), "end", func);
+    b.CreateCondBr(b.CreateICmpNE(counter_phi, llvm::ConstantInt::get(size_type, 1)), loop, end);
+    b.SetInsertPoint(end);
+    b.CreateRetVoid();
+}
+
+CHJIT::CompiledModuleInfo compileFunction(CHJIT & jit, const IFunctionBaseImpl & function)
+{
+    Stopwatch watch;
+
+    auto compiled_module_info = jit.compileModule([&](llvm::Module & module)
+    {
+        compileFunction(module, function);
+    });
+
+    ProfileEvents::increment(ProfileEvents::CompileExpressionsMicroseconds, watch.elapsedMicroseconds());
+    ProfileEvents::increment(ProfileEvents::CompileExpressionsBytes, compiled_module_info.size);
+    ProfileEvents::increment(ProfileEvents::CompileFunction);
+
+    return compiled_module_info;
+}
+
+}
+
+#endif
diff --git a/src/Interpreters/JIT/compileFunction.h b/src/Interpreters/JIT/compileFunction.h
new file mode 100644
index 00000000000..ae8a5f0ad13
--- /dev/null
+++ b/src/Interpreters/JIT/compileFunction.h
@@ -0,0 +1,46 @@
+#pragma once
+
+#if !defined(ARCADIA_BUILD)
+#    include "config_core.h"
+#endif
+
+#if USE_EMBEDDED_COMPILER
+
+#include <Functions/IFunctionImpl.h>
+#include <Interpreters/JIT/CHJIT.h>
+
+namespace DB
+{
+
+/** ColumnData structure to pass into compiled function.
+  * data is raw column data.
+  * null_data is null map column raw data.
+  */
+struct ColumnData
+{
+    const char * data = nullptr;
+    const char * null_data = nullptr;
+};
+
+/** Returns ColumnData for column.
+  * If constant column is passed, LOGICAL_ERROR will be thrown.
+  */
+ColumnData getColumnData(const IColumn * column);
+
+using ColumnDataRowsSize = size_t;
+using JITCompiledFunction = void (*)(ColumnDataRowsSize, ColumnData *);
+
+/** Compile function to native jit code using CHJIT instance.
+  * Function is compiled as single module.
+  * After this function execution, code for function will be compiled and can be queried using
+  * findCompiledFunction with function name.
+  * Compiled function can be safely casted to JITCompiledFunction type and must be called with
+  * valid ColumnData and ColumnDataRowsSize.
+  * It is important that ColumnData parameter of JITCompiledFunction is result column,
+  * and will be filled by compiled function.
+  */
+CHJIT::CompiledModuleInfo compileFunction(CHJIT & jit, const IFunctionBaseImpl & function);
+
+}
+
+#endif
diff --git a/src/Interpreters/MySQL/InterpretersMySQLDDLQuery.cpp b/src/Interpreters/MySQL/InterpretersMySQLDDLQuery.cpp
index 2420255c5c1..40508488d05 100644
--- a/src/Interpreters/MySQL/InterpretersMySQLDDLQuery.cpp
+++ b/src/Interpreters/MySQL/InterpretersMySQLDDLQuery.cpp
@@ -185,7 +185,7 @@ static inline std::tuple<NamesAndTypesList, NamesAndTypesList, NamesAndTypesList
                     {
                         const auto & prefix_limit = function->arguments->children[0]->as<ASTLiteral>();
 
-                        if (prefix_limit && isInt64FieldType(prefix_limit->value.getType()))
+                        if (prefix_limit && isInt64OrUInt64FieldType(prefix_limit->value.getType()))
                             res->children.back() = std::make_shared<ASTIdentifier>(function->name);
                     }
                 }
diff --git a/src/Interpreters/OpenTelemetrySpanLog.cpp b/src/Interpreters/OpenTelemetrySpanLog.cpp
index c72b0f3d326..727a60f2260 100644
--- a/src/Interpreters/OpenTelemetrySpanLog.cpp
+++ b/src/Interpreters/OpenTelemetrySpanLog.cpp
@@ -8,6 +8,9 @@
 #include <DataTypes/DataTypeString.h>
 #include <DataTypes/DataTypeUUID.h>
 
+#include <Common/hex.h>
+
+
 namespace DB
 {
 
@@ -43,7 +46,7 @@ void OpenTelemetrySpanLogElement::appendToBlock(MutableColumns & columns) const
 {
     size_t i = 0;
 
-    columns[i++]->insert(UInt128(Int128(trace_id)));
+    columns[i++]->insert(trace_id);
     columns[i++]->insert(span_id);
     columns[i++]->insert(parent_span_id);
     columns[i++]->insert(operation_name);
@@ -79,10 +82,8 @@ OpenTelemetrySpanHolder::OpenTelemetrySpanHolder(const std::string & _operation_
     auto & thread = CurrentThread::get();
 
     trace_id = thread.thread_trace_context.trace_id;
-    if (!trace_id)
-    {
+    if (trace_id == UUID())
         return;
-    }
 
     parent_span_id = thread.thread_trace_context.span_id;
     span_id = thread_local_rng();
@@ -98,10 +99,8 @@ OpenTelemetrySpanHolder::~OpenTelemetrySpanHolder()
 {
     try
     {
-        if (!trace_id)
-        {
+        if (trace_id == UUID())
             return;
-        }
 
         // First of all, return old value of current span.
         auto & thread = CurrentThread::get();
@@ -145,18 +144,31 @@ OpenTelemetrySpanHolder::~OpenTelemetrySpanHolder()
 }
 
 
+template <typename T>
+static T readHex(const char * data)
+{
+    T x{};
+
+    const char * end = data + sizeof(T) * 2;
+    while (data < end)
+    {
+        x *= 16;
+        x += unhex(*data);
+        ++data;
+    }
+
+    return x;
+}
+
+
 bool OpenTelemetryTraceContext::parseTraceparentHeader(const std::string & traceparent,
     std::string & error)
 {
     trace_id = 0;
 
-    uint8_t version = -1;
-    uint64_t trace_id_high = 0;
-    uint64_t trace_id_low = 0;
-
     // Version 00, which is the only one we can parse, is fixed width. Use this
     // fact for an additional sanity check.
-    const int expected_length = 2 + 1 + 32 + 1 + 16 + 1 + 2;
+    const int expected_length = strlen("xx-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx-xxxxxxxxxxxxxxxx-xx");
     if (traceparent.length() != expected_length)
     {
         error = fmt::format("unexpected length {}, expected {}",
@@ -164,30 +176,10 @@ bool OpenTelemetryTraceContext::parseTraceparentHeader(const std::string & trace
         return false;
     }
 
-    // clang-tidy doesn't like sscanf:
-    //   error: 'sscanf' used to convert a string to an unsigned integer value,
-    //   but function will not report conversion errors; consider using 'strtoul'
-    //   instead [cert-err34-c,-warnings-as-errors]
-    // There is no other ready solution, and hand-rolling a more complicated
-    // parser for an HTTP header in C++ sounds like RCE.
-    // NOLINTNEXTLINE(cert-err34-c)
-    int result = sscanf(&traceparent[0],
-        "%2" SCNx8 "-%16" SCNx64 "%16" SCNx64 "-%16" SCNx64 "-%2" SCNx8,
-        &version, &trace_id_high, &trace_id_low, &span_id, &trace_flags);
+    const char * data = traceparent.data();
 
-    if (result == EOF)
-    {
-        error = "EOF";
-        return false;
-    }
-
-    // We read uint128 as two uint64, so 5 parts and not 4.
-    if (result != 5)
-    {
-        error = fmt::format("could only read {} parts instead of the expected 5",
-            result);
-        return false;
-    }
+    uint8_t version = readHex<uint8_t>(data);
+    data += 2;
 
     if (version != 0)
     {
@@ -195,8 +187,35 @@ bool OpenTelemetryTraceContext::parseTraceparentHeader(const std::string & trace
         return false;
     }
 
-    trace_id = static_cast<__uint128_t>(trace_id_high) << 64
-        | trace_id_low;
+    if (*data != '-')
+    {
+        error = fmt::format("Malformed traceparant header: {}", traceparent);
+        return false;
+    }
+
+    ++data;
+    UInt128 trace_id_128 = readHex<UInt128>(data);
+    trace_id = trace_id_128;
+    data += 32;
+
+    if (*data != '-')
+    {
+        error = fmt::format("Malformed traceparant header: {}", traceparent);
+        return false;
+    }
+
+    ++data;
+    span_id = readHex<UInt64>(data);
+    data += 16;
+
+    if (*data != '-')
+    {
+        error = fmt::format("Malformed traceparant header: {}", traceparent);
+        return false;
+    }
+
+    ++data;
+    trace_flags = readHex<UInt8>(data);
     return true;
 }
 
@@ -205,7 +224,7 @@ std::string OpenTelemetryTraceContext::composeTraceparentHeader() const
 {
     // This span is a parent for its children, so we specify this span_id as a
     // parent id.
-    return fmt::format("00-{:032x}-{:016x}-{:02x}", trace_id,
+    return fmt::format("00-{:032x}-{:016x}-{:02x}", __uint128_t(trace_id.toUnderType()),
         span_id,
         // This cast is needed because fmt is being weird and complaining that
         // "mixing character types is not allowed".
diff --git a/src/Interpreters/OpenTelemetrySpanLog.h b/src/Interpreters/OpenTelemetrySpanLog.h
index f74e1f0c9fd..861293b4f98 100644
--- a/src/Interpreters/OpenTelemetrySpanLog.h
+++ b/src/Interpreters/OpenTelemetrySpanLog.h
@@ -7,7 +7,7 @@ namespace DB
 
 struct OpenTelemetrySpan
 {
-    __uint128_t trace_id;
+    UUID trace_id;
     UInt64 span_id;
     UInt64 parent_span_id;
     std::string operation_name;
diff --git a/src/Interpreters/PartLog.cpp b/src/Interpreters/PartLog.cpp
index e4459399336..ad4fb60f00c 100644
--- a/src/Interpreters/PartLog.cpp
+++ b/src/Interpreters/PartLog.cpp
@@ -143,7 +143,7 @@ bool PartLog::addNewParts(
             if (query_id.data && query_id.size)
                 elem.query_id.insert(0, query_id.data, query_id.size);
 
-            elem.event_type = PartLogElement::NEW_PART;
+            elem.event_type = PartLogElement::NEW_PART; //-V1048
 
             // construct event_time and event_time_microseconds using the same time point
             // so that the two times will always be equal up to a precision of a second.
diff --git a/src/Interpreters/ProcessList.h b/src/Interpreters/ProcessList.h
index 3eeea9c8e5b..fca28b031db 100644
--- a/src/Interpreters/ProcessList.h
+++ b/src/Interpreters/ProcessList.h
@@ -276,7 +276,7 @@ protected:
 
     /// List of queries
     Container processes;
-    size_t max_size;        /// 0 means no limit. Otherwise, when limit exceeded, an exception is thrown.
+    size_t max_size = 0;        /// 0 means no limit. Otherwise, when limit exceeded, an exception is thrown.
 
     /// Stores per-user info: queries, statistics and limits
     UserToQueries user_to_queries;
diff --git a/src/Interpreters/RemoveInjectiveFunctionsVisitor.cpp b/src/Interpreters/RemoveInjectiveFunctionsVisitor.cpp
index f46e80a6370..1dca2db859b 100644
--- a/src/Interpreters/RemoveInjectiveFunctionsVisitor.cpp
+++ b/src/Interpreters/RemoveInjectiveFunctionsVisitor.cpp
@@ -12,7 +12,8 @@ namespace DB
 static bool isUniq(const ASTFunction & func)
 {
     return func.name == "uniq" || func.name == "uniqExact" || func.name == "uniqHLL12"
-        || func.name == "uniqCombined" || func.name == "uniqCombined64";
+        || func.name == "uniqCombined" || func.name == "uniqCombined64"
+        || func.name == "uniqThetaSketch";
 }
 
 /// Remove injective functions of one argument: replace with a child
diff --git a/src/Interpreters/RewriteSumIfFunctionVisitor.cpp b/src/Interpreters/RewriteSumIfFunctionVisitor.cpp
index 2593c220c63..7b322ca1585 100644
--- a/src/Interpreters/RewriteSumIfFunctionVisitor.cpp
+++ b/src/Interpreters/RewriteSumIfFunctionVisitor.cpp
@@ -29,7 +29,7 @@ void RewriteSumIfFunctionMatcher::visit(const ASTFunction & func, ASTPtr & ast,
     {
         /// sumIf(1, cond) -> countIf(cond)
         const auto * literal = func_arguments[0]->as<ASTLiteral>();
-        if (!literal || !DB::isInt64FieldType(literal->value.getType()))
+        if (!literal || !DB::isInt64OrUInt64FieldType(literal->value.getType()))
             return;
 
         if (func_arguments.size() == 2 && literal->value.get<UInt64>() == 1)
@@ -54,7 +54,7 @@ void RewriteSumIfFunctionMatcher::visit(const ASTFunction & func, ASTPtr & ast,
 
         if (first_literal && second_literal)
         {
-            if (!DB::isInt64FieldType(first_literal->value.getType()) || !DB::isInt64FieldType(second_literal->value.getType()))
+            if (!DB::isInt64OrUInt64FieldType(first_literal->value.getType()) || !DB::isInt64OrUInt64FieldType(second_literal->value.getType()))
                 return;
 
             auto first_value = first_literal->value.get<UInt64>();
diff --git a/src/Interpreters/Set.cpp b/src/Interpreters/Set.cpp
index b150eabda65..713be3c1447 100644
--- a/src/Interpreters/Set.cpp
+++ b/src/Interpreters/Set.cpp
@@ -1,7 +1,6 @@
 #include <optional>
 
 #include <Core/Field.h>
-#include <Common/FieldVisitors.h>
 #include <Core/Row.h>
 
 #include <Columns/ColumnsNumber.h>
diff --git a/src/Interpreters/SetVariants.cpp b/src/Interpreters/SetVariants.cpp
index eb21333e3ec..1cc0f767ecc 100644
--- a/src/Interpreters/SetVariants.cpp
+++ b/src/Interpreters/SetVariants.cpp
@@ -122,7 +122,7 @@ typename SetVariantsTemplate<Variant>::Type SetVariantsTemplate<Variant>::choose
                 throw Exception{"Aggregator: keys sizes overflow", ErrorCodes::LOGICAL_ERROR};
             if ((std::tuple_size<KeysNullMap<UInt128>>::value + keys_bytes) <= 16)
                 return Type::nullable_keys128;
-            if ((std::tuple_size<KeysNullMap<DummyUInt256>>::value + keys_bytes) <= 32)
+            if ((std::tuple_size<KeysNullMap<UInt256>>::value + keys_bytes) <= 32)
                 return Type::nullable_keys256;
         }
 
diff --git a/src/Interpreters/SetVariants.h b/src/Interpreters/SetVariants.h
index bcd833e42a8..d6be996effb 100644
--- a/src/Interpreters/SetVariants.h
+++ b/src/Interpreters/SetVariants.h
@@ -8,7 +8,6 @@
 #include <Common/HashTable/ClearableHashSet.h>
 #include <Common/HashTable/FixedClearableHashSet.h>
 #include <Common/HashTable/FixedHashSet.h>
-#include <Common/UInt128.h>
 
 
 namespace DB
@@ -202,12 +201,12 @@ struct NonClearableSet
     std::unique_ptr<SetMethodString<HashSetWithSavedHash<StringRef>>>                        key_string;
     std::unique_ptr<SetMethodFixedString<HashSetWithSavedHash<StringRef>>>                   key_fixed_string;
     std::unique_ptr<SetMethodKeysFixed<HashSet<UInt128, UInt128HashCRC32>>>                  keys128;
-    std::unique_ptr<SetMethodKeysFixed<HashSet<DummyUInt256, UInt256HashCRC32>>>             keys256;
+    std::unique_ptr<SetMethodKeysFixed<HashSet<UInt256, UInt256HashCRC32>>>                  keys256;
     std::unique_ptr<SetMethodHashed<HashSet<UInt128, UInt128TrivialHash>>>                   hashed;
 
     /// Support for nullable keys (for DISTINCT implementation).
     std::unique_ptr<SetMethodKeysFixed<HashSet<UInt128, UInt128HashCRC32>, true>>            nullable_keys128;
-    std::unique_ptr<SetMethodKeysFixed<HashSet<DummyUInt256, UInt256HashCRC32>, true>>       nullable_keys256;
+    std::unique_ptr<SetMethodKeysFixed<HashSet<UInt256, UInt256HashCRC32>, true>>            nullable_keys256;
     /** Unlike Aggregator, `concat` method is not used here.
       * This is done because `hashed` method, although slower, but in this case, uses less RAM.
       *  since when you use it, the key values themselves are not stored.
@@ -224,12 +223,12 @@ struct ClearableSet
     std::unique_ptr<SetMethodString<ClearableHashSetWithSavedHash<StringRef>>>                       key_string;
     std::unique_ptr<SetMethodFixedString<ClearableHashSetWithSavedHash<StringRef>>>                  key_fixed_string;
     std::unique_ptr<SetMethodKeysFixed<ClearableHashSet<UInt128, UInt128HashCRC32>>>                 keys128;
-    std::unique_ptr<SetMethodKeysFixed<ClearableHashSet<DummyUInt256, UInt256HashCRC32>>>            keys256;
+    std::unique_ptr<SetMethodKeysFixed<ClearableHashSet<UInt256, UInt256HashCRC32>>>                 keys256;
     std::unique_ptr<SetMethodHashed<ClearableHashSet<UInt128, UInt128TrivialHash>>>                  hashed;
 
     /// Support for nullable keys (for DISTINCT implementation).
     std::unique_ptr<SetMethodKeysFixed<ClearableHashSet<UInt128, UInt128HashCRC32>, true>>           nullable_keys128;
-    std::unique_ptr<SetMethodKeysFixed<ClearableHashSet<DummyUInt256, UInt256HashCRC32>, true>>      nullable_keys256;
+    std::unique_ptr<SetMethodKeysFixed<ClearableHashSet<UInt256, UInt256HashCRC32>, true>>           nullable_keys256;
     /** Unlike Aggregator, `concat` method is not used here.
       * This is done because `hashed` method, although slower, but in this case, uses less RAM.
       *  since when you use it, the key values themselves are not stored.
diff --git a/src/Interpreters/TextLog.h b/src/Interpreters/TextLog.h
index 7ff55128a90..0133d5e4eb6 100644
--- a/src/Interpreters/TextLog.h
+++ b/src/Interpreters/TextLog.h
@@ -10,10 +10,10 @@ struct TextLogElement
 {
     time_t event_time{};
     Decimal64 event_time_microseconds{};
-    UInt32 microseconds;
+    UInt32 microseconds{};
 
     String thread_name;
-    UInt64 thread_id;
+    UInt64 thread_id{};
 
     Message::Priority level = Message::PRIO_TRACE;
 
@@ -22,7 +22,7 @@ struct TextLogElement
     String message;
 
     String source_file;
-    UInt64 source_line;
+    UInt64 source_line{};
 
     static std::string name() { return "TextLog"; }
     static Block createBlock();
diff --git a/src/Interpreters/ThreadStatusExt.cpp b/src/Interpreters/ThreadStatusExt.cpp
index c04534e11a1..cff6fb9cbcd 100644
--- a/src/Interpreters/ThreadStatusExt.cpp
+++ b/src/Interpreters/ThreadStatusExt.cpp
@@ -80,7 +80,7 @@ void ThreadStatus::attachQueryContext(ContextPtr query_context_)
     // on OpenTelemetrySpanHolder due to link order issues.
     // FIXME why and how is this different from setupState()?
     thread_trace_context = query_context_->query_trace_context;
-    if (thread_trace_context.trace_id)
+    if (thread_trace_context.trace_id != UUID())
     {
         thread_trace_context.span_id = thread_local_rng();
     }
@@ -126,7 +126,7 @@ void ThreadStatus::setupState(const ThreadGroupStatusPtr & thread_group_)
         // Generate new span for thread manually here, because we can't depend
         // on OpenTelemetrySpanHolder due to link order issues.
         thread_trace_context = query_context_ptr->query_trace_context;
-        if (thread_trace_context.trace_id)
+        if (thread_trace_context.trace_id != UUID())
         {
             thread_trace_context.span_id = thread_local_rng();
         }
@@ -335,7 +335,7 @@ void ThreadStatus::detachQuery(bool exit_if_already_detached, bool thread_exits)
 
     std::shared_ptr<OpenTelemetrySpanLog> opentelemetry_span_log;
     auto query_context_ptr = query_context.lock();
-    if (thread_trace_context.trace_id && query_context_ptr)
+    if (thread_trace_context.trace_id != UUID() && query_context_ptr)
     {
         opentelemetry_span_log = query_context_ptr->getOpenTelemetrySpanLog();
     }
diff --git a/src/Interpreters/TreeRewriter.cpp b/src/Interpreters/TreeRewriter.cpp
index 324a773fbc2..3dbcbeeff2b 100644
--- a/src/Interpreters/TreeRewriter.cpp
+++ b/src/Interpreters/TreeRewriter.cpp
@@ -755,6 +755,7 @@ void TreeRewriterResult::collectUsedColumns(const ASTPtr & query, bool is_select
             partition_source_columns.push_back("_part");
             partition_source_columns.push_back("_partition_id");
             partition_source_columns.push_back("_part_uuid");
+            partition_source_columns.push_back("_partition_value");
             optimize_trivial_count = true;
             for (const auto & required_column : required)
             {
diff --git a/src/Interpreters/WindowDescription.cpp b/src/Interpreters/WindowDescription.cpp
index 05d75d4647e..b9f8597706e 100644
--- a/src/Interpreters/WindowDescription.cpp
+++ b/src/Interpreters/WindowDescription.cpp
@@ -1,9 +1,11 @@
 #include <Interpreters/WindowDescription.h>
 
 #include <Core/Field.h>
+#include <Common/FieldVisitors.h>
 #include <IO/Operators.h>
 #include <Parsers/ASTFunction.h>
 
+
 namespace DB
 {
 
diff --git a/src/Interpreters/WindowDescription.h b/src/Interpreters/WindowDescription.h
index 70a4e0e44e0..4cb478bae85 100644
--- a/src/Interpreters/WindowDescription.h
+++ b/src/Interpreters/WindowDescription.h
@@ -1,6 +1,5 @@
 #pragma once
 
-#include <Common/FieldVisitors.h>
 #include <Core/Field.h>
 #include <Parsers/IAST_fwd.h>
 #include <AggregateFunctions/IAggregateFunction.h>
diff --git a/src/Interpreters/convertFieldToType.cpp b/src/Interpreters/convertFieldToType.cpp
index 529caec9c80..fa49b730379 100644
--- a/src/Interpreters/convertFieldToType.cpp
+++ b/src/Interpreters/convertFieldToType.cpp
@@ -14,14 +14,13 @@
 #include <DataTypes/DataTypeDateTime.h>
 #include <DataTypes/DataTypeDateTime64.h>
 #include <DataTypes/DataTypeEnum.h>
+#include <DataTypes/DataTypeUUID.h>
+#include <DataTypes/DataTypeLowCardinality.h>
 #include <DataTypes/DataTypeNullable.h>
 
 #include <Core/AccurateComparison.h>
-#include <Common/FieldVisitors.h>
 #include <Common/typeid_cast.h>
 #include <Common/NaNUtils.h>
-#include <DataTypes/DataTypeUUID.h>
-#include <DataTypes/DataTypeLowCardinality.h>
 
 #include <common/DateLUT.h>
 #include <DataTypes/DataTypeAggregateFunction.h>
@@ -67,6 +66,14 @@ static Field convertNumericType(const Field & from, const IDataType & type)
         return convertNumericTypeImpl<Int64, To>(from);
     if (from.getType() == Field::Types::Float64)
         return convertNumericTypeImpl<Float64, To>(from);
+    if (from.getType() == Field::Types::UInt128)
+        return convertNumericTypeImpl<UInt128, To>(from);
+    if (from.getType() == Field::Types::Int128)
+        return convertNumericTypeImpl<Int128, To>(from);
+    if (from.getType() == Field::Types::UInt256)
+        return convertNumericTypeImpl<UInt256, To>(from);
+    if (from.getType() == Field::Types::Int256)
+        return convertNumericTypeImpl<Int256, To>(from);
 
     throw Exception("Type mismatch in IN or VALUES section. Expected: " + type.getName() + ". Got: "
         + Field::Types::toString(from.getType()), ErrorCodes::TYPE_MISMATCH);
@@ -78,9 +85,9 @@ static Field convertIntToDecimalType(const Field & from, const DataTypeDecimal<T
 {
     From value = from.get<From>();
     if (!type.canStoreWhole(value))
-        throw Exception("Number is too much to place in " + type.getName(), ErrorCodes::ARGUMENT_OUT_OF_BOUND);
+        throw Exception("Number is too big to place in " + type.getName(), ErrorCodes::ARGUMENT_OUT_OF_BOUND);
 
-    T scaled_value = type.getScaleMultiplier() * value;
+    T scaled_value = type.getScaleMultiplier() * static_cast<T>(value);
     return DecimalField<T>(scaled_value, type.getScale());
 }
 
@@ -108,6 +115,15 @@ static Field convertDecimalType(const Field & from, const To & type)
         return convertIntToDecimalType<UInt64>(from, type);
     if (from.getType() == Field::Types::Int64)
         return convertIntToDecimalType<Int64>(from, type);
+    if (from.getType() == Field::Types::UInt128)
+        return convertIntToDecimalType<UInt128>(from, type);
+    if (from.getType() == Field::Types::Int128)
+        return convertIntToDecimalType<Int128>(from, type);
+    if (from.getType() == Field::Types::UInt256)
+        return convertIntToDecimalType<UInt256>(from, type);
+    if (from.getType() == Field::Types::Int256)
+        return convertIntToDecimalType<Int256>(from, type);
+
     if (from.getType() == Field::Types::String)
         return convertStringToDecimalType(from, type);
 
@@ -125,7 +141,6 @@ static Field convertDecimalType(const Field & from, const To & type)
 
 Field convertFieldToTypeImpl(const Field & src, const IDataType & type, const IDataType * from_type_hint)
 {
-    // This was added to mitigate converting DateTime64-Field (a typedef to a Decimal64) to DataTypeDate64-compatible type.
     if (from_type_hint && from_type_hint->equals(type))
     {
         return src;
@@ -133,6 +148,7 @@ Field convertFieldToTypeImpl(const Field & src, const IDataType & type, const ID
 
     WhichDataType which_type(type);
     WhichDataType which_from_type;
+
     if (from_type_hint)
     {
         which_from_type = WhichDataType(*from_type_hint);
@@ -179,12 +195,6 @@ Field convertFieldToTypeImpl(const Field & src, const IDataType & type, const ID
             return src;
         }
 
-        if (which_type.isUUID() && src.getType() == Field::Types::UInt128)
-        {
-            /// Already in needed type.
-            return src;
-        }
-
         if (which_type.isDateTime64() && src.getType() == Field::Types::Decimal64)
         {
             /// Already in needed type.
@@ -193,6 +203,11 @@ Field convertFieldToTypeImpl(const Field & src, const IDataType & type, const ID
 
         /// TODO Conversion from integers to DateTime64
     }
+    else if (which_type.isUUID() && src.getType() == Field::Types::UUID)
+    {
+        /// Already in needed type.
+        return src;
+    }
     else if (which_type.isStringOrFixedString())
     {
         if (src.getType() == Field::Types::String)
@@ -364,6 +379,7 @@ Field convertFieldToTypeImpl(const Field & src, const IDataType & type, const ID
 
 }
 
+
 Field convertFieldToType(const Field & from_value, const IDataType & to_type, const IDataType * from_type_hint)
 {
     if (from_value.isNull())
@@ -390,18 +406,22 @@ Field convertFieldToType(const Field & from_value, const IDataType & to_type, co
         return convertFieldToTypeImpl(from_value, to_type, from_type_hint);
 }
 
+
 Field convertFieldToTypeOrThrow(const Field & from_value, const IDataType & to_type, const IDataType * from_type_hint)
 {
     bool is_null = from_value.isNull();
     if (is_null && !to_type.isNullable())
         throw Exception(ErrorCodes::TYPE_MISMATCH, "Cannot convert NULL to {}", to_type.getName());
+
     Field converted = convertFieldToType(from_value, to_type, from_type_hint);
+
     if (!is_null && converted.isNull())
         throw Exception(ErrorCodes::ARGUMENT_OUT_OF_BOUND,
             "Cannot convert value '{}'{}: it cannot be represented as {}",
             toString(from_value),
             from_type_hint ? " from " + from_type_hint->getName() : "",
             to_type.getName());
+
     return converted;
 }
 
diff --git a/src/Interpreters/examples/CMakeLists.txt b/src/Interpreters/examples/CMakeLists.txt
index 6916c255b36..85daffc4064 100644
--- a/src/Interpreters/examples/CMakeLists.txt
+++ b/src/Interpreters/examples/CMakeLists.txt
@@ -35,3 +35,6 @@ target_link_libraries (string_hash_set PRIVATE dbms)
 add_executable (two_level_hash_map two_level_hash_map.cpp)
 target_include_directories (two_level_hash_map SYSTEM BEFORE PRIVATE ${SPARSEHASH_INCLUDE_DIR})
 target_link_libraries (two_level_hash_map PRIVATE dbms)
+
+add_executable (jit_example jit_example.cpp)
+target_link_libraries (jit_example PRIVATE dbms)
diff --git a/src/Interpreters/examples/jit_example.cpp b/src/Interpreters/examples/jit_example.cpp
new file mode 100644
index 00000000000..a4f19838bbe
--- /dev/null
+++ b/src/Interpreters/examples/jit_example.cpp
@@ -0,0 +1,57 @@
+#include <iostream>
+
+#include <llvm/IR/IRBuilder.h>
+
+#include <Interpreters/JIT/CHJIT.h>
+
+void test_function()
+{
+    std::cerr << "Test function" << std::endl;
+}
+
+int main(int argc, char **argv)
+{
+    (void)(argc);
+    (void)(argv);
+
+    auto jit = DB::CHJIT();
+
+    jit.registerExternalSymbol("test_function", reinterpret_cast<void *>(&test_function));
+
+    auto compiled_module_info = jit.compileModule([](llvm::Module & module)
+    {
+        auto & context = module.getContext();
+        llvm::IRBuilder<> b (context);
+
+        auto * func_declaration_type = llvm::FunctionType::get(b.getVoidTy(), { }, /*isVarArg=*/false);
+        auto * func_declaration = llvm::Function::Create(func_declaration_type, llvm::Function::ExternalLinkage, "test_function", module);
+
+        auto * value_type = b.getInt64Ty();
+        auto * pointer_type = value_type->getPointerTo();
+
+        auto * func_type = llvm::FunctionType::get(b.getVoidTy(), { pointer_type }, /*isVarArg=*/false);
+        auto * function = llvm::Function::Create(func_type, llvm::Function::ExternalLinkage, "test_name", module);
+        auto * entry = llvm::BasicBlock::Create(context, "entry", function);
+
+        auto * argument = function->args().begin();
+        b.SetInsertPoint(entry);
+
+        b.CreateCall(func_declaration);
+
+        auto * load_argument = b.CreateLoad(argument);
+        auto * value = b.CreateAdd(load_argument, load_argument);
+        b.CreateRet(value);
+    });
+
+    for (const auto & compiled_function_name : compiled_module_info.compiled_functions)
+    {
+        std::cerr << compiled_function_name << std::endl;
+    }
+
+    int64_t value = 5;
+    auto * test_name_function = reinterpret_cast<int64_t (*)(int64_t *)>(jit.findCompiledFunction(compiled_module_info, "test_name"));
+    auto result = test_name_function(&value);
+    std::cerr << "Result " << result << std::endl;
+
+    return 0;
+}
diff --git a/src/Interpreters/executeQuery.cpp b/src/Interpreters/executeQuery.cpp
index 5df245f9f26..90e39ae0af7 100644
--- a/src/Interpreters/executeQuery.cpp
+++ b/src/Interpreters/executeQuery.cpp
@@ -174,7 +174,7 @@ static void logQuery(const String & query, ContextPtr context, bool internal)
             comment,
             joinLines(query));
 
-        if (client_info.client_trace_context.trace_id)
+        if (client_info.client_trace_context.trace_id != UUID())
         {
             LOG_TRACE(&Poco::Logger::get("executeQuery"),
                 "OpenTelemetry traceparent '{}'",
@@ -289,7 +289,7 @@ static void onExceptionBeforeStart(const String & query_for_logging, ContextPtr
             query_log->add(elem);
 
     if (auto opentelemetry_span_log = context->getOpenTelemetrySpanLog();
-        context->query_trace_context.trace_id
+        context->query_trace_context.trace_id != UUID()
             && opentelemetry_span_log)
     {
         OpenTelemetrySpanLogElement span;
@@ -552,7 +552,7 @@ static std::tuple<ASTPtr, BlockIO> executeQueryImpl(
         StreamLocalLimits limits;
         if (!interpreter->ignoreLimits())
         {
-            limits.mode = LimitsMode::LIMITS_CURRENT;
+            limits.mode = LimitsMode::LIMITS_CURRENT; //-V1048
             limits.size_limits = SizeLimits(settings.max_result_rows, settings.max_result_bytes, settings.result_overflow_mode);
         }
 
@@ -632,7 +632,7 @@ static std::tuple<ASTPtr, BlockIO> executeQueryImpl(
         {
             QueryLogElement elem;
 
-            elem.type = QueryLogElementType::QUERY_START;
+            elem.type = QueryLogElementType::QUERY_START; //-V1048
 
             elem.event_time = time_in_seconds(current_time);
             elem.event_time_microseconds = time_in_microseconds(current_time);
@@ -792,7 +792,7 @@ static std::tuple<ASTPtr, BlockIO> executeQueryImpl(
                 }
 
                 if (auto opentelemetry_span_log = context->getOpenTelemetrySpanLog();
-                    context->query_trace_context.trace_id
+                    context->query_trace_context.trace_id != UUID()
                         && opentelemetry_span_log)
                 {
                     OpenTelemetrySpanLogElement span;
diff --git a/src/Interpreters/join_common.cpp b/src/Interpreters/join_common.cpp
index cc51848b4a4..80299610a44 100644
--- a/src/Interpreters/join_common.cpp
+++ b/src/Interpreters/join_common.cpp
@@ -281,7 +281,7 @@ void createMissedColumns(Block & block)
     for (size_t i = 0; i < block.columns(); ++i)
     {
         auto & column = block.getByPosition(i);
-        if (!column.column)
+        if (!column.column) //-V1051
             column.column = column.type->createColumn();
     }
 }
diff --git a/src/Interpreters/sortBlock.h b/src/Interpreters/sortBlock.h
index a3b0a10b8f9..faf9384901b 100644
--- a/src/Interpreters/sortBlock.h
+++ b/src/Interpreters/sortBlock.h
@@ -32,7 +32,7 @@ bool isAlreadySorted(const Block & block, const SortDescription & description);
 /// Column with description for sort
 struct ColumnWithSortDescription
 {
-    const IColumn * column;
+    const IColumn * column = nullptr;
     SortColumnDescription description;
 
     /// It means, that this column is ColumnConst
diff --git a/src/Interpreters/ya.make b/src/Interpreters/ya.make
index 105e1e11365..480c368c640 100644
--- a/src/Interpreters/ya.make
+++ b/src/Interpreters/ya.make
@@ -39,6 +39,7 @@ SRCS(
     CollectJoinOnKeysVisitor.cpp
     ColumnAliasesVisitor.cpp
     Context.cpp
+    ConvertStringsToEnumVisitor.cpp
     CrashLog.cpp
     CrossToInnerJoinVisitor.cpp
     DDLTask.cpp
diff --git a/src/Parsers/ASTCreateQuery.cpp b/src/Parsers/ASTCreateQuery.cpp
index 1192fcc6ebd..d4c7312f437 100644
--- a/src/Parsers/ASTCreateQuery.cpp
+++ b/src/Parsers/ASTCreateQuery.cpp
@@ -327,7 +327,7 @@ void ASTCreateQuery::formatQueryImpl(const FormatSettings & settings, FormatStat
             FormatStateStacked frame_nested = frame;
             columns_list->formatImpl(settings, state, frame_nested);
             settings.ostr << (settings.one_line ? ")" : "\n)");
-            frame.expression_list_always_start_on_new_line = false;
+            frame.expression_list_always_start_on_new_line = false; //-V519
         }
 
         settings.ostr << (settings.hilite ? hilite_keyword : "") << " AS " << (settings.hilite ? hilite_none : "");
@@ -355,7 +355,7 @@ void ASTCreateQuery::formatQueryImpl(const FormatSettings & settings, FormatStat
         settings.ostr << (settings.one_line ? ")" : "\n)");
     }
 
-    frame.expression_list_always_start_on_new_line = false;
+    frame.expression_list_always_start_on_new_line = false; //-V519
 
     if (storage)
         storage->formatImpl(settings, state, frame);
diff --git a/src/Parsers/ASTFunction.cpp b/src/Parsers/ASTFunction.cpp
index a0662a47152..cc460f600dd 100644
--- a/src/Parsers/ASTFunction.cpp
+++ b/src/Parsers/ASTFunction.cpp
@@ -223,7 +223,7 @@ void ASTFunction::formatImplWithoutAlias(const FormatSettings & settings, Format
 
             for (const char ** func = operators; *func; func += 2)
             {
-                if (strcmp(name.c_str(), func[0]) != 0)
+                if (strcasecmp(name.c_str(), func[0]) != 0)
                 {
                     continue;
                 }
@@ -415,7 +415,7 @@ void ASTFunction::formatImplWithoutAlias(const FormatSettings & settings, Format
                 // them, and we want to have consistent formatting.
                 if (tuple_arguments_valid && lit_right)
                 {
-                    if (isInt64FieldType(lit_right->value.getType())
+                    if (isInt64OrUInt64FieldType(lit_right->value.getType())
                         && lit_right->value.get<Int64>() >= 0)
                     {
                         if (frame.need_parens)
diff --git a/src/Parsers/ASTSampleRatio.h b/src/Parsers/ASTSampleRatio.h
index 09dec6aac99..a3e70b7dab7 100644
--- a/src/Parsers/ASTSampleRatio.h
+++ b/src/Parsers/ASTSampleRatio.h
@@ -2,6 +2,7 @@
 
 #include <Parsers/IAST.h>
 
+
 namespace DB
 {
 
@@ -11,12 +12,7 @@ namespace DB
 class ASTSampleRatio : public IAST
 {
 public:
-#ifdef __SIZEOF_INT128__
     using BigNum = __uint128_t;    /// Must contain the result of multiplying two UInt64.
-#else
-    #warning "No uint128_t type. Sampling ratios cannot work correctly."
-    using BigNum = uint64_t;
-#endif
 
     struct Rational
     {
diff --git a/src/Parsers/ASTWindowDefinition.cpp b/src/Parsers/ASTWindowDefinition.cpp
index 35374df6177..37b27b22c7d 100644
--- a/src/Parsers/ASTWindowDefinition.cpp
+++ b/src/Parsers/ASTWindowDefinition.cpp
@@ -1,8 +1,10 @@
 #include <Parsers/ASTWindowDefinition.h>
 
 #include <Common/quoteString.h>
+#include <Common/FieldVisitors.h>
 #include <IO/Operators.h>
 
+
 namespace DB
 {
 
diff --git a/src/Parsers/ExpressionElementParsers.cpp b/src/Parsers/ExpressionElementParsers.cpp
index 7c91d4ee89b..9c20cfd0327 100644
--- a/src/Parsers/ExpressionElementParsers.cpp
+++ b/src/Parsers/ExpressionElementParsers.cpp
@@ -497,7 +497,8 @@ bool ParserTableFunctionView::parseImpl(Pos & pos, ASTPtr & node, Expected & exp
 
 bool ParserWindowReference::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
 {
-    ASTFunction * function = dynamic_cast<ASTFunction *>(node.get());
+    assert(node);
+    ASTFunction & function = dynamic_cast<ASTFunction &>(*node);
 
     // Variant 1:
     // function_name ( * ) OVER window_name
@@ -510,7 +511,7 @@ bool ParserWindowReference::parseImpl(Pos & pos, ASTPtr & node, Expected & expec
         ParserIdentifier window_name_parser;
         if (window_name_parser.parse(pos, window_name_ast, expected))
         {
-            function->window_name = getIdentifierName(window_name_ast);
+            function.window_name = getIdentifierName(window_name_ast);
             return true;
         }
         else
@@ -522,7 +523,7 @@ bool ParserWindowReference::parseImpl(Pos & pos, ASTPtr & node, Expected & expec
     // Variant 2:
     // function_name ( * ) OVER ( window_definition )
     ParserWindowDefinition parser_definition;
-    return parser_definition.parse(pos, function->window_definition, expected);
+    return parser_definition.parse(pos, function.window_definition, expected);
 }
 
 static bool tryParseFrameDefinition(ASTWindowDefinition * node, IParser::Pos & pos,
diff --git a/src/Parsers/IAST.cpp b/src/Parsers/IAST.cpp
index 6451a9d0c0d..3a21d704eb9 100644
--- a/src/Parsers/IAST.cpp
+++ b/src/Parsers/IAST.cpp
@@ -53,7 +53,7 @@ IAST::Hash IAST::getTreeHash() const
     SipHash hash_state;
     updateTreeHash(hash_state);
     IAST::Hash res;
-    hash_state.get128(res.first, res.second);
+    hash_state.get128(res);
     return res;
 }
 
diff --git a/src/Parsers/New/ParserErrorListener.cpp b/src/Parsers/New/ParserErrorListener.cpp
index 5c1b9238d15..bc5ee84cba9 100644
--- a/src/Parsers/New/ParserErrorListener.cpp
+++ b/src/Parsers/New/ParserErrorListener.cpp
@@ -23,7 +23,8 @@ extern int SYNTAX_ERROR;
 void ParserErrorListener::syntaxError(
     Recognizer * recognizer, Token * token, size_t, size_t, const std::string & message, std::exception_ptr)
 {
-    auto * parser = dynamic_cast<ClickHouseParser*>(recognizer);
+    auto * parser = dynamic_cast<ClickHouseParser *>(recognizer);
+    assert(parser);
 
     LOG_ERROR(&Poco::Logger::get("ClickHouseParser"),
               "Last element parsed so far:\n"
diff --git a/src/Parsers/ParserExplainQuery.cpp b/src/Parsers/ParserExplainQuery.cpp
index 7a7abba94a9..c8d8dc10a7f 100644
--- a/src/Parsers/ParserExplainQuery.cpp
+++ b/src/Parsers/ParserExplainQuery.cpp
@@ -31,7 +31,7 @@ bool ParserExplainQuery::parseImpl(Pos & pos, ASTPtr & node, Expected & expected
         else if (s_pipeline.ignore(pos, expected))
             kind = ASTExplainQuery::ExplainKind::QueryPipeline;
         else if (s_plan.ignore(pos, expected))
-            kind = ASTExplainQuery::ExplainKind::QueryPlan;
+            kind = ASTExplainQuery::ExplainKind::QueryPlan; //-V1048
     }
     else
         return false;
diff --git a/src/Parsers/ParserGrantQuery.cpp b/src/Parsers/ParserGrantQuery.cpp
index d3aa62e73da..9411fa93892 100644
--- a/src/Parsers/ParserGrantQuery.cpp
+++ b/src/Parsers/ParserGrantQuery.cpp
@@ -238,8 +238,7 @@ bool ParserGrantQuery::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
         return false;
 
     String cluster;
-    if (cluster.empty())
-        parseOnCluster(pos, expected, cluster);
+    parseOnCluster(pos, expected, cluster);
 
     bool grant_option = false;
     bool admin_option = false;
diff --git a/src/Processors/Executors/PipelineExecutingBlockInputStream.cpp b/src/Processors/Executors/PipelineExecutingBlockInputStream.cpp
index 458fa0a0a90..736ad1ecefe 100644
--- a/src/Processors/Executors/PipelineExecutingBlockInputStream.cpp
+++ b/src/Processors/Executors/PipelineExecutingBlockInputStream.cpp
@@ -121,11 +121,4 @@ void PipelineExecutingBlockInputStream::setQuota(const std::shared_ptr<const Ena
                     ErrorCodes::LOGICAL_ERROR);
 }
 
-void PipelineExecutingBlockInputStream::addTotalRowsApprox(size_t)
-{
-    throw Exception("Progress is not supported by PipelineExecutingBlockInputStream",
-                    ErrorCodes::LOGICAL_ERROR);
-}
-
-
 }
diff --git a/src/Processors/Executors/PipelineExecutingBlockInputStream.h b/src/Processors/Executors/PipelineExecutingBlockInputStream.h
index e37ad41f6ab..68497938ad4 100644
--- a/src/Processors/Executors/PipelineExecutingBlockInputStream.h
+++ b/src/Processors/Executors/PipelineExecutingBlockInputStream.h
@@ -26,7 +26,6 @@ public:
     void setProcessListElement(QueryStatus * elem) final;
     void setLimits(const StreamLocalLimits & limits_) final;
     void setQuota(const std::shared_ptr<const EnabledQuota> & quota_) final;
-    void addTotalRowsApprox(size_t value) final;
 
 protected:
     void readPrefixImpl() override;
diff --git a/src/Processors/Executors/PollingQueue.h b/src/Processors/Executors/PollingQueue.h
index 0d306ddf2f7..100d762b731 100644
--- a/src/Processors/Executors/PollingQueue.h
+++ b/src/Processors/Executors/PollingQueue.h
@@ -17,7 +17,7 @@ class PollingQueue
 public:
     struct TaskData
     {
-        size_t thread_num;
+        size_t thread_num = 0;
 
         void * data = nullptr;
         int fd = -1;
diff --git a/src/Processors/Formats/IRowInputFormat.h b/src/Processors/Formats/IRowInputFormat.h
index 8c600ad7285..2ca182b7ffe 100644
--- a/src/Processors/Formats/IRowInputFormat.h
+++ b/src/Processors/Formats/IRowInputFormat.h
@@ -22,10 +22,10 @@ struct RowReadExtension
 /// Common parameters for generating blocks.
 struct RowInputFormatParams
 {
-    size_t max_block_size;
+    size_t max_block_size = 0;
 
-    UInt64 allow_errors_num;
-    Float64 allow_errors_ratio;
+    UInt64 allow_errors_num = 0;
+    Float64 allow_errors_ratio = 0;
 
     Poco::Timespan max_execution_time = 0;
     OverflowMode timeout_overflow_mode = OverflowMode::THROW;
diff --git a/src/Processors/Formats/IRowOutputFormat.cpp b/src/Processors/Formats/IRowOutputFormat.cpp
index b714844feea..6b7a9a46eaa 100644
--- a/src/Processors/Formats/IRowOutputFormat.cpp
+++ b/src/Processors/Formats/IRowOutputFormat.cpp
@@ -103,7 +103,7 @@ void IRowOutputFormat::writeMinExtreme(const DB::Columns & columns, size_t row_n
     write(columns, row_num);
 }
 
-void IRowOutputFormat::writeMaxExtreme(const DB::Columns & columns, size_t row_num)
+void IRowOutputFormat::writeMaxExtreme(const DB::Columns & columns, size_t row_num) //-V524
 {
     write(columns, row_num);
 }
diff --git a/src/Processors/Formats/Impl/CapnProtoRowInputFormat.h b/src/Processors/Formats/Impl/CapnProtoRowInputFormat.h
index 51ed451417c..0957cd1d681 100644
--- a/src/Processors/Formats/Impl/CapnProtoRowInputFormat.h
+++ b/src/Processors/Formats/Impl/CapnProtoRowInputFormat.h
@@ -50,9 +50,9 @@ private:
     struct Action
     {
         enum Type { POP, PUSH, READ };
-        Type type;
-        capnp::StructSchema::Field field = {};
-        BlockPositionList columns = {};
+        Type type{};
+        capnp::StructSchema::Field field{};
+        BlockPositionList columns{};
     };
 
     // Wrapper for classes that could throw in destructor
diff --git a/src/Processors/Formats/Impl/ConstantExpressionTemplate.cpp b/src/Processors/Formats/Impl/ConstantExpressionTemplate.cpp
index 288c6ee09ef..cc9ae5e65bb 100644
--- a/src/Processors/Formats/Impl/ConstantExpressionTemplate.cpp
+++ b/src/Processors/Formats/Impl/ConstantExpressionTemplate.cpp
@@ -363,7 +363,7 @@ size_t ConstantExpressionTemplate::TemplateStructure::getTemplateHash(const ASTP
     hash_state.update(salt);
 
     IAST::Hash res128;
-    hash_state.get128(res128.first, res128.second);
+    hash_state.get128(res128);
     size_t res = 0;
     boost::hash_combine(res, res128.first);
     boost::hash_combine(res, res128.second);
diff --git a/src/Processors/Formats/Impl/ValuesBlockInputFormat.cpp b/src/Processors/Formats/Impl/ValuesBlockInputFormat.cpp
index 701385447b4..1eb64682fae 100644
--- a/src/Processors/Formats/Impl/ValuesBlockInputFormat.cpp
+++ b/src/Processors/Formats/Impl/ValuesBlockInputFormat.cpp
@@ -6,7 +6,6 @@
 #include <Parsers/ExpressionListParsers.h>
 #include <Processors/Formats/Impl/ValuesBlockInputFormat.h>
 #include <Formats/FormatFactory.h>
-#include <Common/FieldVisitors.h>
 #include <Core/Block.h>
 #include <common/find_symbols.h>
 #include <Common/typeid_cast.h>
diff --git a/src/Processors/QueryPipeline.h b/src/Processors/QueryPipeline.h
index 0c8caa93539..90c7e370880 100644
--- a/src/Processors/QueryPipeline.h
+++ b/src/Processors/QueryPipeline.h
@@ -135,7 +135,7 @@ public:
     {
         auto num_threads = pipe.maxParallelStreams();
 
-        if (max_threads)
+        if (max_threads) //-V1051
             num_threads = std::min(num_threads, max_threads);
 
         return std::max<size_t>(1, num_threads);
diff --git a/src/Processors/QueryPlan/Optimizations/Optimizations.h b/src/Processors/QueryPlan/Optimizations/Optimizations.h
index 7e946a71fad..10bc6293537 100644
--- a/src/Processors/QueryPlan/Optimizations/Optimizations.h
+++ b/src/Processors/QueryPlan/Optimizations/Optimizations.h
@@ -23,8 +23,8 @@ struct Optimization
 {
     using Function = size_t (*)(QueryPlan::Node *, QueryPlan::Nodes &);
     const Function apply = nullptr;
-    const char * name;
-    const bool QueryPlanOptimizationSettings::* const is_enabled;
+    const char * name = "";
+    const bool QueryPlanOptimizationSettings::* const is_enabled{};
 };
 
 /// Move ARRAY JOIN up if possible.
diff --git a/src/Processors/QueryPlan/Optimizations/optimizeTree.cpp b/src/Processors/QueryPlan/Optimizations/optimizeTree.cpp
index da9b1e26f68..9a8dd151830 100644
--- a/src/Processors/QueryPlan/Optimizations/optimizeTree.cpp
+++ b/src/Processors/QueryPlan/Optimizations/optimizeTree.cpp
@@ -23,7 +23,7 @@ void optimizeTree(const QueryPlanOptimizationSettings & settings, QueryPlan::Nod
 
     struct Frame
     {
-        QueryPlan::Node * node;
+        QueryPlan::Node * node = nullptr;
 
         /// If not zero, traverse only depth_limit layers of tree (if no other optimizations happen).
         /// Otherwise, traverse all children.
diff --git a/src/Processors/QueryPlan/PartialSortingStep.cpp b/src/Processors/QueryPlan/PartialSortingStep.cpp
index f4abea440fe..d713a63028a 100644
--- a/src/Processors/QueryPlan/PartialSortingStep.cpp
+++ b/src/Processors/QueryPlan/PartialSortingStep.cpp
@@ -58,7 +58,7 @@ void PartialSortingStep::transformPipeline(QueryPipeline & pipeline, const Build
     });
 
     StreamLocalLimits limits;
-    limits.mode = LimitsMode::LIMITS_CURRENT;
+    limits.mode = LimitsMode::LIMITS_CURRENT; //-V1048
     limits.size_limits = size_limits;
 
     pipeline.addSimpleTransform([&](const Block & header, QueryPipeline::StreamType stream_type) -> ProcessorPtr
diff --git a/src/Processors/QueryPlan/QueryPlan.cpp b/src/Processors/QueryPlan/QueryPlan.cpp
index 3e46adb9d9c..44c5c48975c 100644
--- a/src/Processors/QueryPlan/QueryPlan.cpp
+++ b/src/Processors/QueryPlan/QueryPlan.cpp
@@ -142,7 +142,7 @@ QueryPipelinePtr QueryPlan::buildQueryPipeline(
 
     struct Frame
     {
-        Node * node;
+        Node * node = {};
         QueryPipelines pipelines = {};
     };
 
@@ -158,7 +158,7 @@ QueryPipelinePtr QueryPlan::buildQueryPipeline(
         if (last_pipeline)
         {
             frame.pipelines.emplace_back(std::move(last_pipeline));
-            last_pipeline = nullptr;
+            last_pipeline = nullptr; //-V1048
         }
 
         size_t next_child = frame.pipelines.size();
@@ -242,7 +242,7 @@ JSONBuilder::ItemPtr QueryPlan::explainPlan(const ExplainPlanOptions & options)
 
     struct Frame
     {
-        Node * node;
+        Node * node = {};
         size_t next_child = 0;
         std::unique_ptr<JSONBuilder::JSONMap> node_map = {};
         std::unique_ptr<JSONBuilder::JSONArray> children_array = {};
@@ -352,7 +352,7 @@ void QueryPlan::explainPlan(WriteBuffer & buffer, const ExplainPlanOptions & opt
 
     struct Frame
     {
-        Node * node;
+        Node * node = {};
         bool is_description_printed = false;
         size_t next_child = 0;
     };
@@ -398,7 +398,7 @@ void QueryPlan::explainPipeline(WriteBuffer & buffer, const ExplainPipelineOptio
 
     struct Frame
     {
-        Node * node;
+        Node * node = {};
         size_t offset = 0;
         bool is_description_printed = false;
         size_t next_child = 0;
diff --git a/src/Processors/QueryPlan/ReadFromMergeTree.cpp b/src/Processors/QueryPlan/ReadFromMergeTree.cpp
index 8a7fca63d8c..d7a78e6cc6b 100644
--- a/src/Processors/QueryPlan/ReadFromMergeTree.cpp
+++ b/src/Processors/QueryPlan/ReadFromMergeTree.cpp
@@ -26,6 +26,7 @@ ReadFromMergeTree::ReadFromMergeTree(
     : ISourceStep(DataStream{.header = MergeTreeBaseSelectProcessor::transformHeader(
         metadata_snapshot_->getSampleBlockForColumns(required_columns_, storage_.getVirtuals(), storage_.getStorageID()),
         prewhere_info_,
+        storage_.getPartitionValueType(),
         virt_column_names_)})
     , storage(storage_)
     , metadata_snapshot(std::move(metadata_snapshot_))
diff --git a/src/Processors/Transforms/AggregatingTransform.cpp b/src/Processors/Transforms/AggregatingTransform.cpp
index 3400d06dae3..cb64a25e9a9 100644
--- a/src/Processors/Transforms/AggregatingTransform.cpp
+++ b/src/Processors/Transforms/AggregatingTransform.cpp
@@ -95,7 +95,7 @@ public:
     struct SharedData
     {
         std::atomic<UInt32> next_bucket_to_merge = 0;
-        std::array<std::atomic<bool>, NUM_BUCKETS> is_bucket_processed;
+        std::array<std::atomic<bool>, NUM_BUCKETS> is_bucket_processed{};
         std::atomic<bool> is_cancelled = false;
 
         SharedData()
@@ -541,7 +541,7 @@ void AggregatingTransform::initGenerate()
     double elapsed_seconds = watch.elapsedSeconds();
     size_t rows = variants.sizeWithoutOverflowRow();
 
-    LOG_DEBUG(log, "Aggregated. {} to {} rows (from {}) in {} sec. ({} rows/sec., {}/sec.)",
+    LOG_DEBUG(log, "Aggregated. {} to {} rows (from {}) in {} sec. ({:.3f} rows/sec., {}/sec.)",
         src_rows, rows, ReadableSize(src_bytes),
         elapsed_seconds, src_rows / elapsed_seconds,
         ReadableSize(src_bytes / elapsed_seconds));
diff --git a/src/Processors/Transforms/FillingTransform.cpp b/src/Processors/Transforms/FillingTransform.cpp
index 3f3a0e75223..317453f272a 100644
--- a/src/Processors/Transforms/FillingTransform.cpp
+++ b/src/Processors/Transforms/FillingTransform.cpp
@@ -36,6 +36,8 @@ FillingTransform::FillingTransform(
         auto max_type = Field::Types::Null;
         WhichDataType which(type);
         DataTypePtr to_type;
+
+        /// TODO Wrong results for big integers.
         if (isInteger(type) || which.isDateOrDateTime())
         {
             max_type = Field::Types::Int64;
@@ -46,8 +48,11 @@ FillingTransform::FillingTransform(
             max_type = Field::Types::Float64;
             to_type = std::make_shared<DataTypeFloat64>();
         }
+        else
+            return false;
 
-        if (descr.fill_from.getType() > max_type || descr.fill_to.getType() > max_type
+        if (descr.fill_from.getType() > max_type
+            || descr.fill_to.getType() > max_type
             || descr.fill_step.getType() > max_type)
             return false;
 
diff --git a/src/Processors/Transforms/LimitByTransform.cpp b/src/Processors/Transforms/LimitByTransform.cpp
index 5c405046a83..cb2804007bd 100644
--- a/src/Processors/Transforms/LimitByTransform.cpp
+++ b/src/Processors/Transforms/LimitByTransform.cpp
@@ -33,13 +33,13 @@ void LimitByTransform::transform(Chunk & chunk)
 
     for (UInt64 row = 0; row < num_rows; ++row)
     {
-        UInt128 key(0, 0);
+        UInt128 key{};
         SipHash hash;
 
         for (auto position : key_positions)
             columns[position]->updateHashWithValue(row, hash);
 
-        hash.get128(key.low, key.high);
+        hash.get128(key);
 
         auto count = keys_counts[key]++;
         if (count >= group_offset
diff --git a/src/Processors/Transforms/LimitByTransform.h b/src/Processors/Transforms/LimitByTransform.h
index 9773f637f40..8c2b46af69e 100644
--- a/src/Processors/Transforms/LimitByTransform.h
+++ b/src/Processors/Transforms/LimitByTransform.h
@@ -1,7 +1,7 @@
 #pragma once
 #include <Processors/ISimpleTransform.h>
 #include <Common/HashTable/HashMap.h>
-#include <Common/UInt128.h>
+
 
 namespace DB
 {
diff --git a/src/Processors/Transforms/MergingAggregatedMemoryEfficientTransform.cpp b/src/Processors/Transforms/MergingAggregatedMemoryEfficientTransform.cpp
index 83c1e35ad12..df2ea4b03f0 100644
--- a/src/Processors/Transforms/MergingAggregatedMemoryEfficientTransform.cpp
+++ b/src/Processors/Transforms/MergingAggregatedMemoryEfficientTransform.cpp
@@ -228,13 +228,14 @@ IProcessor::Status GroupingAggregatedTransform::prepare()
             return Status::PortFull;
 
         /// Sanity check. If new bucket was read, we should be able to push it.
-        if (!all_inputs_finished)
+        /// This is always false, but we still keep this condition in case the code will be changed.
+        if (!all_inputs_finished) // -V547
             throw Exception("GroupingAggregatedTransform has read new two-level bucket, but couldn't push it.",
                             ErrorCodes::LOGICAL_ERROR);
     }
     else
     {
-        if (!all_inputs_finished)
+        if (!all_inputs_finished) // -V547
             throw Exception("GroupingAggregatedTransform should have read all chunks for single level aggregation, "
                             "but not all of the inputs are finished.", ErrorCodes::LOGICAL_ERROR);
 
diff --git a/src/Processors/Transforms/WindowTransform.cpp b/src/Processors/Transforms/WindowTransform.cpp
index df92f911325..798f19c37ff 100644
--- a/src/Processors/Transforms/WindowTransform.cpp
+++ b/src/Processors/Transforms/WindowTransform.cpp
@@ -3,6 +3,7 @@
 #include <AggregateFunctions/AggregateFunctionFactory.h>
 #include <Common/Arena.h>
 #include <Common/FieldVisitorsAccurateComparison.h>
+#include <common/arithmeticOverflow.h>
 #include <DataTypes/DataTypesNumber.h>
 #include <DataTypes/getLeastSupertype.h>
 #include <Interpreters/ExpressionActions.h>
@@ -67,15 +68,9 @@ static int compareValuesWithOffset(const IColumn * _compared_column,
 
     bool is_overflow;
     if (offset_is_preceding)
-    {
-        is_overflow = __builtin_sub_overflow(reference_value, offset,
-            &reference_value);
-    }
+        is_overflow = common::subOverflow(reference_value, offset, reference_value);
     else
-    {
-        is_overflow = __builtin_add_overflow(reference_value, offset,
-            &reference_value);
-    }
+        is_overflow = common::addOverflow(reference_value, offset, reference_value);
 
 //    fmt::print(stderr,
 //        "compared [{}] = {}, old ref {}, shifted ref [{}] = {}, offset {} preceding {} overflow {} to negative {}\n",
@@ -1465,7 +1460,7 @@ struct WindowFunctionLagLeadInFrame final : public WindowFunction
             return;
         }
 
-        if (!isInt64FieldType(argument_types[1]->getDefault().getType()))
+        if (!isInt64OrUInt64FieldType(argument_types[1]->getDefault().getType()))
         {
             throw Exception(ErrorCodes::BAD_ARGUMENTS,
                 "Offset must be an integer, '{}' given",
diff --git a/src/Processors/Transforms/WindowTransform.h b/src/Processors/Transforms/WindowTransform.h
index 882bf429c0a..611b03ebf72 100644
--- a/src/Processors/Transforms/WindowTransform.h
+++ b/src/Processors/Transforms/WindowTransform.h
@@ -8,6 +8,7 @@
 
 #include <deque>
 
+
 namespace DB
 {
 
diff --git a/src/Server/PostgreSQLHandler.h b/src/Server/PostgreSQLHandler.h
index cc30c85d8bb..0f114d388fb 100644
--- a/src/Server/PostgreSQLHandler.h
+++ b/src/Server/PostgreSQLHandler.h
@@ -38,9 +38,9 @@ private:
 
     IServer & server;
     ContextPtr connection_context;
-    bool ssl_enabled;
-    Int32 connection_id;
-    Int32 secret_key;
+    bool ssl_enabled = false;
+    Int32 connection_id = 0;
+    Int32 secret_key = 0;
 
     std::shared_ptr<ReadBuffer> in;
     std::shared_ptr<WriteBuffer> out;
diff --git a/src/Server/TCPHandler.cpp b/src/Server/TCPHandler.cpp
index 916f29ba1d4..9ef0292ee06 100644
--- a/src/Server/TCPHandler.cpp
+++ b/src/Server/TCPHandler.cpp
@@ -745,7 +745,7 @@ void TCPHandler::processTablesStatusRequest()
             status.absolute_delay = replicated_table->getAbsoluteDelay();
         }
         else
-            status.is_replicated = false;
+            status.is_replicated = false; //-V1048
 
         response.table_states_by_id.emplace(table_name, std::move(status));
     }
diff --git a/src/Storages/AlterCommands.cpp b/src/Storages/AlterCommands.cpp
index e3177c167c5..249b81fab3d 100644
--- a/src/Storages/AlterCommands.cpp
+++ b/src/Storages/AlterCommands.cpp
@@ -784,8 +784,10 @@ String alterTypeToString(const AlterCommand::Type type)
         return "RENAME COLUMN";
     case AlterCommand::Type::REMOVE_TTL:
         return "REMOVE TTL";
+    default:
+        throw Exception("Uninitialized ALTER command", ErrorCodes::LOGICAL_ERROR);
     }
-    __builtin_unreachable();
+
 }
 
 void AlterCommands::apply(StorageInMemoryMetadata & metadata, ContextPtr context) const
diff --git a/src/Storages/AlterCommands.h b/src/Storages/AlterCommands.h
index d6c80bc5ed4..c01536116b2 100644
--- a/src/Storages/AlterCommands.h
+++ b/src/Storages/AlterCommands.h
@@ -23,6 +23,7 @@ struct AlterCommand
 
     enum Type
     {
+        UNKNOWN,
         ADD_COLUMN,
         DROP_COLUMN,
         MODIFY_COLUMN,
@@ -55,7 +56,7 @@ struct AlterCommand
         TTL
     };
 
-    Type type;
+    Type type = UNKNOWN;
 
     String column_name;
 
diff --git a/src/Storages/LiveView/LiveViewBlockOutputStream.h b/src/Storages/LiveView/LiveViewBlockOutputStream.h
index 5a1f75a8c2f..6b8a5a2cb9e 100644
--- a/src/Storages/LiveView/LiveViewBlockOutputStream.h
+++ b/src/Storages/LiveView/LiveViewBlockOutputStream.h
@@ -3,6 +3,7 @@
 #include <DataTypes/DataTypesNumber.h>
 #include <DataStreams/IBlockOutputStream.h>
 #include <Storages/LiveView/StorageLiveView.h>
+#include <Common/hex.h>
 
 
 namespace DB
@@ -25,8 +26,8 @@ public:
         UInt128 key;
         String key_str;
 
-        new_hash->get128(key.low, key.high);
-        key_str = key.toHexString();
+        new_hash->get128(key);
+        key_str = getHexUIntLowercase(key);
 
         std::lock_guard lock(storage.mutex);
 
diff --git a/src/Storages/LiveView/StorageLiveView.cpp b/src/Storages/LiveView/StorageLiveView.cpp
index 1d81405ec26..19c3992276f 100644
--- a/src/Storages/LiveView/StorageLiveView.cpp
+++ b/src/Storages/LiveView/StorageLiveView.cpp
@@ -23,6 +23,7 @@ limitations under the License. */
 #include <common/logger_useful.h>
 #include <Common/typeid_cast.h>
 #include <Common/SipHash.h>
+#include <Common/hex.h>
 
 #include <Storages/LiveView/StorageLiveView.h>
 #include <Storages/LiveView/LiveViewBlockInputStream.h>
@@ -366,20 +367,20 @@ bool StorageLiveView::getNewBlocks()
         new_blocks->push_back(block);
     }
 
-    hash.get128(key.low, key.high);
+    hash.get128(key);
 
     /// Update blocks only if hash keys do not match
     /// NOTE: hash could be different for the same result
     ///       if blocks are not in the same order
     bool updated = false;
     {
-        if (getBlocksHashKey() != key.toHexString())
+        if (getBlocksHashKey() != getHexUIntLowercase(key))
         {
             if (new_blocks->empty())
             {
                 new_blocks->push_back(getHeader());
             }
-            new_blocks_metadata->hash = key.toHexString();
+            new_blocks_metadata->hash = getHexUIntLowercase(key);
             new_blocks_metadata->version = getBlocksVersion() + 1;
             new_blocks_metadata->time = std::chrono::system_clock::now();
 
diff --git a/src/Storages/MarkCache.h b/src/Storages/MarkCache.h
index 5dfaa9ef0ea..ccf8a2e606d 100644
--- a/src/Storages/MarkCache.h
+++ b/src/Storages/MarkCache.h
@@ -50,7 +50,7 @@ public:
 
         SipHash hash;
         hash.update(path_to_file.data(), path_to_file.size() + 1);
-        hash.get128(key.low, key.high);
+        hash.get128(key);
 
         return key;
     }
diff --git a/src/Storages/MergeTree/DataPartsExchange.cpp b/src/Storages/MergeTree/DataPartsExchange.cpp
index 82617e6e0af..3f029033054 100644
--- a/src/Storages/MergeTree/DataPartsExchange.cpp
+++ b/src/Storages/MergeTree/DataPartsExchange.cpp
@@ -419,7 +419,9 @@ MergeTreeData::MutableDataPartPtr Fetcher::fetchPart(
             throw Exception("Got 'send_s3_metadata' cookie for in-memory part", ErrorCodes::INCORRECT_PART_TYPE);
 
         UUID part_uuid = UUIDHelpers::Nil;
-        if (server_protocol_version >= REPLICATION_PROTOCOL_VERSION_WITH_PARTS_UUID)
+
+        /// Always true due to values of constants. But we keep this condition just in case.
+        if (server_protocol_version >= REPLICATION_PROTOCOL_VERSION_WITH_PARTS_UUID) //-V547
             readUUIDText(part_uuid, in);
 
         try
@@ -544,7 +546,7 @@ MergeTreeData::MutableDataPartPtr Fetcher::downloadPartToDisk(
     String tmp_prefix = tmp_prefix_.empty() ? TMP_PREFIX : tmp_prefix_;
 
     /// We will remove directory if it's already exists. Make precautions.
-    if (tmp_prefix.empty()
+    if (tmp_prefix.empty() //-V560
         || part_name.empty()
         || std::string::npos != tmp_prefix.find_first_of("/.")
         || std::string::npos != part_name.find_first_of("/."))
diff --git a/src/Storages/MergeTree/MergeSelector.h b/src/Storages/MergeTree/MergeSelector.h
index 5a92b4c5dd6..aac805823a9 100644
--- a/src/Storages/MergeTree/MergeSelector.h
+++ b/src/Storages/MergeTree/MergeSelector.h
@@ -31,16 +31,16 @@ public:
     struct Part
     {
         /// Size of data part in bytes.
-        size_t size;
+        size_t size = 0;
 
         /// How old this data part in seconds.
-        time_t age;
+        time_t age = 0;
 
         /// Depth of tree of merges by which this part was created. New parts has zero level.
-        unsigned level;
+        unsigned level = 0;
 
         /// Opaque pointer to avoid dependencies (it is not possible to do forward declaration of typedef).
-        const void * data;
+        const void * data = nullptr;
 
         /// Information about different TTLs for part. Can be used by
         /// TTLSelector to assign merges with TTL.
diff --git a/src/Storages/MergeTree/MergeTreeBaseSelectProcessor.cpp b/src/Storages/MergeTree/MergeTreeBaseSelectProcessor.cpp
index 41ad71c89ce..34475cec307 100644
--- a/src/Storages/MergeTree/MergeTreeBaseSelectProcessor.cpp
+++ b/src/Storages/MergeTree/MergeTreeBaseSelectProcessor.cpp
@@ -30,7 +30,7 @@ MergeTreeBaseSelectProcessor::MergeTreeBaseSelectProcessor(
     const MergeTreeReaderSettings & reader_settings_,
     bool use_uncompressed_cache_,
     const Names & virt_column_names_)
-    : SourceWithProgress(transformHeader(std::move(header), prewhere_info_, virt_column_names_))
+    : SourceWithProgress(transformHeader(std::move(header), prewhere_info_, storage_.getPartitionValueType(), virt_column_names_))
     , storage(storage_)
     , metadata_snapshot(metadata_snapshot_)
     , prewhere_info(prewhere_info_)
@@ -40,6 +40,7 @@ MergeTreeBaseSelectProcessor::MergeTreeBaseSelectProcessor(
     , reader_settings(reader_settings_)
     , use_uncompressed_cache(use_uncompressed_cache_)
     , virt_column_names(virt_column_names_)
+    , partition_value_type(storage.getPartitionValueType())
 {
     header_without_virtual_columns = getPort().getHeader();
 
@@ -60,7 +61,7 @@ Chunk MergeTreeBaseSelectProcessor::generate()
 
         if (res.hasRows())
         {
-            injectVirtualColumns(res, task.get(), virt_column_names);
+            injectVirtualColumns(res, task.get(), partition_value_type, virt_column_names);
             return res;
         }
     }
@@ -207,11 +208,18 @@ namespace
         virtual void insertStringColumn(const ColumnPtr & column, const String & name) = 0;
         virtual void insertUInt64Column(const ColumnPtr & column, const String & name) = 0;
         virtual void insertUUIDColumn(const ColumnPtr & column, const String & name) = 0;
+        virtual void
+        insertPartitionValueColumn(size_t rows, const Row & partition_value, const DataTypePtr & partition_value_type, const String & name)
+            = 0;
     };
 }
 
-static void injectVirtualColumnsImpl(size_t rows, VirtualColumnsInserter & inserter,
-                                     MergeTreeReadTask * task, const Names & virtual_columns)
+static void injectVirtualColumnsImpl(
+    size_t rows,
+    VirtualColumnsInserter & inserter,
+    MergeTreeReadTask * task,
+    const DataTypePtr & partition_value_type,
+    const Names & virtual_columns)
 {
     /// add virtual columns
     /// Except _sample_factor, which is added from the outside.
@@ -263,6 +271,13 @@ static void injectVirtualColumnsImpl(size_t rows, VirtualColumnsInserter & inser
 
                 inserter.insertStringColumn(column, virtual_column_name);
             }
+            else if (virtual_column_name == "_partition_value")
+            {
+                if (rows)
+                    inserter.insertPartitionValueColumn(rows, task->data_part->partition.value, partition_value_type, virtual_column_name);
+                else
+                    inserter.insertPartitionValueColumn(rows, {}, partition_value_type, virtual_column_name);
+            }
         }
     }
 }
@@ -288,6 +303,19 @@ namespace
             block.insert({column, std::make_shared<DataTypeUUID>(), name});
         }
 
+        void insertPartitionValueColumn(
+            size_t rows, const Row & partition_value, const DataTypePtr & partition_value_type, const String & name) final
+        {
+            ColumnPtr column;
+            if (rows)
+                column = partition_value_type->createColumnConst(rows, Tuple(partition_value.begin(), partition_value.end()))
+                             ->convertToFullColumnIfConst();
+            else
+                column = partition_value_type->createColumn();
+
+            block.insert({column, partition_value_type, name});
+        }
+
         Block & block;
     };
 
@@ -309,23 +337,38 @@ namespace
         {
             columns.push_back(column);
         }
+
+        void
+        insertPartitionValueColumn(size_t rows, const Row & partition_value, const DataTypePtr & partition_value_type, const String &) final
+        {
+            ColumnPtr column;
+            if (rows)
+                column = partition_value_type->createColumnConst(rows, Tuple(partition_value.begin(), partition_value.end()))
+                             ->convertToFullColumnIfConst();
+            else
+                column = partition_value_type->createColumn();
+            columns.push_back(column);
+        }
+
         Columns & columns;
     };
 }
 
-void MergeTreeBaseSelectProcessor::injectVirtualColumns(Block & block, MergeTreeReadTask * task, const Names & virtual_columns)
+void MergeTreeBaseSelectProcessor::injectVirtualColumns(
+    Block & block, MergeTreeReadTask * task, const DataTypePtr & partition_value_type, const Names & virtual_columns)
 {
-    VirtualColumnsInserterIntoBlock inserter { block };
-    injectVirtualColumnsImpl(block.rows(), inserter, task, virtual_columns);
+    VirtualColumnsInserterIntoBlock inserter{block};
+    injectVirtualColumnsImpl(block.rows(), inserter, task, partition_value_type, virtual_columns);
 }
 
-void MergeTreeBaseSelectProcessor::injectVirtualColumns(Chunk & chunk, MergeTreeReadTask * task, const Names & virtual_columns)
+void MergeTreeBaseSelectProcessor::injectVirtualColumns(
+    Chunk & chunk, MergeTreeReadTask * task, const DataTypePtr & partition_value_type, const Names & virtual_columns)
 {
     UInt64 num_rows = chunk.getNumRows();
     auto columns = chunk.detachColumns();
 
-    VirtualColumnsInserterIntoColumns inserter { columns };
-    injectVirtualColumnsImpl(num_rows, inserter, task, virtual_columns);
+    VirtualColumnsInserterIntoColumns inserter{columns};
+    injectVirtualColumnsImpl(num_rows, inserter, task, partition_value_type, virtual_columns);
 
     chunk.setColumns(columns, num_rows);
 }
@@ -371,10 +414,10 @@ void MergeTreeBaseSelectProcessor::executePrewhereActions(Block & block, const P
 }
 
 Block MergeTreeBaseSelectProcessor::transformHeader(
-    Block block, const PrewhereInfoPtr & prewhere_info, const Names & virtual_columns)
+    Block block, const PrewhereInfoPtr & prewhere_info, const DataTypePtr & partition_value_type, const Names & virtual_columns)
 {
     executePrewhereActions(block, prewhere_info);
-    injectVirtualColumns(block, nullptr, virtual_columns);
+    injectVirtualColumns(block, nullptr, partition_value_type, virtual_columns);
     return block;
 }
 
diff --git a/src/Storages/MergeTree/MergeTreeBaseSelectProcessor.h b/src/Storages/MergeTree/MergeTreeBaseSelectProcessor.h
index a4c55cbae45..4615dec089f 100644
--- a/src/Storages/MergeTree/MergeTreeBaseSelectProcessor.h
+++ b/src/Storages/MergeTree/MergeTreeBaseSelectProcessor.h
@@ -33,7 +33,8 @@ public:
 
     ~MergeTreeBaseSelectProcessor() override;
 
-    static Block transformHeader(Block block, const PrewhereInfoPtr & prewhere_info, const Names & virtual_columns);
+    static Block transformHeader(
+        Block block, const PrewhereInfoPtr & prewhere_info, const DataTypePtr & partition_value_type, const Names & virtual_columns);
 
     static void executePrewhereActions(Block & block, const PrewhereInfoPtr & prewhere_info);
 
@@ -48,8 +49,10 @@ protected:
     Chunk readFromPartImpl();
 
     /// Two versions for header and chunk.
-    static void injectVirtualColumns(Block & block, MergeTreeReadTask * task, const Names & virtual_columns);
-    static void injectVirtualColumns(Chunk & chunk, MergeTreeReadTask * task, const Names & virtual_columns);
+    static void
+    injectVirtualColumns(Block & block, MergeTreeReadTask * task, const DataTypePtr & partition_value_type, const Names & virtual_columns);
+    static void
+    injectVirtualColumns(Chunk & chunk, MergeTreeReadTask * task, const DataTypePtr & partition_value_type, const Names & virtual_columns);
 
     void initializeRangeReaders(MergeTreeReadTask & task);
 
@@ -68,6 +71,9 @@ protected:
     bool use_uncompressed_cache;
 
     Names virt_column_names;
+
+    DataTypePtr partition_value_type;
+
     /// This header is used for chunks from readFromPart().
     Block header_without_virtual_columns;
 
diff --git a/src/Storages/MergeTree/MergeTreeData.cpp b/src/Storages/MergeTree/MergeTreeData.cpp
index c9ad3f10bd8..cc0faea1a07 100644
--- a/src/Storages/MergeTree/MergeTreeData.cpp
+++ b/src/Storages/MergeTree/MergeTreeData.cpp
@@ -7,6 +7,7 @@
 #include <DataTypes/DataTypeLowCardinality.h>
 #include <DataTypes/DataTypeNullable.h>
 #include <DataTypes/DataTypeUUID.h>
+#include <DataTypes/DataTypeTuple.h>
 #include <DataTypes/NestedUtils.h>
 #include <Formats/FormatFactory.h>
 #include <Functions/FunctionFactory.h>
@@ -686,6 +687,62 @@ void MergeTreeData::MergingParams::check(const StorageInMemoryMetadata & metadat
 }
 
 
+DataTypePtr MergeTreeData::getPartitionValueType() const
+{
+    DataTypePtr partition_value_type;
+    auto partition_types = getInMemoryMetadataPtr()->partition_key.sample_block.getDataTypes();
+    if (partition_types.empty())
+        partition_value_type = std::make_shared<DataTypeUInt8>();
+    else
+        partition_value_type = std::make_shared<DataTypeTuple>(std::move(partition_types));
+    return partition_value_type;
+}
+
+
+Block MergeTreeData::getBlockWithVirtualPartColumns(const MergeTreeData::DataPartsVector & parts, bool one_part) const
+{
+    DataTypePtr partition_value_type = getPartitionValueType();
+    bool has_partition_value = typeid_cast<const DataTypeTuple *>(partition_value_type.get());
+    Block block{
+        ColumnWithTypeAndName(ColumnString::create(), std::make_shared<DataTypeString>(), "_part"),
+        ColumnWithTypeAndName(ColumnString::create(), std::make_shared<DataTypeString>(), "_partition_id"),
+        ColumnWithTypeAndName(ColumnUUID::create(), std::make_shared<DataTypeUUID>(), "_part_uuid"),
+        ColumnWithTypeAndName(partition_value_type->createColumn(), partition_value_type, "_partition_value")};
+
+    MutableColumns columns = block.mutateColumns();
+
+    auto & part_column = columns[0];
+    auto & partition_id_column = columns[1];
+    auto & part_uuid_column = columns[2];
+    auto & partition_value_column = columns[3];
+
+    for (const auto & part : parts)
+    {
+        part_column->insert(part->name);
+        partition_id_column->insert(part->info.partition_id);
+        part_uuid_column->insert(part->uuid);
+        Tuple tuple(part->partition.value.begin(), part->partition.value.end());
+        if (has_partition_value)
+            partition_value_column->insert(tuple);
+
+        if (one_part)
+        {
+            part_column = ColumnConst::create(std::move(part_column), 1);
+            partition_id_column = ColumnConst::create(std::move(partition_id_column), 1);
+            part_uuid_column = ColumnConst::create(std::move(part_uuid_column), 1);
+            if (has_partition_value)
+                partition_value_column = ColumnConst::create(std::move(partition_value_column), 1);
+            break;
+        }
+    }
+
+    block.setColumns(std::move(columns));
+    if (!has_partition_value)
+        block.erase("_partition_value");
+    return block;
+}
+
+
 std::optional<UInt64> MergeTreeData::totalRowsByPartitionPredicateImpl(
     const SelectQueryInfo & query_info, ContextPtr local_context, const DataPartsVector & parts) const
 {
@@ -693,7 +750,7 @@ std::optional<UInt64> MergeTreeData::totalRowsByPartitionPredicateImpl(
         return 0u;
     auto metadata_snapshot = getInMemoryMetadataPtr();
     ASTPtr expression_ast;
-    Block virtual_columns_block = MergeTreeDataSelectExecutor::getBlockWithVirtualPartColumns(parts, true /* one_part */);
+    Block virtual_columns_block = getBlockWithVirtualPartColumns(parts, true /* one_part */);
 
     // Generate valid expressions for filtering
     bool valid = VirtualColumnUtils::prepareFilterBlockWithQuery(query_info.query, local_context, virtual_columns_block, expression_ast);
@@ -705,7 +762,7 @@ std::optional<UInt64> MergeTreeData::totalRowsByPartitionPredicateImpl(
     std::unordered_set<String> part_values;
     if (valid && expression_ast)
     {
-        virtual_columns_block = MergeTreeDataSelectExecutor::getBlockWithVirtualPartColumns(parts, false /* one_part */);
+        virtual_columns_block = getBlockWithVirtualPartColumns(parts, false /* one_part */);
         VirtualColumnUtils::filterBlockWithQuery(query_info.query, virtual_columns_block, local_context, expression_ast);
         part_values = VirtualColumnUtils::extractSingleValueFromBlock<String>(virtual_columns_block, "_part");
         if (part_values.empty())
@@ -1185,7 +1242,7 @@ void MergeTreeData::removePartsFinally(const MergeTreeData::DataPartsVector & pa
 
         part_log_elem.event_type = PartLogElement::REMOVE_PART;
         part_log_elem.event_time = time(nullptr);
-        part_log_elem.duration_ms = 0;
+        part_log_elem.duration_ms = 0; //-V1048
 
         part_log_elem.database_name = table_id.database_name;
         part_log_elem.table_name = table_id.table_name;
@@ -3033,6 +3090,9 @@ Pipe MergeTreeData::alterPartition(
             }
 
             break;
+
+            default:
+                throw Exception("Uninitialized partition command", ErrorCodes::LOGICAL_ERROR);
         }
         for (auto & command_result : current_command_results)
             command_result.command_type = command.typeToString();
@@ -4276,6 +4336,7 @@ NamesAndTypesList MergeTreeData::getVirtuals() const
         NameAndTypePair("_part_index", std::make_shared<DataTypeUInt64>()),
         NameAndTypePair("_part_uuid", std::make_shared<DataTypeUUID>()),
         NameAndTypePair("_partition_id", std::make_shared<DataTypeString>()),
+        NameAndTypePair("_partition_value", getPartitionValueType()),
         NameAndTypePair("_sample_factor", std::make_shared<DataTypeFloat64>()),
     };
 }
diff --git a/src/Storages/MergeTree/MergeTreeData.h b/src/Storages/MergeTree/MergeTreeData.h
index 46c0014d9f7..52e1396769a 100644
--- a/src/Storages/MergeTree/MergeTreeData.h
+++ b/src/Storages/MergeTree/MergeTreeData.h
@@ -762,6 +762,13 @@ public:
     /// Remove current query id after query finished.
     void removeQueryId(const String & query_id) const;
 
+    /// Return the partition expression types as a Tuple type. Return DataTypeUInt8 if partition expression is empty.
+    DataTypePtr getPartitionValueType() const;
+
+    /// Construct a block consisting only of possible virtual columns for part pruning.
+    /// If one_part is true, fill in at most one part.
+    Block getBlockWithVirtualPartColumns(const MergeTreeData::DataPartsVector & parts, bool one_part) const;
+
     /// Limiting parallel sends per one table, used in DataPartsExchange
     std::atomic_uint current_table_sends {0};
 
diff --git a/src/Storages/MergeTree/MergeTreeDataPartChecksum.cpp b/src/Storages/MergeTree/MergeTreeDataPartChecksum.cpp
index b0eb1cbea70..3a944b3e7f0 100644
--- a/src/Storages/MergeTree/MergeTreeDataPartChecksum.cpp
+++ b/src/Storages/MergeTree/MergeTreeDataPartChecksum.cpp
@@ -299,7 +299,8 @@ String MergeTreeDataPartChecksums::getTotalChecksumHex() const
         hash_of_all_files.update(checksum.file_hash);
     }
 
-    UInt64 lo, hi;
+    UInt64 lo;
+    UInt64 hi;
     hash_of_all_files.get128(lo, hi);
 
     return getHexUIntUppercase(hi) + getHexUIntUppercase(lo);
@@ -394,7 +395,7 @@ void MinimalisticDataPartChecksums::computeTotalChecksums(const MergeTreeDataPar
 
     auto get_hash = [] (SipHash & hash, uint128 & data)
     {
-        hash.get128(data.first, data.second);
+        hash.get128(data);
     };
 
     get_hash(hash_of_all_files_state, hash_of_all_files);
diff --git a/src/Storages/MergeTree/MergeTreeDataPartInMemory.cpp b/src/Storages/MergeTree/MergeTreeDataPartInMemory.cpp
index 045ab488ada..fb7431e0bfe 100644
--- a/src/Storages/MergeTree/MergeTreeDataPartInMemory.cpp
+++ b/src/Storages/MergeTree/MergeTreeDataPartInMemory.cpp
@@ -125,7 +125,7 @@ IMergeTreeDataPart::Checksum MergeTreeDataPartInMemory::calculateBlockChecksum()
         column.column->updateHashFast(hash);
 
     checksum.uncompressed_size = block.bytes();
-    hash.get128(checksum.uncompressed_hash.first, checksum.uncompressed_hash.second);
+    hash.get128(checksum.uncompressed_hash);
     return checksum;
 }
 
diff --git a/src/Storages/MergeTree/MergeTreeDataPartUUID.cpp b/src/Storages/MergeTree/MergeTreeDataPartUUID.cpp
index 17d19855798..3c3a6ecee7f 100644
--- a/src/Storages/MergeTree/MergeTreeDataPartUUID.cpp
+++ b/src/Storages/MergeTree/MergeTreeDataPartUUID.cpp
@@ -1,5 +1,7 @@
+#include <vector>
 #include <Storages/MergeTree/MergeTreeDataPartUUID.h>
 
+
 namespace DB
 {
 
diff --git a/src/Storages/MergeTree/MergeTreeDataPartWriterCompact.cpp b/src/Storages/MergeTree/MergeTreeDataPartWriterCompact.cpp
index 2efda206cf9..5e85f88a487 100644
--- a/src/Storages/MergeTree/MergeTreeDataPartWriterCompact.cpp
+++ b/src/Storages/MergeTree/MergeTreeDataPartWriterCompact.cpp
@@ -114,8 +114,8 @@ void writeColumnSingleGranule(
     ISerialization::SerializeBinaryBulkSettings serialize_settings;
 
     serialize_settings.getter = stream_getter;
-    serialize_settings.position_independent_encoding = true;
-    serialize_settings.low_cardinality_max_dictionary_size = 0;
+    serialize_settings.position_independent_encoding = true; //-V1048
+    serialize_settings.low_cardinality_max_dictionary_size = 0; //-V1048
 
     serialization->serializeBinaryBulkStatePrefix(serialize_settings, state);
     serialization->serializeBinaryBulkWithMultipleStreams(*column.column, from_row, number_of_rows, serialize_settings, state);
diff --git a/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp b/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp
index 8debf961b89..57c44fd84c7 100644
--- a/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp
+++ b/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp
@@ -3,7 +3,7 @@
 #include <optional>
 #include <unordered_set>
 
-#include <Common/FieldVisitors.h>
+#include <Poco/File.h>
 #include <Storages/MergeTree/MergeTreeDataSelectExecutor.h>
 #include <Storages/MergeTree/MergeTreeSelectProcessor.h>
 #include <Storages/MergeTree/MergeTreeReverseSelectProcessor.h>
@@ -35,9 +35,11 @@
 #include <DataTypes/DataTypeDate.h>
 #include <DataTypes/DataTypeEnum.h>
 #include <DataTypes/DataTypeUUID.h>
+#include <DataTypes/DataTypeTuple.h>
 #include <DataTypes/DataTypesNumber.h>
 #include <Storages/VirtualColumnUtils.h>
 
+
 namespace ProfileEvents
 {
     extern const Event SelectedParts;
@@ -60,6 +62,7 @@ namespace ErrorCodes
     extern const int CANNOT_PARSE_TEXT;
     extern const int TOO_MANY_PARTITIONS;
     extern const int DUPLICATED_PART_UUIDS;
+    extern const int NO_SUCH_COLUMN_IN_TABLE;
 }
 
 
@@ -68,38 +71,6 @@ MergeTreeDataSelectExecutor::MergeTreeDataSelectExecutor(const MergeTreeData & d
 {
 }
 
-Block MergeTreeDataSelectExecutor::getBlockWithVirtualPartColumns(const MergeTreeData::DataPartsVector & parts, bool one_part)
-{
-    Block block(std::initializer_list<ColumnWithTypeAndName>{
-        ColumnWithTypeAndName(ColumnString::create(), std::make_shared<DataTypeString>(), "_part"),
-        ColumnWithTypeAndName(ColumnString::create(), std::make_shared<DataTypeString>(), "_partition_id"),
-        ColumnWithTypeAndName(ColumnUUID::create(), std::make_shared<DataTypeUUID>(), "_part_uuid")});
-
-    MutableColumns columns = block.mutateColumns();
-
-    auto & part_column = columns[0];
-    auto & partition_id_column = columns[1];
-    auto & part_uuid_column = columns[2];
-
-    for (const auto & part : parts)
-    {
-        part_column->insert(part->name);
-        partition_id_column->insert(part->info.partition_id);
-        part_uuid_column->insert(part->uuid);
-        if (one_part)
-        {
-            part_column = ColumnConst::create(std::move(part_column), 1);
-            partition_id_column = ColumnConst::create(std::move(partition_id_column), 1);
-            part_uuid_column = ColumnConst::create(std::move(part_uuid_column), 1);
-            break;
-        }
-    }
-
-    block.setColumns(std::move(columns));
-    return block;
-}
-
-
 size_t MergeTreeDataSelectExecutor::getApproximateTotalRowsToRead(
     const MergeTreeData::DataPartsVector & parts,
     const StorageMetadataPtr & metadata_snapshot,
@@ -204,6 +175,18 @@ QueryPlanPtr MergeTreeDataSelectExecutor::readFromParts(
         {
             virt_column_names.push_back(name);
         }
+        else if (name == "_partition_value")
+        {
+            if (!typeid_cast<const DataTypeTuple *>(data.getPartitionValueType().get()))
+            {
+                throw Exception(
+                    ErrorCodes::NO_SUCH_COLUMN_IN_TABLE,
+                    "Missing column `_partition_value` because there is no partition column in table {}",
+                    data.getStorageID().getTableName());
+            }
+
+            virt_column_names.push_back(name);
+        }
         else if (name == "_sample_factor")
         {
             sample_factor_column_queried = true;
@@ -223,7 +206,7 @@ QueryPlanPtr MergeTreeDataSelectExecutor::readFromParts(
 
     std::unordered_set<String> part_values;
     ASTPtr expression_ast;
-    auto virtual_columns_block = getBlockWithVirtualPartColumns(parts, true /* one_part */);
+    auto virtual_columns_block = data.getBlockWithVirtualPartColumns(parts, true /* one_part */);
 
     // Generate valid expressions for filtering
     VirtualColumnUtils::prepareFilterBlockWithQuery(query_info.query, context, virtual_columns_block, expression_ast);
@@ -231,7 +214,7 @@ QueryPlanPtr MergeTreeDataSelectExecutor::readFromParts(
     // If there is still something left, fill the virtual block and do the filtering.
     if (expression_ast)
     {
-        virtual_columns_block = getBlockWithVirtualPartColumns(parts, false /* one_part */);
+        virtual_columns_block = data.getBlockWithVirtualPartColumns(parts, false /* one_part */);
         VirtualColumnUtils::filterBlockWithQuery(query_info.query, virtual_columns_block, context, expression_ast);
         part_values = VirtualColumnUtils::extractSingleValueFromBlock<String>(virtual_columns_block, "_part");
         if (part_values.empty())
diff --git a/src/Storages/MergeTree/MergeTreeDataSelectExecutor.h b/src/Storages/MergeTree/MergeTreeDataSelectExecutor.h
index d7193fbfbfa..07b4534da23 100644
--- a/src/Storages/MergeTree/MergeTreeDataSelectExecutor.h
+++ b/src/Storages/MergeTree/MergeTreeDataSelectExecutor.h
@@ -45,10 +45,6 @@ public:
         unsigned num_streams,
         const PartitionIdToMaxBlock * max_block_numbers_to_read = nullptr) const;
 
-    /// Construct a block consisting only of possible virtual columns for part pruning.
-    /// If one_part is true, fill in at most one part.
-    static Block getBlockWithVirtualPartColumns(const MergeTreeData::DataPartsVector & parts, bool one_part);
-
 private:
     const MergeTreeData & data;
 
diff --git a/src/Storages/MergeTree/MergeTreeIndexSet.cpp b/src/Storages/MergeTree/MergeTreeIndexSet.cpp
index ff875b185e9..6cee80983d6 100644
--- a/src/Storages/MergeTree/MergeTreeIndexSet.cpp
+++ b/src/Storages/MergeTree/MergeTreeIndexSet.cpp
@@ -69,7 +69,7 @@ void MergeTreeIndexGranuleSet::serializeBinary(WriteBuffer & ostr) const
         ISerialization::SerializeBinaryBulkSettings settings;
         settings.getter = [&ostr](ISerialization::SubstreamPath) -> WriteBuffer * { return &ostr; };
         settings.position_independent_encoding = false;
-        settings.low_cardinality_max_dictionary_size = 0;
+        settings.low_cardinality_max_dictionary_size = 0; //-V1048
 
         auto serialization = type->getDefaultSerialization();
         ISerialization::SerializeBinaryBulkStatePtr state;
diff --git a/src/Storages/MergeTree/SimpleMergeSelector.cpp b/src/Storages/MergeTree/SimpleMergeSelector.cpp
index 972c6ea6ecb..0775e021c76 100644
--- a/src/Storages/MergeTree/SimpleMergeSelector.cpp
+++ b/src/Storages/MergeTree/SimpleMergeSelector.cpp
@@ -3,6 +3,7 @@
 #include <Common/interpolate.h>
 
 #include <cmath>
+#include <cassert>
 #include <iostream>
 
 
@@ -168,7 +169,8 @@ void selectWithinPartition(
 
         for (size_t end = begin + 2; end <= parts_count; ++end)
         {
-            if (settings.max_parts_to_merge_at_once && end - begin > settings.max_parts_to_merge_at_once)
+            assert(end > begin);
+            if (settings.max_parts_to_merge_at_once && end - begin > settings.max_parts_to_merge_at_once) //-V658
                 break;
 
             if (!parts[end - 1].shall_participate_in_merges)
diff --git a/src/Storages/MergeTree/tests/gtest_ReplicatedMergeTreeLogEntry.cpp b/src/Storages/MergeTree/tests/gtest_ReplicatedMergeTreeLogEntry.cpp
deleted file mode 100644
index 03f36d866bb..00000000000
--- a/src/Storages/MergeTree/tests/gtest_ReplicatedMergeTreeLogEntry.cpp
+++ /dev/null
@@ -1,348 +0,0 @@
-#include <Storages/MergeTree/ReplicatedMergeTreeLogEntry.h>
-
-#include <IO/ReadBufferFromString.h>
-
-#include <Core/iostream_debug_helpers.h>
-
-#include <type_traits>
-#include <regex>
-
-#include <gtest/gtest.h>
-
-namespace DB
-{
-std::ostream & operator<<(std::ostream & ostr, const MergeTreeDataPartType & type)
-{
-    return ostr << type.toString();
-}
-
-std::ostream & operator<<(std::ostream & ostr, const UInt128 & v)
-{
-    return ostr << v.toHexString();
-}
-
-template <typename T, typename Tag>
-std::ostream & operator<<(std::ostream & ostr, const StrongTypedef<T, Tag> & v)
-{
-    return ostr << v.toUnderType();
-}
-
-std::ostream & operator<<(std::ostream & ostr, const MergeType & v)
-{
-    return ostr << toString(v);
-}
-
-}
-
-namespace std
-{
-
-std::ostream & operator<<(std::ostream & ostr, const std::exception_ptr & exception)
-{
-    try
-    {
-        if (exception)
-        {
-            std::rethrow_exception(exception);
-        }
-        return ostr << "<NULL EXCEPTION>";
-    }
-    catch (const std::exception& e)
-    {
-        return ostr << e.what();
-    }
-}
-
-template <typename T>
-inline std::ostream& operator<<(std::ostream & ostr, const std::vector<T> & v)
-{
-    ostr << "[";
-    for (size_t i = 0; i < v.size(); ++i)
-    {
-        ostr << i;
-        if (i != v.size() - 1)
-            ostr << ", ";
-    }
-    return ostr << "] (" << v.size() << ") items";
-}
-
-}
-
-namespace
-{
-using namespace DB;
-
-template <typename T>
-void compareAttributes(::testing::AssertionResult & result, const char * name, const T & expected_value, const T & actual_value);
-
-#define CMP_ATTRIBUTE(attribute) compareAttributes(result, #attribute, expected.attribute, actual.attribute)
-
-::testing::AssertionResult compare(
-        const ReplicatedMergeTreeLogEntryData::ReplaceRangeEntry & expected,
-        const ReplicatedMergeTreeLogEntryData::ReplaceRangeEntry & actual)
-{
-    auto result = ::testing::AssertionSuccess();
-
-    CMP_ATTRIBUTE(drop_range_part_name);
-    CMP_ATTRIBUTE(from_database);
-    CMP_ATTRIBUTE(from_table);
-    CMP_ATTRIBUTE(src_part_names);
-    CMP_ATTRIBUTE(new_part_names);
-    CMP_ATTRIBUTE(part_names_checksums);
-    CMP_ATTRIBUTE(columns_version);
-
-    return result;
-}
-
-template <typename T>
-bool compare(const T & expected, const T & actual)
-{
-    return expected == actual;
-}
-
-template <typename T>
-::testing::AssertionResult compare(const std::shared_ptr<T> & expected, const std::shared_ptr<T> & actual)
-{
-    if (!!expected != !!actual)
-        return ::testing::AssertionFailure()
-                << "expected : " << static_cast<const void*>(expected.get())
-                << "\nactual   : " << static_cast<const void*>(actual.get());
-
-    if (expected && actual)
-        return compare(*expected, *actual);
-
-    return ::testing::AssertionSuccess();
-}
-
-template <typename T>
-void compareAttributes(::testing::AssertionResult & result, const char * name, const T & expected_value, const T & actual_value)
-{
-    const auto cmp_result = compare(expected_value, actual_value);
-    if (cmp_result == false)
-    {
-        if (result)
-            result = ::testing::AssertionFailure();
-
-        result << "\nMismatching attribute: \"" << name << "\"";
-        if constexpr (std::is_same_v<std::decay_t<decltype(cmp_result)>, ::testing::AssertionResult>)
-            result << "\n" << cmp_result.message();
-        else
-            result << "\n\texpected: " << expected_value
-                   << "\n\tactual  : " << actual_value;
-    }
-};
-
-::testing::AssertionResult compare(const ReplicatedMergeTreeLogEntryData & expected, const ReplicatedMergeTreeLogEntryData & actual)
-{
-    ::testing::AssertionResult result = ::testing::AssertionSuccess();
-
-    CMP_ATTRIBUTE(znode_name);
-    CMP_ATTRIBUTE(type);
-    CMP_ATTRIBUTE(source_replica);
-    CMP_ATTRIBUTE(new_part_name);
-    CMP_ATTRIBUTE(new_part_type);
-    CMP_ATTRIBUTE(block_id);
-    CMP_ATTRIBUTE(actual_new_part_name);
-    CMP_ATTRIBUTE(new_part_uuid);
-    CMP_ATTRIBUTE(source_parts);
-    CMP_ATTRIBUTE(deduplicate);
-    CMP_ATTRIBUTE(deduplicate_by_columns);
-    CMP_ATTRIBUTE(merge_type);
-    CMP_ATTRIBUTE(column_name);
-    CMP_ATTRIBUTE(index_name);
-    CMP_ATTRIBUTE(detach);
-    CMP_ATTRIBUTE(replace_range_entry);
-    CMP_ATTRIBUTE(alter_version);
-    CMP_ATTRIBUTE(have_mutation);
-    CMP_ATTRIBUTE(columns_str);
-    CMP_ATTRIBUTE(metadata_str);
-    CMP_ATTRIBUTE(currently_executing);
-    CMP_ATTRIBUTE(removed_by_other_entry);
-    CMP_ATTRIBUTE(num_tries);
-    CMP_ATTRIBUTE(exception);
-    CMP_ATTRIBUTE(last_attempt_time);
-    CMP_ATTRIBUTE(num_postponed);
-    CMP_ATTRIBUTE(postpone_reason);
-    CMP_ATTRIBUTE(last_postpone_time);
-    CMP_ATTRIBUTE(create_time);
-    CMP_ATTRIBUTE(quorum);
-
-    return result;
-}
-}
-
-
-class ReplicatedMergeTreeLogEntryDataTest : public ::testing::TestWithParam<std::tuple<ReplicatedMergeTreeLogEntryData, const char* /* serialized RE*/>>
-{};
-
-TEST_P(ReplicatedMergeTreeLogEntryDataTest, transcode)
-{
-    const auto & [expected, match_regex] = GetParam();
-    const auto str = expected.toString();
-
-    if (match_regex)
-    {
-        try
-        {
-            // egrep since "." matches newline and we can also use "\n" explicitly
-            std::regex re(match_regex, std::regex::egrep);
-            EXPECT_TRUE(std::regex_match(str, re))
-                    << "Failed to match serialized ReplicatedMergeTreeLogEntryData: {\n"
-                    << str << "} \nwith regex: \"" << match_regex << "\"\n";
-        }
-        catch (const std::regex_error &e)
-        {
-            FAIL() << e.what()
-                   << " on regex: " << match_regex
-                   << " (" << strlen(match_regex) << " bytes)" << std::endl;
-        }
-        catch (...)
-        {
-            throw;
-        }
-    }
-
-    ReplicatedMergeTreeLogEntryData actual;
-    {
-        DB::ReadBufferFromString buffer(str);
-        EXPECT_NO_THROW(actual.readText(buffer)) << "While reading:\n" << str;
-    }
-
-    ASSERT_TRUE(compare(expected, actual)) << "Via text:\n" << str;
-}
-
-// Enabling this warning would ruin test brievity without adding anything else in return,
-// since most of the fields have default constructors or be will be zero-initialized as by standard,
-// so values are predicatable and stable across runs.
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
-
-INSTANTIATE_TEST_SUITE_P(Merge, ReplicatedMergeTreeLogEntryDataTest,
-        ::testing::ValuesIn(std::initializer_list<std::tuple<ReplicatedMergeTreeLogEntryData, const char*>>{
-    {
-        {
-            // Basic: minimal set of attributes.
-            .type = ReplicatedMergeTreeLogEntryData::MERGE_PARTS,
-            .new_part_type = MergeTreeDataPartType::WIDE,
-            .create_time = 123, // 0 means 'now' which could cause flaky tests.
-        },
-        R"re(^format version: 4.+merge.+into.+deduplicate: 0.+$)re"
-    },
-    {
-        {
-            .type = ReplicatedMergeTreeLogEntryData::MERGE_PARTS,
-            .new_part_type = MergeTreeDataPartType::WIDE,
-
-            // Format version 4
-            .deduplicate = true,
-
-            .create_time = 123,
-        },
-        R"re(^format version: 4.+merge.+into.+deduplicate: 1.+$)re"
-    },
-    {
-        {
-            .type = ReplicatedMergeTreeLogEntryData::MERGE_PARTS,
-            .new_part_type = MergeTreeDataPartType::WIDE,
-
-            // Format version 5
-            .new_part_uuid = UUID(UInt128(123456789, 10111213141516)),
-
-            .create_time = 123,
-        },
-        R"re(^format version: 5.+merge.+into.+deduplicate: 0.+into_uuid: 00000000-075b-cd15-0000-093233447e0c.+$)re"
-    },
-    {
-        {
-            .type = ReplicatedMergeTreeLogEntryData::MERGE_PARTS,
-            .new_part_type = MergeTreeDataPartType::WIDE,
-
-            // Format version 6
-            .deduplicate = true,
-            .deduplicate_by_columns = {"foo", "bar", "qux"},
-
-            .create_time = 123,
-        },
-        R"re(^format version: 6.+merge.+into.+deduplicate: 1.+deduplicate_by_columns: 'foo','bar','qux'.*$)re"
-    },
-    {
-        {
-            .type = ReplicatedMergeTreeLogEntryData::MERGE_PARTS,
-            .new_part_type = MergeTreeDataPartType::WIDE,
-
-            // Mixing features
-            .new_part_uuid = UUID(UInt128(123456789, 10111213141516)),
-            .deduplicate = true,
-            .deduplicate_by_columns = {"foo", "bar", "qux"},
-
-            .create_time = 123,
-        },
-        R"re(^format version: 6.+merge.+into.+deduplicate: 1.+into_uuid: 00000000-075b-cd15-0000-093233447e0c.+deduplicate_by_columns: 'foo','bar','qux'.*$)re"
-    },
-    {
-        // Validate that exotic column names are serialized/deserialized properly
-        {
-            .type = ReplicatedMergeTreeLogEntryData::MERGE_PARTS,
-            .new_part_type = MergeTreeDataPartType::WIDE,
-
-            // Mixing features
-            .new_part_uuid = UUID(UInt128(123456789, 10111213141516)),
-            .deduplicate = true,
-            .deduplicate_by_columns = {"name with space", "\"column\"", "'column'", "колонка", "\u30ab\u30e9\u30e0", "\x01\x03 column \x10\x11\x12"},
-
-            .create_time = 123,
-        },
-        R"re(^format version: 6.+merge.+deduplicate_by_columns: 'name with space','"column"','\\'column\\'','колонка')re"
-                ",'\u30ab\u30e9\u30e0','\x01\x03 column \x10\x11\x12'.*$"
-    },
-}));
-
-#pragma GCC diagnostic pop
-
-// This is just an example of how to set all fields. Can't be used as is since depending on type,
-// only some fields are serialized/deserialized, and even if everything works perfectly,
-// some fields in deserialized object would be unset (hence differ from expected).
-// INSTANTIATE_TEST_SUITE_P(Full, ReplicatedMergeTreeLogEntryDataTest,
-//         ::testing::ValuesIn(std::initializer_list<ReplicatedMergeTreeLogEntryData>{
-//     {
-//         .znode_name = "znode name",
-//         .type = ReplicatedMergeTreeLogEntryData::MERGE_PARTS,
-//         .source_replica = "source replica",
-//         .new_part_name = "new part name",
-//         .new_part_type = MergeTreeDataPartType::WIDE,
-//         .block_id = "block id",
-//         .actual_new_part_name = "new part name",
-//         .new_part_uuid = UUID(UInt128(123456789, 10111213141516)),
-//         .source_parts = {"part1", "part2"},
-//         .deduplicate = true,
-//         .deduplicate_by_columns = {"col1", "col2"},
-//         .merge_type = MergeType::REGULAR,
-//         .column_name = "column name",
-//         .index_name = "index name",
-//         .detach = false,
-//         .replace_range_entry = std::make_shared<ReplicatedMergeTreeLogEntryData::ReplaceRangeEntry>(
-//             ReplicatedMergeTreeLogEntryData::ReplaceRangeEntry
-//             {
-//                 .drop_range_part_name = "drop range part name",
-//                 .from_database = "from database",
-//                 .src_part_names = {"src part name1", "src part name2"},
-//                 .new_part_names = {"new part name1", "new part name2"},
-//                 .columns_version = 123456,
-//             }),
-//         .alter_version = 56789,
-//         .have_mutation = false,
-//         .columns_str = "columns str",
-//         .metadata_str = "metadata str",
-//         // Those attributes are not serialized to string, hence it makes no sense to set.
-//         // .currently_executing
-//         // .removed_by_other_entry
-//         // .num_tries
-//         // .exception
-//         // .last_attempt_time
-//         // .num_postponed
-//         // .postpone_reason
-//         // .last_postpone_time,
-//         .create_time = static_cast<time_t>(123456789),
-//         .quorum = 321,
-//     },
-// }));
diff --git a/src/Storages/PartitionCommands.cpp b/src/Storages/PartitionCommands.cpp
index f09f60887e8..7cee3a59345 100644
--- a/src/Storages/PartitionCommands.cpp
+++ b/src/Storages/PartitionCommands.cpp
@@ -13,6 +13,12 @@
 namespace DB
 {
 
+namespace ErrorCodes
+{
+    extern const int LOGICAL_ERROR;
+}
+
+
 std::optional<PartitionCommand> PartitionCommand::parse(const ASTAlterCommand * command_ast)
 {
     if (command_ast->type == ASTAlterCommand::DROP_PARTITION)
@@ -155,8 +161,9 @@ std::string PartitionCommand::typeToString() const
         return "UNFREEZE ALL";
     case PartitionCommand::Type::REPLACE_PARTITION:
         return "REPLACE PARTITION";
+    default:
+        throw Exception("Uninitialized partition command", ErrorCodes::LOGICAL_ERROR);
     }
-    __builtin_unreachable();
 }
 
 Pipe convertCommandsResultToSource(const PartitionCommandsResultInfo & commands_result)
diff --git a/src/Storages/PartitionCommands.h b/src/Storages/PartitionCommands.h
index 9f89d44bd4e..b1ff77a758b 100644
--- a/src/Storages/PartitionCommands.h
+++ b/src/Storages/PartitionCommands.h
@@ -20,6 +20,8 @@ struct PartitionCommand
 {
     enum Type
     {
+        UNKNOWN,
+
         ATTACH_PARTITION,
         MOVE_PARTITION,
         DROP_PARTITION,
@@ -32,7 +34,7 @@ struct PartitionCommand
         REPLACE_PARTITION,
     };
 
-    Type type;
+    Type type = UNKNOWN;
 
     ASTPtr partition;
 
diff --git a/src/Storages/RabbitMQ/ReadBufferFromRabbitMQConsumer.h b/src/Storages/RabbitMQ/ReadBufferFromRabbitMQConsumer.h
index 23e1d3f0649..9b8a73fc4fb 100644
--- a/src/Storages/RabbitMQ/ReadBufferFromRabbitMQConsumer.h
+++ b/src/Storages/RabbitMQ/ReadBufferFromRabbitMQConsumer.h
@@ -48,9 +48,9 @@ public:
     {
         String message;
         String message_id;
-        uint64_t timestamp;
-        bool redelivered;
-        AckTracker track;
+        uint64_t timestamp = 0;
+        bool redelivered = false;
+        AckTracker track{};
     };
 
     ChannelPtr & getChannel() { return consumer_channel; }
diff --git a/src/Storages/RabbitMQ/StorageRabbitMQ.cpp b/src/Storages/RabbitMQ/StorageRabbitMQ.cpp
index de923390300..e49c8bf1729 100644
--- a/src/Storages/RabbitMQ/StorageRabbitMQ.cpp
+++ b/src/Storages/RabbitMQ/StorageRabbitMQ.cpp
@@ -192,7 +192,7 @@ String StorageRabbitMQ::getTableBasedName(String name, const StorageID & table_i
 std::shared_ptr<Context> StorageRabbitMQ::addSettings(ContextPtr local_context) const
 {
     auto modified_context = Context::createCopy(local_context);
-    modified_context->setSetting("input_format_skip_unknown_fields", true);
+    modified_context->setSetting("input_format_skip_unknown_fields", Field{true});
     modified_context->setSetting("input_format_allow_errors_ratio", 0.);
     modified_context->setSetting("input_format_allow_errors_num", rabbitmq_settings->rabbitmq_skip_broken_messages.value);
 
@@ -402,7 +402,7 @@ void StorageRabbitMQ::bindExchange()
         }
     }
 
-    while (!binding_created)
+    while (!binding_created) //-V776
     {
         event_handler->iterateLoop();
     }
@@ -463,7 +463,7 @@ void StorageRabbitMQ::bindQueue(size_t queue_id)
     const String queue_name = !hash_exchange ? queue_base : std::to_string(queue_id) + "_" + queue_base;
     setup_channel->declareQueue(queue_name, AMQP::durable, queue_settings).onSuccess(success_callback).onError(error_callback);
 
-    while (!binding_created)
+    while (!binding_created) //-V776
     {
         event_handler->iterateLoop();
     }
diff --git a/src/Storages/StorageBuffer.cpp b/src/Storages/StorageBuffer.cpp
index 58161a94f45..08c55c79775 100644
--- a/src/Storages/StorageBuffer.cpp
+++ b/src/Storages/StorageBuffer.cpp
@@ -859,7 +859,7 @@ void StorageBuffer::flushBuffer(Buffer & buffer, bool check_thresholds, bool loc
 
         buffer.data.swap(block_to_write);
 
-        if (!buffer.first_write_time)
+        if (!buffer.first_write_time) // -V547
             buffer.first_write_time = current_time;
 
         /// After a while, the next write attempt will happen.
diff --git a/src/Storages/StorageGenerateRandom.cpp b/src/Storages/StorageGenerateRandom.cpp
index bc158c38f37..7987fcc3b31 100644
--- a/src/Storages/StorageGenerateRandom.cpp
+++ b/src/Storages/StorageGenerateRandom.cpp
@@ -213,10 +213,7 @@ ColumnPtr fillColumnWithRandomData(
         {
             auto column = ColumnUInt16::create();
             column->getData().resize(limit);
-
-            for (size_t i = 0; i < limit; ++i)
-                column->getData()[i] = rng() % (DATE_LUT_MAX_DAY_NUM + 1);
-
+            fillBufferWithRandomData(reinterpret_cast<char *>(column->getData().data()), limit * sizeof(UInt16), rng);
             return column;
         }
         case TypeIndex::UInt32: [[fallthrough]];
@@ -234,14 +231,28 @@ ColumnPtr fillColumnWithRandomData(
             fillBufferWithRandomData(reinterpret_cast<char *>(column->getData().data()), limit * sizeof(UInt64), rng);
             return column;
         }
-        case TypeIndex::UInt128: [[fallthrough]];
-        case TypeIndex::UUID:
+        case TypeIndex::UInt128:
         {
             auto column = ColumnUInt128::create();
             column->getData().resize(limit);
             fillBufferWithRandomData(reinterpret_cast<char *>(column->getData().data()), limit * sizeof(UInt128), rng);
             return column;
         }
+        case TypeIndex::UInt256:
+        {
+            auto column = ColumnUInt256::create();
+            column->getData().resize(limit);
+            fillBufferWithRandomData(reinterpret_cast<char *>(column->getData().data()), limit * sizeof(UInt256), rng);
+            return column;
+        }
+        case TypeIndex::UUID:
+        {
+            auto column = ColumnUUID::create();
+            column->getData().resize(limit);
+            /// NOTE This is slightly incorrect as random UUIDs should have fixed version 4.
+            fillBufferWithRandomData(reinterpret_cast<char *>(column->getData().data()), limit * sizeof(UUID), rng);
+            return column;
+        }
         case TypeIndex::Int8:
         {
             auto column = ColumnInt8::create();
@@ -270,6 +281,20 @@ ColumnPtr fillColumnWithRandomData(
             fillBufferWithRandomData(reinterpret_cast<char *>(column->getData().data()), limit * sizeof(Int64), rng);
             return column;
         }
+        case TypeIndex::Int128:
+        {
+            auto column = ColumnInt128::create();
+            column->getData().resize(limit);
+            fillBufferWithRandomData(reinterpret_cast<char *>(column->getData().data()), limit * sizeof(Int128), rng);
+            return column;
+        }
+        case TypeIndex::Int256:
+        {
+            auto column = ColumnInt256::create();
+            column->getData().resize(limit);
+            fillBufferWithRandomData(reinterpret_cast<char *>(column->getData().data()), limit * sizeof(Int256), rng);
+            return column;
+        }
         case TypeIndex::Float32:
         {
             auto column = ColumnFloat32::create();
@@ -308,6 +333,14 @@ ColumnPtr fillColumnWithRandomData(
             fillBufferWithRandomData(reinterpret_cast<char *>(column_concrete.getData().data()), limit * sizeof(Decimal128), rng);
             return column;
         }
+        case TypeIndex::Decimal256:
+        {
+            auto column = type->createColumn();
+            auto & column_concrete = typeid_cast<ColumnDecimal<Decimal256> &>(*column);
+            column_concrete.getData().resize(limit);
+            fillBufferWithRandomData(reinterpret_cast<char *>(column_concrete.getData().data()), limit * sizeof(Decimal256), rng);
+            return column;
+        }
         case TypeIndex::FixedString:
         {
             size_t n = typeid_cast<const DataTypeFixedString &>(*type).getN();
diff --git a/src/Storages/StorageJoin.cpp b/src/Storages/StorageJoin.cpp
index 983b9213a35..d9970bab22c 100644
--- a/src/Storages/StorageJoin.cpp
+++ b/src/Storages/StorageJoin.cpp
@@ -408,7 +408,7 @@ private:
 
         if (!position)
             position = decltype(position)(
-                static_cast<void *>(new typename Map::const_iterator(map.begin())),
+                static_cast<void *>(new typename Map::const_iterator(map.begin())), //-V572
                 [](void * ptr) { delete reinterpret_cast<typename Map::const_iterator *>(ptr); });
 
         auto & it = *reinterpret_cast<typename Map::const_iterator *>(position.get());
diff --git a/src/Storages/StorageMerge.cpp b/src/Storages/StorageMerge.cpp
index bf7141576e8..1110b850ba9 100644
--- a/src/Storages/StorageMerge.cpp
+++ b/src/Storages/StorageMerge.cpp
@@ -241,7 +241,7 @@ Pipe StorageMerge::read(
       * since there is no certainty that it works when one of table is MergeTree and other is not.
       */
     auto modified_context = Context::createCopy(local_context);
-    modified_context->setSetting("optimize_move_to_prewhere", false);
+    modified_context->setSetting("optimize_move_to_prewhere", Field{false});
 
     /// What will be result structure depending on query processed stage in source tables?
     Block header = getHeaderForProcessingStage(*this, column_names, metadata_snapshot, query_info, local_context, processed_stage);
diff --git a/src/Storages/StorageMergeTree.cpp b/src/Storages/StorageMergeTree.cpp
index b9daa4a1f41..a337f9b6b34 100644
--- a/src/Storages/StorageMergeTree.cpp
+++ b/src/Storages/StorageMergeTree.cpp
@@ -3,7 +3,6 @@
 #include <Databases/IDatabase.h>
 #include <Common/escapeForFileName.h>
 #include <Common/typeid_cast.h>
-#include <Common/FieldVisitors.h>
 #include <Common/ThreadPool.h>
 #include <Interpreters/InterpreterAlterQuery.h>
 #include <Interpreters/PartLog.h>
@@ -228,7 +227,7 @@ StorageMergeTree::write(const ASTPtr & /*query*/, const StorageMetadataPtr & met
 {
     const auto & settings = local_context->getSettingsRef();
     return std::make_shared<MergeTreeBlockOutputStream>(
-        *this, metadata_snapshot, settings.max_partitions_per_insert_block, local_context->getSettingsRef().optimize_on_insert);
+        *this, metadata_snapshot, settings.max_partitions_per_insert_block, settings.optimize_on_insert);
 }
 
 void StorageMergeTree::checkTableCanBeDropped() const
@@ -976,7 +975,7 @@ bool StorageMergeTree::mutateSelectedPart(const StorageMetadataPtr & metadata_sn
     return true;
 }
 
-std::optional<JobAndPool> StorageMergeTree::getDataProcessingJob()
+std::optional<JobAndPool> StorageMergeTree::getDataProcessingJob() //-V657
 {
     if (shutdown_called)
         return {};
diff --git a/src/Storages/StorageReplicatedMergeTree.cpp b/src/Storages/StorageReplicatedMergeTree.cpp
index 64f800dc05a..e62ab2c9dff 100644
--- a/src/Storages/StorageReplicatedMergeTree.cpp
+++ b/src/Storages/StorageReplicatedMergeTree.cpp
@@ -1,6 +1,5 @@
 #include <Core/Defines.h>
 
-#include <Common/FieldVisitors.h>
 #include <Common/Macros.h>
 #include <Common/StringUtils/StringUtils.h>
 #include <Common/ThreadPool.h>
@@ -4332,7 +4331,7 @@ BlockOutputStreamPtr StorageReplicatedMergeTree::write(const ASTPtr & /*query*/,
         query_settings.max_partitions_per_insert_block,
         query_settings.insert_quorum_parallel,
         deduplicate,
-        local_context->getSettingsRef().optimize_on_insert);
+        query_settings.optimize_on_insert);
 }
 
 
diff --git a/src/Storages/StorageS3.cpp b/src/Storages/StorageS3.cpp
index 186f326d883..1138f5a0ac8 100644
--- a/src/Storages/StorageS3.cpp
+++ b/src/Storages/StorageS3.cpp
@@ -447,6 +447,7 @@ void StorageS3::updateClientAndAuthSettings(ContextPtr ctx, StorageS3::ClientAut
     }
 
     S3::PocoHTTPClientConfiguration client_configuration = S3::ClientFactory::instance().createClientConfiguration(
+        settings.region,
         ctx->getRemoteHostFilter(), ctx->getGlobalContext()->getSettingsRef().s3_max_redirects);
 
     client_configuration.endpointOverride = upd.uri.endpoint;
diff --git a/src/Storages/StorageS3Settings.cpp b/src/Storages/StorageS3Settings.cpp
index 8aafc12a688..ea0466690dc 100644
--- a/src/Storages/StorageS3Settings.cpp
+++ b/src/Storages/StorageS3Settings.cpp
@@ -30,6 +30,7 @@ void StorageS3Settings::loadFromConfig(const String & config_elem, const Poco::U
             auto endpoint = config.getString(config_elem + "." + key + ".endpoint");
             auto access_key_id = config.getString(config_elem + "." + key + ".access_key_id", "");
             auto secret_access_key = config.getString(config_elem + "." + key + ".secret_access_key", "");
+            auto region = config.getString(config_elem + "." + key + ".region", "");
             auto server_side_encryption_customer_key_base64 = config.getString(config_elem + "." + key + ".server_side_encryption_customer_key_base64", "");
             std::optional<bool> use_environment_credentials;
             if (config.has(config_elem + "." + key + ".use_environment_credentials"))
@@ -57,7 +58,14 @@ void StorageS3Settings::loadFromConfig(const String & config_elem, const Poco::U
                 }
             }
 
-            settings.emplace(endpoint, S3AuthSettings{std::move(access_key_id), std::move(secret_access_key), std::move(server_side_encryption_customer_key_base64), std::move(headers), use_environment_credentials, use_insecure_imds_request});
+            settings.emplace(endpoint, S3AuthSettings{
+                    std::move(access_key_id), std::move(secret_access_key),
+                    std::move(region),
+                    std::move(server_side_encryption_customer_key_base64),
+                    std::move(headers),
+                    use_environment_credentials,
+                    use_insecure_imds_request
+                });
         }
     }
 }
diff --git a/src/Storages/StorageS3Settings.h b/src/Storages/StorageS3Settings.h
index 66e776dbea2..63f758c816e 100644
--- a/src/Storages/StorageS3Settings.h
+++ b/src/Storages/StorageS3Settings.h
@@ -28,6 +28,7 @@ struct S3AuthSettings
 {
     String access_key_id;
     String secret_access_key;
+    String region;
     String server_side_encryption_customer_key_base64;
 
     HeaderCollection headers;
@@ -38,7 +39,9 @@ struct S3AuthSettings
     inline bool operator==(const S3AuthSettings & other) const
     {
         return access_key_id == other.access_key_id && secret_access_key == other.secret_access_key
-            && server_side_encryption_customer_key_base64 == other.server_side_encryption_customer_key_base64 && headers == other.headers
+            && region == other.region
+            && server_side_encryption_customer_key_base64 == other.server_side_encryption_customer_key_base64
+            && headers == other.headers
             && use_environment_credentials == other.use_environment_credentials
             && use_insecure_imds_request == other.use_insecure_imds_request;
     }
diff --git a/src/Storages/StorageURL.cpp b/src/Storages/StorageURL.cpp
index e6c2f52f925..824f1164851 100644
--- a/src/Storages/StorageURL.cpp
+++ b/src/Storages/StorageURL.cpp
@@ -79,7 +79,7 @@ namespace
             if (CurrentThread::isInitialized())
             {
                 const auto & thread_trace_context = CurrentThread::get().thread_trace_context;
-                if (thread_trace_context.trace_id)
+                if (thread_trace_context.trace_id != UUID())
                 {
                     header.emplace_back("traceparent",
                         thread_trace_context.composeTraceparentHeader());
diff --git a/src/Storages/System/StorageSystemDictionaries.cpp b/src/Storages/System/StorageSystemDictionaries.cpp
index 5f4d5df2036..eb313f93a25 100644
--- a/src/Storages/System/StorageSystemDictionaries.cpp
+++ b/src/Storages/System/StorageSystemDictionaries.cpp
@@ -37,6 +37,7 @@ NamesAndTypesList StorageSystemDictionaries::getNamesAndTypes()
         {"bytes_allocated", std::make_shared<DataTypeUInt64>()},
         {"query_count", std::make_shared<DataTypeUInt64>()},
         {"hit_rate", std::make_shared<DataTypeFloat64>()},
+        {"found_rate", std::make_shared<DataTypeFloat64>()},
         {"element_count", std::make_shared<DataTypeUInt64>()},
         {"load_factor", std::make_shared<DataTypeFloat64>()},
         {"source", std::make_shared<DataTypeString>()},
@@ -113,6 +114,7 @@ void StorageSystemDictionaries::fillData(MutableColumns & res_columns, ContextPt
             res_columns[i++]->insert(dict_ptr->getBytesAllocated());
             res_columns[i++]->insert(dict_ptr->getQueryCount());
             res_columns[i++]->insert(dict_ptr->getHitRate());
+            res_columns[i++]->insert(dict_ptr->getFoundRate());
             res_columns[i++]->insert(dict_ptr->getElementCount());
             res_columns[i++]->insert(dict_ptr->getLoadFactor());
             res_columns[i++]->insert(dict_ptr->getSource()->toString());
@@ -125,7 +127,7 @@ void StorageSystemDictionaries::fillData(MutableColumns & res_columns, ContextPt
         }
         else
         {
-            for (size_t j = 0; j != 8; ++j) // Number of empty fields if dict_ptr is null
+            for (size_t j = 0; j != 9; ++j) // Number of empty fields if dict_ptr is null
                 res_columns[i++]->insertDefault();
         }
 
diff --git a/src/Storages/System/StorageSystemNumbers.cpp b/src/Storages/System/StorageSystemNumbers.cpp
index f8a0e94bf98..545f2c8be9a 100644
--- a/src/Storages/System/StorageSystemNumbers.cpp
+++ b/src/Storages/System/StorageSystemNumbers.cpp
@@ -144,7 +144,7 @@ Pipe StorageSystemNumbers::read(
 
     Pipe pipe;
 
-    if (num_streams > 1 && !even_distribution && *limit)
+    if (num_streams > 1 && !even_distribution && limit)
     {
         auto state = std::make_shared<NumbersMultiThreadedState>(offset);
         UInt64 max_counter = offset + *limit;
diff --git a/src/Storages/System/StorageSystemQuotas.cpp b/src/Storages/System/StorageSystemQuotas.cpp
index 4bba082f66e..5e1ce220bec 100644
--- a/src/Storages/System/StorageSystemQuotas.cpp
+++ b/src/Storages/System/StorageSystemQuotas.cpp
@@ -60,7 +60,7 @@ void StorageSystemQuotas::fillData(MutableColumns & res_columns, ContextPtr cont
 
     size_t column_index = 0;
     auto & column_name = assert_cast<ColumnString &>(*res_columns[column_index++]);
-    auto & column_id = assert_cast<ColumnUInt128 &>(*res_columns[column_index++]).getData();
+    auto & column_id = assert_cast<ColumnUUID &>(*res_columns[column_index++]).getData();
     auto & column_storage = assert_cast<ColumnString &>(*res_columns[column_index++]);
     auto & column_key_types = assert_cast<ColumnInt8 &>(assert_cast<ColumnArray &>(*res_columns[column_index]).getData()).getData();
     auto & column_key_types_offsets = assert_cast<ColumnArray &>(*res_columns[column_index++]).getOffsets();
@@ -80,7 +80,7 @@ void StorageSystemQuotas::fillData(MutableColumns & res_columns, ContextPtr cont
                        const RolesOrUsersSet & apply_to)
     {
         column_name.insertData(name.data(), name.length());
-        column_id.push_back(id);
+        column_id.push_back(id.toUnderType());
         column_storage.insertData(storage_name.data(), storage_name.length());
 
         if (key_type != KeyType::NONE)
diff --git a/src/Storages/System/StorageSystemRoles.cpp b/src/Storages/System/StorageSystemRoles.cpp
index 65ae74887a7..42983670466 100644
--- a/src/Storages/System/StorageSystemRoles.cpp
+++ b/src/Storages/System/StorageSystemRoles.cpp
@@ -31,7 +31,7 @@ void StorageSystemRoles::fillData(MutableColumns & res_columns, ContextPtr conte
 
     size_t column_index = 0;
     auto & column_name = assert_cast<ColumnString &>(*res_columns[column_index++]);
-    auto & column_id = assert_cast<ColumnUInt128 &>(*res_columns[column_index++]).getData();
+    auto & column_id = assert_cast<ColumnUUID &>(*res_columns[column_index++]).getData();
     auto & column_storage = assert_cast<ColumnString &>(*res_columns[column_index++]);
 
     auto add_row = [&](const String & name,
@@ -39,7 +39,7 @@ void StorageSystemRoles::fillData(MutableColumns & res_columns, ContextPtr conte
                        const String & storage_name)
     {
         column_name.insertData(name.data(), name.length());
-        column_id.push_back(id);
+        column_id.push_back(id.toUnderType());
         column_storage.insertData(storage_name.data(), storage_name.length());
     };
 
diff --git a/src/Storages/System/StorageSystemRowPolicies.cpp b/src/Storages/System/StorageSystemRowPolicies.cpp
index f9d6b14957e..c7a403a4abe 100644
--- a/src/Storages/System/StorageSystemRowPolicies.cpp
+++ b/src/Storages/System/StorageSystemRowPolicies.cpp
@@ -63,7 +63,7 @@ void StorageSystemRowPolicies::fillData(MutableColumns & res_columns, ContextPtr
     auto & column_short_name = assert_cast<ColumnString &>(*res_columns[column_index++]);
     auto & column_database = assert_cast<ColumnString &>(*res_columns[column_index++]);
     auto & column_table = assert_cast<ColumnString &>(*res_columns[column_index++]);
-    auto & column_id = assert_cast<ColumnUInt128 &>(*res_columns[column_index++]).getData();
+    auto & column_id = assert_cast<ColumnUUID &>(*res_columns[column_index++]).getData();
     auto & column_storage = assert_cast<ColumnString &>(*res_columns[column_index++]);
 
     ColumnString * column_condition[MAX_CONDITION_TYPE];
@@ -93,7 +93,7 @@ void StorageSystemRowPolicies::fillData(MutableColumns & res_columns, ContextPtr
         column_short_name.insertData(name_parts.short_name.data(), name_parts.short_name.length());
         column_database.insertData(name_parts.database.data(), name_parts.database.length());
         column_table.insertData(name_parts.table_name.data(), name_parts.table_name.length());
-        column_id.push_back(id);
+        column_id.push_back(id.toUnderType());
         column_storage.insertData(storage_name.data(), storage_name.length());
 
         for (auto condition_type : ext::range(MAX_CONDITION_TYPE))
diff --git a/src/Storages/System/StorageSystemSettingsProfiles.cpp b/src/Storages/System/StorageSystemSettingsProfiles.cpp
index c726f54a324..87847fb80bc 100644
--- a/src/Storages/System/StorageSystemSettingsProfiles.cpp
+++ b/src/Storages/System/StorageSystemSettingsProfiles.cpp
@@ -38,7 +38,7 @@ void StorageSystemSettingsProfiles::fillData(MutableColumns & res_columns, Conte
 
     size_t column_index = 0;
     auto & column_name = assert_cast<ColumnString &>(*res_columns[column_index++]);
-    auto & column_id = assert_cast<ColumnUInt128 &>(*res_columns[column_index++]).getData();
+    auto & column_id = assert_cast<ColumnUUID &>(*res_columns[column_index++]).getData();
     auto & column_storage = assert_cast<ColumnString &>(*res_columns[column_index++]);
     auto & column_num_elements = assert_cast<ColumnUInt64 &>(*res_columns[column_index++]).getData();
     auto & column_apply_to_all = assert_cast<ColumnUInt8 &>(*res_columns[column_index++]).getData();
@@ -54,7 +54,7 @@ void StorageSystemSettingsProfiles::fillData(MutableColumns & res_columns, Conte
                        const RolesOrUsersSet & apply_to)
     {
         column_name.insertData(name.data(), name.length());
-        column_id.push_back(id);
+        column_id.push_back(id.toUnderType());
         column_storage.insertData(storage_name.data(), storage_name.length());
         column_num_elements.push_back(elements.size());
 
diff --git a/src/Storages/System/StorageSystemTables.cpp b/src/Storages/System/StorageSystemTables.cpp
index 9602339f381..9d00a9b71c4 100644
--- a/src/Storages/System/StorageSystemTables.cpp
+++ b/src/Storages/System/StorageSystemTables.cpp
@@ -389,14 +389,13 @@ protected:
                     src_index += 2;
 
                 StorageMetadataPtr metadata_snapshot;
-                if (table != nullptr)
+                if (table)
                     metadata_snapshot = table->getInMemoryMetadataPtr();
 
                 ASTPtr expression_ptr;
                 if (columns_mask[src_index++])
                 {
-                    assert(metadata_snapshot != nullptr);
-                    if ((expression_ptr = metadata_snapshot->getPartitionKeyAST()))
+                    if (metadata_snapshot && (expression_ptr = metadata_snapshot->getPartitionKeyAST()))
                         res_columns[res_index++]->insert(queryToString(expression_ptr));
                     else
                         res_columns[res_index++]->insertDefault();
@@ -404,8 +403,7 @@ protected:
 
                 if (columns_mask[src_index++])
                 {
-                    assert(metadata_snapshot != nullptr);
-                    if ((expression_ptr = metadata_snapshot->getSortingKey().expression_list_ast))
+                    if (metadata_snapshot && (expression_ptr = metadata_snapshot->getSortingKey().expression_list_ast))
                         res_columns[res_index++]->insert(queryToString(expression_ptr));
                     else
                         res_columns[res_index++]->insertDefault();
@@ -413,8 +411,7 @@ protected:
 
                 if (columns_mask[src_index++])
                 {
-                    assert(metadata_snapshot != nullptr);
-                    if ((expression_ptr = metadata_snapshot->getPrimaryKey().expression_list_ast))
+                    if (metadata_snapshot && (expression_ptr = metadata_snapshot->getPrimaryKey().expression_list_ast))
                         res_columns[res_index++]->insert(queryToString(expression_ptr));
                     else
                         res_columns[res_index++]->insertDefault();
@@ -422,8 +419,7 @@ protected:
 
                 if (columns_mask[src_index++])
                 {
-                    assert(metadata_snapshot != nullptr);
-                    if ((expression_ptr = metadata_snapshot->getSamplingKeyAST()))
+                    if (metadata_snapshot && (expression_ptr = metadata_snapshot->getSamplingKeyAST()))
                         res_columns[res_index++]->insert(queryToString(expression_ptr));
                     else
                         res_columns[res_index++]->insertDefault();
@@ -431,8 +427,7 @@ protected:
 
                 if (columns_mask[src_index++])
                 {
-                    assert(table != nullptr);
-                    auto policy = table->getStoragePolicy();
+                    auto policy = table ? table->getStoragePolicy() : nullptr;
                     if (policy)
                         res_columns[res_index++]->insert(policy->getName());
                     else
@@ -441,8 +436,7 @@ protected:
 
                 if (columns_mask[src_index++])
                 {
-                    assert(table != nullptr);
-                    auto total_rows = table->totalRows(context->getSettingsRef());
+                    auto total_rows = table ? table->totalRows(context->getSettingsRef()) : std::nullopt;
                     if (total_rows)
                         res_columns[res_index++]->insert(*total_rows);
                     else
@@ -451,8 +445,7 @@ protected:
 
                 if (columns_mask[src_index++])
                 {
-                    assert(table != nullptr);
-                    auto total_bytes = table->totalBytes(context->getSettingsRef());
+                    auto total_bytes = table ? table->totalBytes(context->getSettingsRef()) : std::nullopt;
                     if (total_bytes)
                         res_columns[res_index++]->insert(*total_bytes);
                     else
@@ -461,8 +454,7 @@ protected:
 
                 if (columns_mask[src_index++])
                 {
-                    assert(table != nullptr);
-                    auto lifetime_rows = table->lifetimeRows();
+                    auto lifetime_rows = table ? table->lifetimeRows() : std::nullopt;
                     if (lifetime_rows)
                         res_columns[res_index++]->insert(*lifetime_rows);
                     else
@@ -471,8 +463,7 @@ protected:
 
                 if (columns_mask[src_index++])
                 {
-                    assert(table != nullptr);
-                    auto lifetime_bytes = table->lifetimeBytes();
+                    auto lifetime_bytes = table ? table->lifetimeBytes() : std::nullopt;
                     if (lifetime_bytes)
                         res_columns[res_index++]->insert(*lifetime_bytes);
                     else
diff --git a/src/Storages/System/StorageSystemUsers.cpp b/src/Storages/System/StorageSystemUsers.cpp
index e60f1372df9..74ac48c145c 100644
--- a/src/Storages/System/StorageSystemUsers.cpp
+++ b/src/Storages/System/StorageSystemUsers.cpp
@@ -63,7 +63,7 @@ void StorageSystemUsers::fillData(MutableColumns & res_columns, ContextPtr conte
 
     size_t column_index = 0;
     auto & column_name = assert_cast<ColumnString &>(*res_columns[column_index++]);
-    auto & column_id = assert_cast<ColumnUInt128 &>(*res_columns[column_index++]).getData();
+    auto & column_id = assert_cast<ColumnUUID &>(*res_columns[column_index++]).getData();
     auto & column_storage = assert_cast<ColumnString &>(*res_columns[column_index++]);
     auto & column_auth_type = assert_cast<ColumnInt8 &>(*res_columns[column_index++]).getData();
     auto & column_auth_params = assert_cast<ColumnString &>(*res_columns[column_index++]);
@@ -95,7 +95,7 @@ void StorageSystemUsers::fillData(MutableColumns & res_columns, ContextPtr conte
                        const RolesOrUsersSet & grantees)
     {
         column_name.insertData(name.data(), name.length());
-        column_id.push_back(id);
+        column_id.push_back(id.toUnderType());
         column_storage.insertData(storage_name.data(), storage_name.length());
         column_auth_type.push_back(static_cast<Int8>(authentication.getType()));
 
diff --git a/tests/integration/runner b/tests/integration/runner
index e89e10fbc21..ee116c29aa5 100755
--- a/tests/integration/runner
+++ b/tests/integration/runner
@@ -64,7 +64,7 @@ def check_args_and_update_paths(args):
         args.src_dir = os.path.abspath(os.path.join(CLICKHOUSE_ROOT, SRC_DIR_IN_REPO))
         logging.info("src dir is not set. Will use {}".format(args.src_dir))
 
-    logging.info("base_configs_dir: {},  binary: {}, cases_dir: {} ".format(args.base_configs_dir, args.binary, args.cases_dir))
+    logging.info("base_configs_dir: {}, binary: {}, cases_dir: {} ".format(args.base_configs_dir, args.binary, args.cases_dir))
 
     for path in [args.binary, args.odbc_bridge_binary, args.library_bridge_binary, args.base_configs_dir, args.cases_dir, CLICKHOUSE_ROOT]:
         if not os.path.exists(path):
diff --git a/tests/integration/test_distributed_ddl/test.py b/tests/integration/test_distributed_ddl/test.py
index 9af27738eed..68d8a2dab53 100755
--- a/tests/integration/test_distributed_ddl/test.py
+++ b/tests/integration/test_distributed_ddl/test.py
@@ -341,8 +341,8 @@ def test_replicated_without_arguments(test_cluster):
                                  "CREATE TABLE test_atomic.rmt ON CLUSTER cluster (n UInt64, s String) ENGINE=ReplicatedMergeTree('/clickhouse/tables/{uuid}/{shard}', '{replica}') ORDER BY n")
     test_cluster.ddl_check_query(instance,
                                  "EXCHANGE TABLES test_atomic.rmt AND test_atomic.rmt_renamed ON CLUSTER cluster")
-    assert instance.query("SELECT countDistinct(uuid) from clusterAllReplicas('cluster', 'system', 'databases') WHERE uuid != 0 AND name='test_atomic'") == "1\n"
-    assert instance.query("SELECT countDistinct(uuid) from clusterAllReplicas('cluster', 'system', 'tables') WHERE uuid != 0 AND name='rmt'") == "1\n"
+    assert instance.query("SELECT countDistinct(uuid) from clusterAllReplicas('cluster', 'system', 'databases') WHERE uuid != '00000000-0000-0000-0000-000000000000' AND name='test_atomic'") == "1\n"
+    assert instance.query("SELECT countDistinct(uuid) from clusterAllReplicas('cluster', 'system', 'tables') WHERE uuid != '00000000-0000-0000-0000-000000000000' AND name='rmt'") == "1\n"
     test_cluster.ddl_check_query(instance,
                                  "CREATE TABLE test_atomic.rrmt ON CLUSTER cluster (n UInt64, m UInt64) ENGINE=ReplicatedReplacingMergeTree(m) ORDER BY n")
     test_cluster.ddl_check_query(instance,
diff --git a/tests/integration/test_distributed_ddl_on_cross_replication/test.py b/tests/integration/test_distributed_ddl_on_cross_replication/test.py
index 85800b2e5e6..833a3fb1f04 100644
--- a/tests/integration/test_distributed_ddl_on_cross_replication/test.py
+++ b/tests/integration/test_distributed_ddl_on_cross_replication/test.py
@@ -20,23 +20,23 @@ def started_cluster():
         node1.query('''
             CREATE DATABASE replica_1 ON CLUSTER cross_3shards_2replicas;
             CREATE DATABASE replica_2 ON CLUSTER cross_3shards_2replicas;
-            
-            CREATE TABLE replica_1.replicated_local  
+
+            CREATE TABLE replica_1.replicated_local
             ON CLUSTER cross_3shards_2replicas (part_key Date, id UInt32, shard_id UInt32)
-            ENGINE = ReplicatedMergeTree('/clickhouse/tables/{shard}/replicated', '{replica}') 
+            ENGINE = ReplicatedMergeTree('/clickhouse/tables/{shard}/replicated', '{replica}')
             partition by part_key order by id;
-            
-            CREATE TABLE replica_1.replicated  
-            ON CLUSTER cross_3shards_2replicas as replica_1.replicated_local  
+
+            CREATE TABLE replica_1.replicated
+            ON CLUSTER cross_3shards_2replicas as replica_1.replicated_local
             ENGINE = Distributed(cross_3shards_2replicas, '', replicated_local, shard_id);
-                
-            CREATE TABLE replica_2.replicated_local 
+
+            CREATE TABLE replica_2.replicated_local
             ON CLUSTER cross_3shards_2replicas (part_key Date, id UInt32, shard_id UInt32)
-            ENGINE = ReplicatedMergeTree('/clickhouse/tables/{shard_bk}/replicated', '{replica_bk}') 
+            ENGINE = ReplicatedMergeTree('/clickhouse/tables/{shard_bk}/replicated', '{replica_bk}')
             partition by part_key order by id;
-            
-            CREATE TABLE replica_2.replicated  
-            ON CLUSTER cross_3shards_2replicas as replica_2.replicated_local  
+
+            CREATE TABLE replica_2.replicated
+            ON CLUSTER cross_3shards_2replicas as replica_2.replicated_local
             ENGINE = Distributed(cross_3shards_2replicas, '', replicated_local, shard_id);
             ''')
 
@@ -98,8 +98,8 @@ def test_atomic_database(started_cluster):
     node1.query("CREATE TABLE replica_1.rmt ON CLUSTER cross_3shards_2replicas (n UInt64, s String) ENGINE=ReplicatedMergeTree('/tables/{shard}/rmt/', '{replica}') ORDER BY n")
     node1.query("CREATE TABLE replica_2.rmt ON CLUSTER cross_3shards_2replicas (n UInt64, s String) ENGINE=ReplicatedMergeTree('/tables/{shard_bk}/rmt/', '{replica_bk}') ORDER BY n")
 
-    assert node1.query("SELECT countDistinct(uuid) from remote('node1,node2,node3', 'system', 'databases') WHERE uuid != 0 AND name='replica_1'") == "1\n"
-    assert node1.query("SELECT countDistinct(uuid) from remote('node1,node2,node3', 'system', 'tables') WHERE uuid != 0 AND name='rmt'") == "2\n"
+    assert node1.query("SELECT countDistinct(uuid) from remote('node1,node2,node3', 'system', 'databases') WHERE uuid != '00000000-0000-0000-0000-000000000000' AND name='replica_1'") == "1\n"
+    assert node1.query("SELECT countDistinct(uuid) from remote('node1,node2,node3', 'system', 'tables') WHERE uuid != '00000000-0000-0000-0000-000000000000' AND name='rmt'") == "2\n"
 
     node1.query("INSERT INTO replica_1.rmt VALUES (1, 'test')")
     node2.query("SYSTEM SYNC REPLICA replica_2.rmt", timeout=5)
diff --git a/tests/integration/test_insert_into_distributed/test.py b/tests/integration/test_insert_into_distributed/test.py
index d54336a3027..47200df4a85 100644
--- a/tests/integration/test_insert_into_distributed/test.py
+++ b/tests/integration/test_insert_into_distributed/test.py
@@ -198,28 +198,34 @@ def test_inserts_single_replica_local_internal_replication(started_cluster):
 
 
 def test_inserts_single_replica_internal_replication(started_cluster):
-    node1.query(
-        "INSERT INTO distributed_one_replica_internal_replication VALUES ('2000-01-01', 1)",
-        settings={
-            "insert_distributed_sync": "1",
-            "prefer_localhost_replica": "0",
-            # to make the test more deterministic
-            "load_balancing": "first_or_random",
-        },
-    )
-    assert node2.query("SELECT count(*) FROM single_replicated").strip() == '1'
-
-
-def test_inserts_single_replica_no_internal_replication(started_cluster):
-    with pytest.raises(QueryRuntimeException, match="Table default.single_replicated doesn't exist"):
+    try:
         node1.query(
-            "INSERT INTO distributed_one_replica_no_internal_replication VALUES ('2000-01-01', 1)",
+            "INSERT INTO distributed_one_replica_internal_replication VALUES ('2000-01-01', 1)",
             settings={
                 "insert_distributed_sync": "1",
                 "prefer_localhost_replica": "0",
+                # to make the test more deterministic
+                "load_balancing": "first_or_random",
             },
         )
-    assert node2.query("SELECT count(*) FROM single_replicated").strip() == '1'
+        assert node2.query("SELECT count(*) FROM single_replicated").strip() == '1'
+    finally:
+        node2.query("TRUNCATE TABLE single_replicated")
+
+
+def test_inserts_single_replica_no_internal_replication(started_cluster):
+    try:
+        with pytest.raises(QueryRuntimeException, match="Table default.single_replicated doesn't exist"):
+            node1.query(
+                "INSERT INTO distributed_one_replica_no_internal_replication VALUES ('2000-01-01', 1)",
+                settings={
+                    "insert_distributed_sync": "1",
+                    "prefer_localhost_replica": "0",
+                },
+            )
+        assert node2.query("SELECT count(*) FROM single_replicated").strip() == '1'
+    finally:
+        node2.query("TRUNCATE TABLE single_replicated")
 
 
 def test_prefer_localhost_replica(started_cluster):
diff --git a/tests/integration/test_storage_s3/s3_mocks/echo.py b/tests/integration/test_storage_s3/s3_mocks/echo.py
new file mode 100644
index 00000000000..ced84e54d62
--- /dev/null
+++ b/tests/integration/test_storage_s3/s3_mocks/echo.py
@@ -0,0 +1,33 @@
+import http.server
+import sys
+
+
+class RequestHandler(http.server.BaseHTTPRequestHandler):
+    def do_HEAD(self):
+        if self.path.startswith("/get-my-path/"):
+            self.send_response(200)
+            self.send_header("Content-Type", "text/plain")
+            self.end_headers()
+
+        elif self.path == "/":
+            self.send_response(200)
+            self.send_header("Content-Type", "text/plain")
+            self.end_headers()
+
+        else:
+            self.send_response(404)
+            self.send_header("Content-Type", "text/plain")
+            self.end_headers()
+
+
+    def do_GET(self):
+        self.do_HEAD()
+        if self.path.startswith("/get-my-path/"):
+            self.wfile.write(b'/' + self.path.split('/', maxsplit=2)[2].encode())
+
+        elif self.path == "/":
+            self.wfile.write(b"OK")
+
+
+httpd = http.server.HTTPServer(("0.0.0.0", int(sys.argv[1])), RequestHandler)
+httpd.serve_forever()
diff --git a/tests/integration/test_storage_s3/test.py b/tests/integration/test_storage_s3/test.py
index c239dc68810..b1427c09981 100644
--- a/tests/integration/test_storage_s3/test.py
+++ b/tests/integration/test_storage_s3/test.py
@@ -146,6 +146,47 @@ def test_put(cluster, maybe_auth, positive, compression):
         assert values_csv == get_s3_file_content(cluster, bucket, filename)
 
 
+@pytest.mark.parametrize("special", [
+    "space",
+    "plus"
+])
+def test_get_file_with_special(cluster, special):
+    symbol = {"space": " ", "plus": "+"}[special]
+    urlsafe_symbol = {"space": "%20", "plus": "%2B"}[special]
+    auth = "'minio','minio123',"
+    bucket = cluster.minio_restricted_bucket
+    instance = cluster.instances["dummy"]
+    table_format = "column1 UInt32, column2 UInt32, column3 UInt32"
+    values = [[12549, 2463, 19893], [64021, 38652, 66703], [81611, 39650, 83516], [11079, 59507, 61546], [51764, 69952, 6876], [41165, 90293, 29095], [40167, 78432, 48309], [81629, 81327, 11855], [55852, 21643, 98507], [6738, 54643, 41155]]
+    values_csv = ('\n'.join((','.join(map(str, row)) for row in values)) + '\n').encode()
+    filename = f"get_file_with_{special}_{symbol}two.csv"
+    put_s3_file_content(cluster, bucket, filename, values_csv)
+
+    get_query = f"SELECT * FROM s3('http://{cluster.minio_host}:{cluster.minio_port}/{bucket}/get_file_with_{special}_{urlsafe_symbol}two.csv', {auth}'CSV', '{table_format}') FORMAT TSV"
+    assert [list(map(int, l.split())) for l in run_query(instance, get_query).splitlines()] == values
+
+    get_query = f"SELECT * FROM s3('http://{cluster.minio_host}:{cluster.minio_port}/{bucket}/get_file_with_{special}*.csv', {auth}'CSV', '{table_format}') FORMAT TSV"
+    assert [list(map(int, l.split())) for l in run_query(instance, get_query).splitlines()] == values
+
+    get_query = f"SELECT * FROM s3('http://{cluster.minio_host}:{cluster.minio_port}/{bucket}/get_file_with_{special}_{urlsafe_symbol}*.csv', {auth}'CSV', '{table_format}') FORMAT TSV"
+    assert [list(map(int, l.split())) for l in run_query(instance, get_query).splitlines()] == values
+
+
+@pytest.mark.parametrize("special", [
+    "space",
+    "plus",
+    "plus2"
+])
+def test_get_path_with_special(cluster, special):
+    symbol = {"space": "%20", "plus": "%2B", "plus2": "%2B"}[special]
+    safe_symbol = {"space": "%20", "plus": "+", "plus2": "%2B"}[special]
+    auth = "'minio','minio123',"
+    table_format = "column1 String"
+    instance = cluster.instances["dummy"]
+    get_query = f"SELECT * FROM s3('http://resolver:8082/get-my-path/{safe_symbol}.csv', {auth}'CSV', '{table_format}') FORMAT TSV"
+    assert run_query(instance, get_query).splitlines() == [f"/{symbol}.csv"]
+
+
 # Test put no data to S3.
 @pytest.mark.parametrize("auth", [
     "'minio','minio123',"
@@ -389,6 +430,7 @@ def run_s3_mocks(cluster):
     mocks = (
         ("mock_s3.py", "resolver", "8080"),
         ("unstable_server.py", "resolver", "8081"),
+        ("echo.py", "resolver", "8082"),
     )
     for mock_filename, container, port in mocks:
         container_id = cluster.get_container_id(container)
diff --git a/tests/performance/single_fixed_string_groupby.xml b/tests/performance/single_fixed_string_groupby.xml
index 6bf5821707f..8e166a124ff 100644
--- a/tests/performance/single_fixed_string_groupby.xml
+++ b/tests/performance/single_fixed_string_groupby.xml
@@ -10,8 +10,8 @@
         INSERT INTO perf_lc_fixed_str_groupby SELECT ('number key ' || toString(number % 400)) AS a, ('number key ' || toString(number % 20)) AS b FROM numbers(30000000)
     </fill_query>
 
-    <query short="1">SELECT count() FROM perf_lc_fixed_str_groupby GROUP BY a</query>
-    <query short="1">SELECT count() FROM perf_lc_fixed_str_groupby GROUP BY b</query>
+    <query short="1">SELECT count() FROM perf_lc_fixed_str_groupby GROUP BY a FORMAT Null</query>
+    <query short="1">SELECT count() FROM perf_lc_fixed_str_groupby GROUP BY b FORMAT Null</query>
 
     <drop_query>DROP TABLE IF EXISTS perf_lc_fixed_str_groupby</drop_query>
 </test>
diff --git a/tests/queries/0_stateless/00700_decimal_arithm.reference b/tests/queries/0_stateless/00700_decimal_arithm.reference
index d0040ff5ae2..9de0d4cbf9a 100644
--- a/tests/queries/0_stateless/00700_decimal_arithm.reference
+++ b/tests/queries/0_stateless/00700_decimal_arithm.reference
@@ -3,11 +3,13 @@
 84	0	1764	1	1	1
 84.840	0.000	1799.456400	1.000	1.000	1.000
 84.840000000	0.000000000
+84.840000000000000000	0.000000000000000000	98.044565395307682683126962841158942720	1.000000000000000000	1.000000000000000000	1.000000000000000000
 84.840000000000000000	0.000000000000000000
 84.84	0.00	1799.4564	1.00	1.00	1.00
 63	21	-42	882	-882	2	0	2	0
 63	21	-42	882	-882	2	0	2	0
 63	21	-42	882	-882	2	0	2	0
+1.00305798474369219219752355409390731264	-0.16305798474369219219752355409390731264	1.49059173023461586584365185794205286400	-1.38847100762815390390123822295304634368	1.38847100762815390390123822295304634368	0.02000000000000000000000000000000000000	0.00500000000000000000000000000000000000
 63.420	21.420	-41.580	890.820	-890.820	2.020	0.505	2.020	0.505
 63.420000000	21.420000000	-41.580000000	890.820000000	-890.820000000	2.020000000	0.505000000	2.020000000	0.505000000
 63.420000000000000000	21.420000000000000000	-41.580000000000000000	890.820000000000000000	-890.820000000000000000	2.020000000000000000	0.505000000000000000	2.020000000000000000	0.505000000000000000
@@ -15,6 +17,7 @@
 63	-21	42	882	-882	0	2	0	2
 63	-21	42	882	-882	0	2	0	2
 63	-21	42	882	-882	0	2	0	2
+1.00305798474369219219752355409390731264	0.16305798474369219219752355409390731264	-1.49059173023461586584365185794205286400	-1.38847100762815390390123822295304634368	1.38847100762815390390123822295304634368	-0.00000000000000000000000000000000000001	0.00000000000000000000000000000000000001
 63.420	-21.420	41.580	890.820	-890.820	0.495	1.980	0.495	1.980
 63.420000000	-21.420000000	41.580000000	890.820000000	-890.820000000
 63.420000000000000000	-21.420000000000000000	41.580000000000000000	890.820000000000000000	-890.820000000000000000	0.495049504950495049	1.980198019801980198	0.495049504950495049	1.980198019801980198
diff --git a/tests/queries/0_stateless/00700_decimal_arithm.sql b/tests/queries/0_stateless/00700_decimal_arithm.sql
index 3fa2aade743..c305a850e5b 100644
--- a/tests/queries/0_stateless/00700_decimal_arithm.sql
+++ b/tests/queries/0_stateless/00700_decimal_arithm.sql
@@ -31,7 +31,7 @@ SELECT f + f, f - f, f * f, f / f, intDiv(f, f), intDivOrZero(f, f) FROM decimal
 SELECT g + g, g - g, g * g, g / g, intDiv(g, g), intDivOrZero(g, g) FROM decimal WHERE g > 0;
 SELECT h + h, h - h, h * h, h / h, intDiv(h, h), intDivOrZero(h, h) FROM decimal WHERE h > 0; -- { serverError 407 }
 SELECT h + h, h - h FROM decimal WHERE h > 0;
-SELECT i + i, i - i, i * i, i / i, intDiv(i, i), intDivOrZero(i, i) FROM decimal WHERE i > 0; -- { serverError 407 }
+SELECT i + i, i - i, i * i, i / i, intDiv(i, i), intDivOrZero(i, i) FROM decimal WHERE i > 0;
 SELECT i + i, i - i FROM decimal WHERE i > 0;
 SELECT j + j, j - j, j * j, j / j, intDiv(j, j), intDivOrZero(j, j) FROM decimal WHERE j > 0;
 
@@ -39,7 +39,7 @@ SELECT a + 21, a - 21, a - 84, a * 21, a * -21, a / 21, a / 84, intDiv(a, 21), i
 SELECT b + 21, b - 21, b - 84, b * 21, b * -21, b / 21, b / 84, intDiv(b, 21), intDivOrZero(b, 84) FROM decimal WHERE b = 42;
 SELECT c + 21, c - 21, c - 84, c * 21, c * -21, c / 21, c / 84, intDiv(c, 21), intDivOrZero(c, 84) FROM decimal WHERE c = 42;
 SELECT e + 21, e - 21, e - 84, e * 21, e * -21, e / 21, e / 84 FROM decimal WHERE e > 0; -- { serverError 407 }
-SELECT f + 21, f - 21, f - 84, f * 21, f * -21, f / 21, f / 84 FROM decimal WHERE f > 0; -- { serverError 407 }
+SELECT f + 21, f - 21, f - 84, f * 21, f * -21, f / 21, f / 84 FROM decimal WHERE f > 0;
 SELECT g + 21, g - 21, g - 84, g * 21, g * -21, g / 21, g / 84, intDiv(g, 21), intDivOrZero(g, 84) FROM decimal WHERE g > 0;
 SELECT h + 21, h - 21, h - 84, h * 21, h * -21, h / 21, h / 84, intDiv(h, 21), intDivOrZero(h, 84) FROM decimal WHERE h > 0;
 SELECT i + 21, i - 21, i - 84, i * 21, i * -21, i / 21, i / 84, intDiv(i, 21), intDivOrZero(i, 84) FROM decimal WHERE i > 0;
@@ -49,7 +49,7 @@ SELECT 21 + a, 21 - a, 84 - a, 21 * a, -21 * a, 21 / a, 84 / a, intDiv(21, a), i
 SELECT 21 + b, 21 - b, 84 - b, 21 * b, -21 * b, 21 / b, 84 / b, intDiv(21, b), intDivOrZero(84, b) FROM decimal WHERE b = 42;
 SELECT 21 + c, 21 - c, 84 - c, 21 * c, -21 * c, 21 / c, 84 / c, intDiv(21, c), intDivOrZero(84, c) FROM decimal WHERE c = 42;
 SELECT 21 + e, 21 - e, 84 - e, 21 * e, -21 * e, 21 / e, 84 / e FROM decimal WHERE e > 0; -- { serverError 407 }
-SELECT 21 + f, 21 - f, 84 - f, 21 * f, -21 * f, 21 / f, 84 / f FROM decimal WHERE f > 0; -- { serverError 407 }
+SELECT 21 + f, 21 - f, 84 - f, 21 * f, -21 * f, 21 / f, 84 / f FROM decimal WHERE f > 0;
 SELECT 21 + g, 21 - g, 84 - g, 21 * g, -21 * g, 21 / g, 84 / g, intDiv(21, g), intDivOrZero(84, g) FROM decimal WHERE g > 0;
 SELECT 21 + h, 21 - h, 84 - h, 21 * h, -21 * h, 21 / h, 84 / h FROM decimal WHERE h > 0; -- { serverError 407 }
 SELECT 21 + h, 21 - h, 84 - h, 21 * h, -21 * h FROM decimal WHERE h > 0;
diff --git a/tests/queries/0_stateless/00700_decimal_casts.reference b/tests/queries/0_stateless/00700_decimal_casts.reference
index 8832c2109f9..99d8b949398 100644
--- a/tests/queries/0_stateless/00700_decimal_casts.reference
+++ b/tests/queries/0_stateless/00700_decimal_casts.reference
@@ -157,39 +157,3 @@
 0.12345678
 0.12345678912345678
 0.1234567890123456789012345678901234567
-1234567890.0000000000000000000000000000	1234567890.00000000000000000000000000000	1234567890.00000000000000000000000000000
-1234567890.00000000	1234567890.000000000	1234567890.000000000
-12345678.0	12345678.00	12345678.00
-9223372036854775807.000000	9223372036854775807	-9223372036854775807
-9223372036854775800	9223372036854775800	-9223372036854775800
-92233720368547758.00	92233720368547758	-92233720368547758
-2147483647.0000000000	2147483647	-2147483647
-2147483647.00	2147483647	-2147483647
-92233720368547757.99	92233720368547757	-92233720368547757
-2147483640.99	2147483640	-2147483640
--0.90000000	0
--0.90000000	0
--0.90000000	0
--0.8000	0
--0.8000	0
--0.8000	0
--0.70	0
--0.70	0
--0.70	0
--0.600000	0
--0.600000	0
--0.600000	0
-18446744073709551615	18446744073709551615
-18446744073709551615.00000000	18446744073709551615
-4294967295	4294967295
-4294967295.0000000000	4294967295
-4294967295	4294967295
-4294967295.0000	4294967295
-65535	65535
-65535.0000000000	65535
-65535	65535
-65535.0000	65535
-2147483647	2147483647
--2147483647	-2147483647
-2147483647	2147483647
-9223372036854775807	9223372036854775807
diff --git a/tests/queries/0_stateless/00700_decimal_casts.sql b/tests/queries/0_stateless/00700_decimal_casts.sql
index 602ee02bc07..8c752565fee 100644
--- a/tests/queries/0_stateless/00700_decimal_casts.sql
+++ b/tests/queries/0_stateless/00700_decimal_casts.sql
@@ -146,123 +146,3 @@ SELECT CAST('0.12345678901234567890123456789012345678', 'Decimal(38,38)');
 SELECT CAST('0.123456789', 'Decimal(9,8)');
 SELECT CAST('0.123456789123456789', 'Decimal(18,17)');
 SELECT CAST('0.12345678901234567890123456789012345678', 'Decimal(38,37)');
-
-SELECT toDecimal128('1234567890', 28) AS x, toDecimal128(x, 29), toDecimal128(toDecimal128('1234567890', 28), 29);
-SELECT toDecimal128(toDecimal128('1234567890', 28), 30); -- { serverError 407 }
-
-SELECT toDecimal64('1234567890', 8) AS x, toDecimal64(x, 9), toDecimal64(toDecimal64('1234567890', 8), 9);
-SELECT toDecimal64(toDecimal64('1234567890', 8), 10); -- { serverError 407 }
-
-SELECT toDecimal32('12345678', 1) AS x, toDecimal32(x, 2), toDecimal32(toDecimal32('12345678', 1), 2);
-SELECT toDecimal32(toDecimal32('12345678', 1), 3); -- { serverError 407 }
-
-SELECT toDecimal64(toDecimal64('92233720368547758.1', 1), 2); -- { serverError 407 }
-SELECT toDecimal64(toDecimal64('-92233720368547758.1', 1), 2); -- { serverError 407 }
-
-SELECT toDecimal128('9223372036854775807', 6) AS x, toInt64(x), toInt64(-x);
-SELECT toDecimal128('9223372036854775809', 6) AS x, toInt64(x); -- { serverError 407 }
-SELECT toDecimal128('9223372036854775809', 6) AS x, toInt64(-x); -- { serverError 407 }
-SELECT toDecimal64('922337203685477580', 0) * 10 AS x, toInt64(x), toInt64(-x);
-SELECT toDecimal64(toDecimal64('92233720368547758.0', 1), 2) AS x, toInt64(x), toInt64(-x);
-
-SELECT toDecimal128('2147483647', 10) AS x, toInt32(x), toInt32(-x);
-SELECT toDecimal128('2147483649', 10) AS x, toInt32(x), toInt32(-x); -- { serverError 407 }
-SELECT toDecimal64('2147483647', 2) AS x, toInt32(x), toInt32(-x);
-SELECT toDecimal64('2147483649', 2) AS x, toInt32(x), toInt32(-x); -- { serverError 407 }
-
-SELECT toDecimal128('92233720368547757.99', 2) AS x, toInt64(x), toInt64(-x);
-SELECT toDecimal64('2147483640.99', 2) AS x, toInt32(x), toInt32(-x);
-
-SELECT toDecimal128('-0.9', 8) AS x, toUInt64(x);
-SELECT toDecimal64('-0.9', 8) AS x, toUInt64(x);
-SELECT toDecimal32('-0.9', 8) AS x, toUInt64(x);
-
-SELECT toDecimal128('-0.8', 4) AS x, toUInt32(x);
-SELECT toDecimal64('-0.8', 4) AS x, toUInt32(x);
-SELECT toDecimal32('-0.8', 4) AS x, toUInt32(x);
-
-SELECT toDecimal128('-0.7', 2) AS x, toUInt16(x);
-SELECT toDecimal64('-0.7', 2) AS x, toUInt16(x);
-SELECT toDecimal32('-0.7', 2) AS x, toUInt16(x);
-
-SELECT toDecimal128('-0.6', 6) AS x, toUInt8(x);
-SELECT toDecimal64('-0.6', 6) AS x, toUInt8(x);
-SELECT toDecimal32('-0.6', 6) AS x, toUInt8(x);
-
-SELECT toDecimal128('-1', 7) AS x, toUInt64(x); -- { serverError 407 }
-SELECT toDecimal128('-1', 7) AS x, toUInt32(x); -- { serverError 407 }
-SELECT toDecimal128('-1', 7) AS x, toUInt16(x); -- { serverError 407 }
-SELECT toDecimal128('-1', 7) AS x, toUInt8(x); -- { serverError 407 }
-
-SELECT toDecimal64('-1', 5) AS x, toUInt64(x); -- { serverError 407 }
-SELECT toDecimal64('-1', 5) AS x, toUInt32(x); -- { serverError 407 }
-SELECT toDecimal64('-1', 5) AS x, toUInt16(x); -- { serverError 407 }
-SELECT toDecimal64('-1', 5) AS x, toUInt8(x); -- { serverError 407 }
-
-SELECT toDecimal32('-1', 3) AS x, toUInt64(x); -- { serverError 407 }
-SELECT toDecimal32('-1', 3) AS x, toUInt32(x); -- { serverError 407 }
-SELECT toDecimal32('-1', 3) AS x, toUInt16(x); -- { serverError 407 }
-SELECT toDecimal32('-1', 3) AS x, toUInt8(x); -- { serverError 407 }
-
-SELECT toDecimal128('18446744073709551615', 0) AS x, toUInt64(x);
-SELECT toDecimal128('18446744073709551616', 0) AS x, toUInt64(x); -- { serverError 407 }
-SELECT toDecimal128('18446744073709551615', 8) AS x, toUInt64(x);
-SELECT toDecimal128('18446744073709551616', 8) AS x, toUInt64(x); -- { serverError 407 }
-
-SELECT toDecimal128('4294967295', 0) AS x, toUInt32(x);
-SELECT toDecimal128('4294967296', 0) AS x, toUInt32(x); -- { serverError 407 }
-SELECT toDecimal128('4294967295', 10) AS x, toUInt32(x);
-SELECT toDecimal128('4294967296', 10) AS x, toUInt32(x); -- { serverError 407 }
-SELECT toDecimal64('4294967295', 0) AS x, toUInt32(x);
-SELECT toDecimal64('4294967296', 0) AS x, toUInt32(x); -- { serverError 407 }
-SELECT toDecimal64('4294967295', 4) AS x, toUInt32(x);
-SELECT toDecimal64('4294967296', 4) AS x, toUInt32(x); -- { serverError 407 }
-
-SELECT toDecimal128('65535', 0) AS x, toUInt16(x);
-SELECT toDecimal128('65536', 0) AS x, toUInt16(x); -- { serverError 407 }
-SELECT toDecimal128('65535', 10) AS x, toUInt16(x);
-SELECT toDecimal128('65536', 10) AS x, toUInt16(x); -- { serverError 407 }
-SELECT toDecimal64('65535', 0) AS x, toUInt16(x);
-SELECT toDecimal64('65536', 0) AS x, toUInt16(x); -- { serverError 407 }
-SELECT toDecimal64('65535', 4) AS x, toUInt16(x);
-SELECT toDecimal64('65536', 4) AS x, toUInt16(x); -- { serverError 407 }
-
-SELECT toInt64('2147483647') AS x, toDecimal32(x, 0);
-SELECT toInt64('-2147483647') AS x, toDecimal32(x, 0);
-SELECT toUInt64('2147483647') AS x, toDecimal32(x, 0);
-SELECT toInt64('2147483649') AS x, toDecimal32(x, 0); -- { serverError 407 }
-SELECT toInt64('-2147483649') AS x, toDecimal32(x, 0); -- { serverError 407 }
-SELECT toUInt64('2147483649') AS x, toDecimal32(x, 0); -- { serverError 407 }
-
-SELECT toUInt64('9223372036854775807') AS x, toDecimal64(x, 0);
-SELECT toUInt64('9223372036854775809') AS x, toDecimal64(x, 0); -- { serverError 407 }
-
-SELECT toDecimal32(0, rowNumberInBlock()); -- { serverError 44 }
-SELECT toDecimal64(0, rowNumberInBlock()); -- { serverError 44 }
-SELECT toDecimal128(0, rowNumberInBlock()); -- { serverError 44 }
-
-SELECT toDecimal32(1/0, 0); -- { serverError 407 }
-SELECT toDecimal64(1/0, 1); -- { serverError 407 }
-SELECT toDecimal128(0/0, 2); -- { serverError 407 }
-SELECT CAST(1/0, 'Decimal(9, 0)'); -- { serverError 407 }
-SELECT CAST(1/0, 'Decimal(18, 1)'); -- { serverError 407 }
-SELECT CAST(1/0, 'Decimal(38, 2)'); -- { serverError 407 }
-SELECT CAST(0/0, 'Decimal(9, 3)'); -- { serverError 407 }
-SELECT CAST(0/0, 'Decimal(18, 4)'); -- { serverError 407 }
-SELECT CAST(0/0, 'Decimal(38, 5)'); -- { serverError 407 }
-
-select toDecimal32(10000.1, 6); -- { serverError 407 }
-select toDecimal64(10000.1, 18); -- { serverError 407 }
-select toDecimal128(1000000000000000000000.1, 18); -- { serverError 407 }
-
-select toDecimal32(-10000.1, 6); -- { serverError 407 }
-select toDecimal64(-10000.1, 18); -- { serverError 407 }
-select toDecimal128(-1000000000000000000000.1, 18); -- { serverError 407 }
-
-select toDecimal32(2147483647.0 + 1.0, 0); -- { serverError 407 }
-select toDecimal64(9223372036854775807.0, 0); -- { serverError 407 }
-select toDecimal128(170141183460469231731687303715884105729.0, 0); -- { serverError 407 }
-
-select toDecimal32(-2147483647.0 - 1.0, 0); -- { serverError 407 }
-select toDecimal64(-9223372036854775807.0, 0); -- { serverError 407 }
-select toDecimal128(-170141183460469231731687303715884105729.0, 0); -- { serverError 407 }
diff --git a/tests/queries/0_stateless/00700_decimal_casts_2.reference b/tests/queries/0_stateless/00700_decimal_casts_2.reference
new file mode 100644
index 00000000000..393baae6c47
--- /dev/null
+++ b/tests/queries/0_stateless/00700_decimal_casts_2.reference
@@ -0,0 +1,37 @@
+1234567890.0000000000000000000000000000	1234567890.00000000000000000000000000000	1234567890.00000000000000000000000000000
+-126561577.683753853853498429727072845824
+1234567890.00000000	1234567890.000000000	1234567890.000000000
+12345678.0	12345678.00	12345678.00
+9223372036854775807.000000	9223372036854775807	-9223372036854775807
+9223372036854775800	9223372036854775800	-9223372036854775800
+92233720368547758.00	92233720368547758	-92233720368547758
+2147483647.0000000000	2147483647	-2147483647
+2147483647.00	2147483647	-2147483647
+92233720368547757.99	92233720368547757	-92233720368547757
+2147483640.99	2147483640	-2147483640
+-0.90000000	0
+-0.90000000	0
+-0.90000000	0
+-0.8000	0
+-0.8000	0
+-0.8000	0
+-0.70	0
+-0.70	0
+-0.70	0
+-0.600000	0
+-0.600000	0
+-0.600000	0
+18446744073709551615	18446744073709551615
+18446744073709551615.00000000	18446744073709551615
+4294967295	4294967295
+4294967295.0000000000	4294967295
+4294967295	4294967295
+4294967295.0000	4294967295
+65535	65535
+65535.0000000000	65535
+65535	65535
+65535.0000	65535
+2147483647	2147483647
+-2147483647	-2147483647
+2147483647	2147483647
+9223372036854775807	9223372036854775807
diff --git a/tests/queries/0_stateless/00700_decimal_casts_2.sql b/tests/queries/0_stateless/00700_decimal_casts_2.sql
new file mode 100644
index 00000000000..89c95fed271
--- /dev/null
+++ b/tests/queries/0_stateless/00700_decimal_casts_2.sql
@@ -0,0 +1,119 @@
+SELECT toDecimal128('1234567890', 28) AS x, toDecimal128(x, 29), toDecimal128(toDecimal128('1234567890', 28), 29);
+SELECT toDecimal128(toDecimal128('1234567890', 28), 30);
+
+SELECT toDecimal64('1234567890', 8) AS x, toDecimal64(x, 9), toDecimal64(toDecimal64('1234567890', 8), 9);
+SELECT toDecimal64(toDecimal64('1234567890', 8), 10); -- { serverError 407 }
+
+SELECT toDecimal32('12345678', 1) AS x, toDecimal32(x, 2), toDecimal32(toDecimal32('12345678', 1), 2);
+SELECT toDecimal32(toDecimal32('12345678', 1), 3); -- { serverError 407 }
+
+SELECT toDecimal64(toDecimal64('92233720368547758.1', 1), 2); -- { serverError 407 }
+SELECT toDecimal64(toDecimal64('-92233720368547758.1', 1), 2); -- { serverError 407 }
+
+SELECT toDecimal128('9223372036854775807', 6) AS x, toInt64(x), toInt64(-x);
+SELECT toDecimal128('9223372036854775809', 6) AS x, toInt64(x); -- { serverError 407 }
+SELECT toDecimal128('9223372036854775809', 6) AS x, toInt64(-x); -- { serverError 407 }
+SELECT toDecimal64('922337203685477580', 0) * 10 AS x, toInt64(x), toInt64(-x);
+SELECT toDecimal64(toDecimal64('92233720368547758.0', 1), 2) AS x, toInt64(x), toInt64(-x);
+
+SELECT toDecimal128('2147483647', 10) AS x, toInt32(x), toInt32(-x);
+SELECT toDecimal128('2147483649', 10) AS x, toInt32(x), toInt32(-x); -- { serverError 407 }
+SELECT toDecimal64('2147483647', 2) AS x, toInt32(x), toInt32(-x);
+SELECT toDecimal64('2147483649', 2) AS x, toInt32(x), toInt32(-x); -- { serverError 407 }
+
+SELECT toDecimal128('92233720368547757.99', 2) AS x, toInt64(x), toInt64(-x);
+SELECT toDecimal64('2147483640.99', 2) AS x, toInt32(x), toInt32(-x);
+
+SELECT toDecimal128('-0.9', 8) AS x, toUInt64(x);
+SELECT toDecimal64('-0.9', 8) AS x, toUInt64(x);
+SELECT toDecimal32('-0.9', 8) AS x, toUInt64(x);
+
+SELECT toDecimal128('-0.8', 4) AS x, toUInt32(x);
+SELECT toDecimal64('-0.8', 4) AS x, toUInt32(x);
+SELECT toDecimal32('-0.8', 4) AS x, toUInt32(x);
+
+SELECT toDecimal128('-0.7', 2) AS x, toUInt16(x);
+SELECT toDecimal64('-0.7', 2) AS x, toUInt16(x);
+SELECT toDecimal32('-0.7', 2) AS x, toUInt16(x);
+
+SELECT toDecimal128('-0.6', 6) AS x, toUInt8(x);
+SELECT toDecimal64('-0.6', 6) AS x, toUInt8(x);
+SELECT toDecimal32('-0.6', 6) AS x, toUInt8(x);
+
+SELECT toDecimal128('-1', 7) AS x, toUInt64(x); -- { serverError 407 }
+SELECT toDecimal128('-1', 7) AS x, toUInt32(x); -- { serverError 407 }
+SELECT toDecimal128('-1', 7) AS x, toUInt16(x); -- { serverError 407 }
+SELECT toDecimal128('-1', 7) AS x, toUInt8(x); -- { serverError 407 }
+
+SELECT toDecimal64('-1', 5) AS x, toUInt64(x); -- { serverError 407 }
+SELECT toDecimal64('-1', 5) AS x, toUInt32(x); -- { serverError 407 }
+SELECT toDecimal64('-1', 5) AS x, toUInt16(x); -- { serverError 407 }
+SELECT toDecimal64('-1', 5) AS x, toUInt8(x); -- { serverError 407 }
+
+SELECT toDecimal32('-1', 3) AS x, toUInt64(x); -- { serverError 407 }
+SELECT toDecimal32('-1', 3) AS x, toUInt32(x); -- { serverError 407 }
+SELECT toDecimal32('-1', 3) AS x, toUInt16(x); -- { serverError 407 }
+SELECT toDecimal32('-1', 3) AS x, toUInt8(x); -- { serverError 407 }
+
+SELECT toDecimal128('18446744073709551615', 0) AS x, toUInt64(x);
+SELECT toDecimal128('18446744073709551616', 0) AS x, toUInt64(x); -- { serverError 407 }
+SELECT toDecimal128('18446744073709551615', 8) AS x, toUInt64(x);
+SELECT toDecimal128('18446744073709551616', 8) AS x, toUInt64(x); -- { serverError 407 }
+
+SELECT toDecimal128('4294967295', 0) AS x, toUInt32(x);
+SELECT toDecimal128('4294967296', 0) AS x, toUInt32(x); -- { serverError 407 }
+SELECT toDecimal128('4294967295', 10) AS x, toUInt32(x);
+SELECT toDecimal128('4294967296', 10) AS x, toUInt32(x); -- { serverError 407 }
+SELECT toDecimal64('4294967295', 0) AS x, toUInt32(x);
+SELECT toDecimal64('4294967296', 0) AS x, toUInt32(x); -- { serverError 407 }
+SELECT toDecimal64('4294967295', 4) AS x, toUInt32(x);
+SELECT toDecimal64('4294967296', 4) AS x, toUInt32(x); -- { serverError 407 }
+
+SELECT toDecimal128('65535', 0) AS x, toUInt16(x);
+SELECT toDecimal128('65536', 0) AS x, toUInt16(x); -- { serverError 407 }
+SELECT toDecimal128('65535', 10) AS x, toUInt16(x);
+SELECT toDecimal128('65536', 10) AS x, toUInt16(x); -- { serverError 407 }
+SELECT toDecimal64('65535', 0) AS x, toUInt16(x);
+SELECT toDecimal64('65536', 0) AS x, toUInt16(x); -- { serverError 407 }
+SELECT toDecimal64('65535', 4) AS x, toUInt16(x);
+SELECT toDecimal64('65536', 4) AS x, toUInt16(x); -- { serverError 407 }
+
+SELECT toInt64('2147483647') AS x, toDecimal32(x, 0);
+SELECT toInt64('-2147483647') AS x, toDecimal32(x, 0);
+SELECT toUInt64('2147483647') AS x, toDecimal32(x, 0);
+SELECT toInt64('2147483649') AS x, toDecimal32(x, 0); -- { serverError 407 }
+SELECT toInt64('-2147483649') AS x, toDecimal32(x, 0); -- { serverError 407 }
+SELECT toUInt64('2147483649') AS x, toDecimal32(x, 0); -- { serverError 407 }
+
+SELECT toUInt64('9223372036854775807') AS x, toDecimal64(x, 0);
+SELECT toUInt64('9223372036854775809') AS x, toDecimal64(x, 0); -- { serverError 407 }
+
+SELECT toDecimal32(0, rowNumberInBlock()); -- { serverError 44 }
+SELECT toDecimal64(0, rowNumberInBlock()); -- { serverError 44 }
+SELECT toDecimal128(0, rowNumberInBlock()); -- { serverError 44 }
+
+SELECT toDecimal32(1/0, 0); -- { serverError 407 }
+SELECT toDecimal64(1/0, 1); -- { serverError 407 }
+SELECT toDecimal128(0/0, 2); -- { serverError 407 }
+SELECT CAST(1/0, 'Decimal(9, 0)'); -- { serverError 407 }
+SELECT CAST(1/0, 'Decimal(18, 1)'); -- { serverError 407 }
+SELECT CAST(1/0, 'Decimal(38, 2)'); -- { serverError 407 }
+SELECT CAST(0/0, 'Decimal(9, 3)'); -- { serverError 407 }
+SELECT CAST(0/0, 'Decimal(18, 4)'); -- { serverError 407 }
+SELECT CAST(0/0, 'Decimal(38, 5)'); -- { serverError 407 }
+
+select toDecimal32(10000.1, 6); -- { serverError 407 }
+select toDecimal64(10000.1, 18); -- { serverError 407 }
+select toDecimal128(1000000000000000000000.1, 18); -- { serverError 407 }
+
+select toDecimal32(-10000.1, 6); -- { serverError 407 }
+select toDecimal64(-10000.1, 18); -- { serverError 407 }
+select toDecimal128(-1000000000000000000000.1, 18); -- { serverError 407 }
+
+select toDecimal32(2147483647.0 + 1.0, 0); -- { serverError 407 }
+select toDecimal64(9223372036854775807.0, 0); -- { serverError 407 }
+select toDecimal128(170141183460469231731687303715884105729.0, 0); -- { serverError 407 }
+
+select toDecimal32(-2147483647.0 - 1.0, 0); -- { serverError 407 }
+select toDecimal64(-9223372036854775807.0, 0); -- { serverError 407 }
+select toDecimal128(-170141183460469231731687303715884105729.0, 0); -- { serverError 407 }
diff --git a/tests/queries/0_stateless/00700_decimal_math.reference b/tests/queries/0_stateless/00700_decimal_math.reference
index 88917004702..f58e08dc1fb 100644
--- a/tests/queries/0_stateless/00700_decimal_math.reference
+++ b/tests/queries/0_stateless/00700_decimal_math.reference
@@ -26,5 +26,5 @@
 1.00000	0.8427007929497149	0.15729920705028513
 42.4200	115.60113124678627	1.6029995567009473e50
 0.00	0	1	0
-3.1415926535897927981986333033020522496	0	-1	-0
+3.14159265358979	0	-1	-0
 1.00	1.5707963267948966	0	0.7853981633974483
diff --git a/tests/queries/0_stateless/00700_decimal_math.sql b/tests/queries/0_stateless/00700_decimal_math.sql
index a6c1ab2f393..237bee1c691 100644
--- a/tests/queries/0_stateless/00700_decimal_math.sql
+++ b/tests/queries/0_stateless/00700_decimal_math.sql
@@ -36,7 +36,7 @@ SELECT toDecimal128('1.0', 5) AS x, erf(x), erfc(x);
 SELECT toDecimal128('42.42', 4) AS x, lgamma(x), tgamma(x);
 
 SELECT toDecimal128('0.0', 2) AS x, round(sin(x), 8), round(cos(x), 8), round(tan(x), 8);
-SELECT toDecimal128(pi(), 37) AS x, round(sin(x), 8), round(cos(x), 8), round(tan(x), 8);
+SELECT toDecimal128(pi(), 14) AS x, round(sin(x), 8), round(cos(x), 8), round(tan(x), 8);
 SELECT toDecimal128('1.0', 2) AS x, asin(x), acos(x), atan(x);
 
 
diff --git a/tests/queries/0_stateless/00700_decimal_round.reference b/tests/queries/0_stateless/00700_decimal_round.reference
index 11281cdeeb6..230b6863411 100644
--- a/tests/queries/0_stateless/00700_decimal_round.reference
+++ b/tests/queries/0_stateless/00700_decimal_round.reference
@@ -58,18 +58,18 @@
 -12345.6789	-12340.0000	-12300.0000	-12000.0000	-10000.0000	0.0000
 -12345.6789	-12350.0000	-12400.0000	-13000.0000	-20000.0000	-100000.0000
 -12345.6789	-12340.0000	-12300.0000	-12000.0000	-10000.0000	0.0000
-123456789.123456784	-123456789.123456784	123456789.000000000	-123456789.000000000	123456789.123460000	-123456789.123460000	123500000.000000000	-123500000.000000000
-123456789.123456784	-123456789.123456784	123456789.000000000	-123456789.000000000	123456789.123460000	-123456789.123460000	123500000.000000000	-123500000.000000000
-123456789.123456784	-123456789.123456784	123456790.000000000	-123456789.000000000	123456789.123460000	-123456789.123450000	123500000.000000000	-123400000.000000000
-123456789.123456784	-123456789.123456784	123456789.000000000	-123456790.000000000	123456789.123450000	-123456789.123460000	123400000.000000000	-123500000.000000000
-123456789.123456784	-123456789.123456784	123456789.000000000	-123456789.000000000	123456789.123450000	-123456789.123450000	123400000.000000000	-123400000.000000000
-12345678901234567525491324606.797053952	-12345678901234567525491324606.797053952	12345678901234567525491324607.000000000	-12345678901234567525491324607.000000000	12345678901234567525491324606.797000000	-12345678901234567525491324606.797000000
-12345678901234567525491324606.797053952	-12345678901234567525491324606.797053952	12345678901234567525491324607.000000000	-12345678901234567525491324607.000000000	12345678901234567525491324606.797000000	-12345678901234567525491324606.797000000
-12345678901234567525491324606.797053952	-12345678901234567525491324606.797053952	12345678901234567525491324607.000000000	-12345678901234567525491324606.000000000	12345678901234567525491324606.798000000	-12345678901234567525491324606.797000000
-12345678901234567525491324606.797053952	-12345678901234567525491324606.797053952	12345678901234567525491324606.000000000	-12345678901234567525491324607.000000000	12345678901234567525491324606.797000000	-12345678901234567525491324606.798000000
-12345678901234567525491324606.797053952	-12345678901234567525491324606.797053952	12345678901234567525491324606.000000000	-12345678901234567525491324606.000000000	12345678901234567525491324606.797000000	-12345678901234567525491324606.797000000
-12345678901234567525491324606.797053952	-12345678901234567525491324606.797053952	12345678901234567525491324607.000000000	-12345678901234567525491324607.000000000	12345678901234567525491325000.000000000	-12345678901234567525491325000.000000000
-12345678901234567525491324606.797053952	-12345678901234567525491324606.797053952	12345678901234567525491324607.000000000	-12345678901234567525491324607.000000000	12345678901234567525491325000.000000000	-12345678901234567525491325000.000000000
-12345678901234567525491324606.797053952	-12345678901234567525491324606.797053952	12345678901234567525491324607.000000000	-12345678901234567525491324606.000000000	12345678901234567525491325000.000000000	-12345678901234567525491324000.000000000
-12345678901234567525491324606.797053952	-12345678901234567525491324606.797053952	12345678901234567525491324606.000000000	-12345678901234567525491324607.000000000	12345678901234567525491324000.000000000	-12345678901234567525491325000.000000000
-12345678901234567525491324606.797053952	-12345678901234567525491324606.797053952	12345678901234567525491324606.000000000	-12345678901234567525491324606.000000000	12345678901234567525491324000.000000000	-12345678901234567525491324000.000000000
+123456789.123456789	-123456789.123456789	123456789.000000000	-123456789.000000000	123456789.123460000	-123456789.123460000	123500000.000000000	-123500000.000000000
+123456789.123456789	-123456789.123456789	123456789.000000000	-123456789.000000000	123456789.123460000	-123456789.123460000	123500000.000000000	-123500000.000000000
+123456789.123456789	-123456789.123456789	123456790.000000000	-123456789.000000000	123456789.123460000	-123456789.123450000	123500000.000000000	-123400000.000000000
+123456789.123456789	-123456789.123456789	123456789.000000000	-123456790.000000000	123456789.123450000	-123456789.123460000	123400000.000000000	-123500000.000000000
+123456789.123456789	-123456789.123456789	123456789.000000000	-123456789.000000000	123456789.123450000	-123456789.123450000	123400000.000000000	-123400000.000000000
+12345678901234567890123456789.123456789	-12345678901234567890123456789.123456789	12345678901234567890123456789.000000000	-12345678901234567890123456789.000000000	12345678901234567890123456789.123000000	-12345678901234567890123456789.123000000
+12345678901234567890123456789.123456789	-12345678901234567890123456789.123456789	12345678901234567890123456789.000000000	-12345678901234567890123456789.000000000	12345678901234567890123456789.123000000	-12345678901234567890123456789.123000000
+12345678901234567890123456789.123456789	-12345678901234567890123456789.123456789	12345678901234567890123456790.000000000	-12345678901234567890123456789.000000000	12345678901234567890123456789.124000000	-12345678901234567890123456789.123000000
+12345678901234567890123456789.123456789	-12345678901234567890123456789.123456789	12345678901234567890123456789.000000000	-12345678901234567890123456790.000000000	12345678901234567890123456789.123000000	-12345678901234567890123456789.124000000
+12345678901234567890123456789.123456789	-12345678901234567890123456789.123456789	12345678901234567890123456789.000000000	-12345678901234567890123456789.000000000	12345678901234567890123456789.123000000	-12345678901234567890123456789.123000000
+12345678901234567890123456789.123456789	-12345678901234567890123456789.123456789	12345678901234567890123456789.000000000	-12345678901234567890123456789.000000000	12345678901234567890123457000.000000000	-12345678901234567890123457000.000000000
+12345678901234567890123456789.123456789	-12345678901234567890123456789.123456789	12345678901234567890123456789.000000000	-12345678901234567890123456789.000000000	12345678901234567890123457000.000000000	-12345678901234567890123457000.000000000
+12345678901234567890123456789.123456789	-12345678901234567890123456789.123456789	12345678901234567890123456790.000000000	-12345678901234567890123456789.000000000	12345678901234567890123457000.000000000	-12345678901234567890123456000.000000000
+12345678901234567890123456789.123456789	-12345678901234567890123456789.123456789	12345678901234567890123456789.000000000	-12345678901234567890123456790.000000000	12345678901234567890123456000.000000000	-12345678901234567890123457000.000000000
+12345678901234567890123456789.123456789	-12345678901234567890123456789.123456789	12345678901234567890123456789.000000000	-12345678901234567890123456789.000000000	12345678901234567890123456000.000000000	-12345678901234567890123456000.000000000
diff --git a/tests/queries/0_stateless/00700_decimal_round.sql b/tests/queries/0_stateless/00700_decimal_round.sql
index 318a7718de9..c5b8dbb520b 100644
--- a/tests/queries/0_stateless/00700_decimal_round.sql
+++ b/tests/queries/0_stateless/00700_decimal_round.sql
@@ -61,20 +61,20 @@ SELECT toDecimal128(-12345.6789, 4) AS x, ceil(x, -1), ceil(x, -2), ceil(x, -3),
 SELECT toDecimal128(-12345.6789, 4) AS x, floor(x, -1), floor(x, -2), floor(x, -3), floor(x, -4), floor(x, -5);
 SELECT toDecimal128(-12345.6789, 4) AS x, trunc(x, -1), trunc(x, -2), trunc(x, -3), trunc(x, -4), trunc(x, -5);
 
-SELECT toDecimal64(123456789.123456789, 9) AS x, -x AS y, round(x), round(y), round(x, 5), round(y, 5), round(x, -5), round(y, -5);
-SELECT toDecimal64(123456789.123456789, 9) AS x, -x AS y, roundBankers(x), roundBankers(y), roundBankers(x, 5), roundBankers(y, 5), roundBankers(x, -5), roundBankers(y, -5);
-SELECT toDecimal64(123456789.123456789, 9) AS x, -x AS y, ceil(x), ceil(y), ceil(x, 5), ceil(y, 5), ceil(x, -5), ceil(y, -5);
-SELECT toDecimal64(123456789.123456789, 9) AS x, -x AS y, floor(x), floor(y), floor(x, 5), floor(y, 5), floor(x, -5), floor(y, -5);
-SELECT toDecimal64(123456789.123456789, 9) AS x, -x AS y, trunc(x), trunc(y), trunc(x, 5), trunc(y, 5), trunc(x, -5), trunc(y, -5);
+SELECT toDecimal64('123456789.123456789', 9) AS x, -x AS y, round(x), round(y), round(x, 5), round(y, 5), round(x, -5), round(y, -5);
+SELECT toDecimal64('123456789.123456789', 9) AS x, -x AS y, roundBankers(x), roundBankers(y), roundBankers(x, 5), roundBankers(y, 5), roundBankers(x, -5), roundBankers(y, -5);
+SELECT toDecimal64('123456789.123456789', 9) AS x, -x AS y, ceil(x), ceil(y), ceil(x, 5), ceil(y, 5), ceil(x, -5), ceil(y, -5);
+SELECT toDecimal64('123456789.123456789', 9) AS x, -x AS y, floor(x), floor(y), floor(x, 5), floor(y, 5), floor(x, -5), floor(y, -5);
+SELECT toDecimal64('123456789.123456789', 9) AS x, -x AS y, trunc(x), trunc(y), trunc(x, 5), trunc(y, 5), trunc(x, -5), trunc(y, -5);
 
-SELECT toDecimal128(12345678901234567890123456789.123456789, 9) AS x, -x AS y, round(x), round(y), round(x, 3), round(y, 3);
-SELECT toDecimal128(12345678901234567890123456789.123456789, 9) AS x, -x AS y, roundBankers(x), roundBankers(y), roundBankers(x, 3), roundBankers(y, 3);
-SELECT toDecimal128(12345678901234567890123456789.123456789, 9) AS x, -x AS y, ceil(x), ceil(y), ceil(x, 3), ceil(y, 3);
-SELECT toDecimal128(12345678901234567890123456789.123456789, 9) AS x, -x AS y, floor(x), floor(y), floor(x, 3), floor(y, 3);
-SELECT toDecimal128(12345678901234567890123456789.123456789, 9) AS x, -x AS y, trunc(x), trunc(y), trunc(x, 3), trunc(y, 3);
+SELECT toDecimal128('12345678901234567890123456789.123456789', 9) AS x, -x AS y, round(x), round(y), round(x, 3), round(y, 3);
+SELECT toDecimal128('12345678901234567890123456789.123456789', 9) AS x, -x AS y, roundBankers(x), roundBankers(y), roundBankers(x, 3), roundBankers(y, 3);
+SELECT toDecimal128('12345678901234567890123456789.123456789', 9) AS x, -x AS y, ceil(x), ceil(y), ceil(x, 3), ceil(y, 3);
+SELECT toDecimal128('12345678901234567890123456789.123456789', 9) AS x, -x AS y, floor(x), floor(y), floor(x, 3), floor(y, 3);
+SELECT toDecimal128('12345678901234567890123456789.123456789', 9) AS x, -x AS y, trunc(x), trunc(y), trunc(x, 3), trunc(y, 3);
 
-SELECT toDecimal128(12345678901234567890123456789.123456789, 9) AS x, -x AS y, round(x), round(y), round(x, -3), round(y, -3);
-SELECT toDecimal128(12345678901234567890123456789.123456789, 9) AS x, -x AS y, roundBankers(x), roundBankers(y), roundBankers(x, -3), roundBankers(y, -3);
-SELECT toDecimal128(12345678901234567890123456789.123456789, 9) AS x, -x AS y, ceil(x), ceil(y), ceil(x, -3), ceil(y, -3);
-SELECT toDecimal128(12345678901234567890123456789.123456789, 9) AS x, -x AS y, floor(x), floor(y), floor(x, -3), floor(y, -3);
-SELECT toDecimal128(12345678901234567890123456789.123456789, 9) AS x, -x AS y, trunc(x), trunc(y), trunc(x, -3), trunc(y, -3);
+SELECT toDecimal128('12345678901234567890123456789.123456789', 9) AS x, -x AS y, round(x), round(y), round(x, -3), round(y, -3);
+SELECT toDecimal128('12345678901234567890123456789.123456789', 9) AS x, -x AS y, roundBankers(x), roundBankers(y), roundBankers(x, -3), roundBankers(y, -3);
+SELECT toDecimal128('12345678901234567890123456789.123456789', 9) AS x, -x AS y, ceil(x), ceil(y), ceil(x, -3), ceil(y, -3);
+SELECT toDecimal128('12345678901234567890123456789.123456789', 9) AS x, -x AS y, floor(x), floor(y), floor(x, -3), floor(y, -3);
+SELECT toDecimal128('12345678901234567890123456789.123456789', 9) AS x, -x AS y, trunc(x), trunc(y), trunc(x, -3), trunc(y, -3);
diff --git a/tests/queries/0_stateless/01035_avg.reference b/tests/queries/0_stateless/01035_avg.reference
index ec79205c6f8..a9f31de57e1 100644
--- a/tests/queries/0_stateless/01035_avg.reference
+++ b/tests/queries/0_stateless/01035_avg.reference
@@ -1,5 +1,5 @@
-nan	nan	nan	nan	nan	nan	nan	nan	nan	nan	nan	nan	nan	nan	nan	nan	nan
--0.5	-0.5	-0.5	-0.5	-0.5	-0.5	127.493856	32355.57552	499999.5	499999.5	499999.5	499999.5	499999.5	-0.000500002	0.49999949943727	-0.000005	-0.000005257366687274546
+nan	nan	nan	nan	nan	nan	nan	nan	nan	nan	nan	nan	nan	nan	nan	nan	nan	nan
+-0.5	-0.5	-0.5	-0.5	-0.5	-0.5	127.493856	32355.57552	499999.5	499999.5	499999.5	499999.5	499999.5	499999.5	-0.000500002	0.49999949943727	-0.000005026740899901579	-0.000005257366687274546
 -2767.546272
 999999
--0.50000449943727
+-0.5000045261781699
diff --git a/tests/queries/0_stateless/01035_avg.sql b/tests/queries/0_stateless/01035_avg.sql
index a185ce816fb..7ad08373917 100644
--- a/tests/queries/0_stateless/01035_avg.sql
+++ b/tests/queries/0_stateless/01035_avg.sql
@@ -1,6 +1,5 @@
 SET allow_experimental_bigint_types=1;
 
--- no UInt128 as for now
 CREATE TABLE IF NOT EXISTS test_01035_avg (
     i8 Int8         DEFAULT i64,
     i16 Int16       DEFAULT i64,
@@ -13,6 +12,7 @@ CREATE TABLE IF NOT EXISTS test_01035_avg (
     u16 UInt16      DEFAULT u64,
     u32 UInt32      DEFAULT u64,
     u64 UInt64,
+    u128 UInt128    DEFAULT u64,
     u256 UInt256    DEFAULT u64,
 
     f32 Float32     DEFAULT u64,
@@ -25,14 +25,14 @@ CREATE TABLE IF NOT EXISTS test_01035_avg (
 ) ENGINE = MergeTree() ORDER BY i64;
 
 SELECT avg(i8), avg(i16), avg(i32), avg(i64), avg(i128), avg(i256),
-       avg(u8), avg(u16), avg(u32), avg(u64), avg(u256),
+       avg(u8), avg(u16), avg(u32), avg(u64), avg(u128), avg(u256),
        avg(f32), avg(f64),
        avg(d32), avg(d64), avg(d128), avg(d256) FROM test_01035_avg;
 
 INSERT INTO test_01035_avg (u64) SELECT number FROM system.numbers LIMIT 1000000;
 
 SELECT avg(i8), avg(i16), avg(i32), avg(i64), avg(i128), avg(i256),
-       avg(u8), avg(u16), avg(u32), avg(u64), avg(u256),
+       avg(u8), avg(u16), avg(u32), avg(u64), avg(u128), avg(u256),
        avg(f32), avg(f64),
        avg(d32), avg(d64), avg(d128), avg(d256) FROM test_01035_avg;
 
diff --git a/tests/queries/0_stateless/01087_table_function_generate.reference b/tests/queries/0_stateless/01087_table_function_generate.reference
index d8886945caa..c04fa831328 100644
--- a/tests/queries/0_stateless/01087_table_function_generate.reference
+++ b/tests/queries/0_stateless/01087_table_function_generate.reference
@@ -1,14 +1,14 @@
 UInt64	Int64	UInt32	Int32	UInt16	Int16	UInt8	Int8
-2804162938822577320	-2776833771540858	3467776823	1163715250	23903	-2916	220	-117
-7885388429666205427	-1363628932535403038	484159052	-308788249	44305	13638	143	-105
-4357435422797280898	1355609803008819271	4126129912	-852056475	58858	9166	49	33
-5935810273536892891	-804738887697332962	3109335413	-80126721	13655	-31421	186	-77
-368066018677693974	-4927165984347126295	1015254922	2026080544	21973	-29626	240	108
-8124171311239967992	-1179703908046100129	1720727300	-138469036	36175	-12819	138	16
-15657812979985370729	-5733276247123822513	3254757884	-500590428	13193	30527	3	-81
-18371568619324220532	-6793779541583578394	1686821450	-455892108	52282	2284	252	-90
-821735343441964030	3148260644406230976	256251035	-885069056	55255	11455	176	90
-9558594037060121162	-2907172753635797124	4276198376	1947296644	48701	26632	97	43
+2804162938822577320	-2776833771540858	3467776823	1163715250	23903	13655	137	-41
+7885388429666205427	-1363628932535403038	484159052	-308788249	56810	-22227	51	-41
+4357435422797280898	1355609803008819271	4126129912	-852056475	64304	-11401	139	86
+5935810273536892891	-804738887697332962	3109335413	-80126721	258	12889	18	88
+368066018677693974	-4927165984347126295	1015254922	2026080544	44305	21973	16	0
+8124171311239967992	-1179703908046100129	1720727300	-138469036	61343	10573	252	-32
+15657812979985370729	-5733276247123822513	3254757884	-500590428	45913	19153	105	-102
+18371568619324220532	-6793779541583578394	1686821450	-455892108	49050	-28603	248	80
+821735343441964030	3148260644406230976	256251035	-885069056	58858	-29361	58	61
+9558594037060121162	-2907172753635797124	4276198376	1947296644	26801	-13531	204	-66
 -
 Enum8(\'hello\' = 1, \'world\' = 5)
 hello
@@ -47,16 +47,16 @@ h
 o
 -
 Date	DateTime	DateTime(\'Europe/Moscow\')
-2113-06-12	1970-10-09 02:30:14	2074-08-12 11:31:27
-2103-11-03	2106-01-30 21:52:44	2097-05-25 07:54:35
-2008-03-16	2096-12-12 00:40:50	1988-08-10 11:16:31
-2126-11-26	2096-01-15 16:31:33	2063-10-20 08:48:17
-1991-02-02	2103-02-11 16:44:39	2036-10-09 04:29:10
-2096-11-03	1980-01-02 05:18:22	2055-12-23 12:33:52
-2024-12-16	2079-06-11 16:29:02	2000-12-05 17:46:24
-2085-04-07	2100-03-01 18:50:22	1993-03-25 01:19:12
-2135-05-30	2034-08-25 19:46:33	2045-12-10 16:47:40
-2094-12-18	2069-09-30 16:07:48	2084-08-26 03:33:12
+2113-06-12	2050-12-17 02:46:35	2096-02-16 22:18:22
+2141-08-09	2013-10-17 23:35:26	1976-01-24 12:52:48
+2039-08-16	1974-11-17 23:22:46	1980-03-04 21:02:50
+1997-04-11	1972-09-18 23:44:08	2040-07-10 14:46:42
+2103-11-03	2044-11-23 20:57:12	1970-10-09 02:30:14
+2066-11-19	2029-12-10 03:13:55	2106-01-30 21:52:44
+2064-08-14	2016-07-14 11:33:45	2096-12-12 00:40:50
+2046-09-13	2085-07-10 18:51:14	2096-01-15 16:31:33
+2008-03-16	2047-05-16 23:28:36	2103-02-11 16:44:39
+2000-07-07	2105-07-19 19:29:06	1980-01-02 05:18:22
 -
 DateTime64(3)	DateTime64(6)	DateTime64(6, \'Europe/Moscow\')
 1978-06-07 23:50:57.320	2013-08-28 10:21:54.010758	1991-08-25 16:23:26.140215
@@ -225,14 +225,14 @@ RL,{Xs\\tw
 [114]	-84125.1554	('2023-06-06 06:55:06.492','bf9ab359-ef9f-ad11-7e6c-160368b1e5ea')
 [124]	-114719.5228	('2010-11-11 22:57:23.722','c1046ffb-3415-cc3a-509a-e0005856d7d7')
 -
-[]	1900051923	{	-189530.5846	h	-5.6279699579452485e47	('1984-12-06','2090-10-31 19:35:45','2038-07-15 05:22:51.805','63d9a12d-d1cf-1f3a-57c6-9bc6dddd0975')	8502
-[-102,-118]	392272782	Eb	-14818.0200	o	-2.664492247169164e59	('2024-01-16','1994-07-16 00:40:02','2034-02-02 05:30:44.960','4fa09948-d32e-8903-63df-43ad759e43f7')	DA61
-[-71]	775049089	\N	-158115.1178	w	4.1323844687113747e-305	('2103-08-04','2062-08-12 23:41:53','2074-02-13 10:29:40.749','c4a44dd7-d009-6f65-1494-9daedfa8a124')	83A7
-[-28,100]	3675466147	{	-146685.1749	h	3.6676044396877755e142	('2119-02-01','2002-06-26 03:33:41','2002-12-02 05:46:03.455','98714b2c-65e7-b5cb-a040-421e260c6d8d')	4B94
-[-23]	2514120753	(`u,	-119659.6174	w	1.3231258347475906e34	('2017-10-25','2080-03-28 08:11:25','2073-07-10 12:19:58.146','003b3b6b-088f-f941-aeb9-c26e0ee72b8e')	6B1F
-[11,-36]	3308237300	\N	171205.1896	\N	5.634708707075817e195	('2084-01-01','2041-11-11 13:19:44','2044-03-18 17:34:17.814','9e60f4cb-6e55-1deb-5ac4-d66a86a8886d')	1964
-[39]	1614362420	`4A8P	157144.0630	o	-1.1843143253872814e-255	('2061-03-10','2066-03-02 11:07:49','1997-10-22 20:14:13.755','97685503-2609-d2b9-981c-02fd75d106cb')	A35B
-[48,-120]	3848918261	1<Lu3	91487.2852	h	-1.9300793134783347e263	('2081-06-01','2031-08-07 11:29:42','2085-03-11 15:17:17.374','af838873-48b2-f609-6483-f5c08733364c')	8E7C
-[55]	3047524030	li&lF	93462.3661	h	2.8979254388809897e54	('2108-04-19','2058-07-14 01:47:30','2055-10-14 06:36:20.056','e932a7b5-173a-1304-e522-b794b8fa3f11')	35D9
-[100,-42]	3999367674		-112975.9852	h	2.658098863752086e-160	('2005-08-26','2029-04-21 12:27:59','2068-08-27 07:49:41.825','802b2a96-319b-8e60-63d9-99b88ccae237')	074E
+[]	1900051923	{	-189530.5846	h	-5.6279699579452485e47	('1984-12-06','2028-08-17 06:05:01','2036-04-02 23:52:28.468','4b3d498c-dd44-95c1-5b75-921504ec5d8d')	F743
+[-102,-118]	392272782	Eb	-14818.0200	o	-2.664492247169164e59	('2082-12-26','2052-09-09 06:50:50','2088-04-21 05:07:08.245','aeb9c26e-0ee7-2b8e-802b-2a96319b8e60')	CBF4
+[-71]	775049089	\N	-158115.1178	w	4.1323844687113747e-305	('2108-04-19','2090-07-31 16:45:26','2076-07-10 09:11:06.385','57c69bc6-dddd-0975-e932-a7b5173a1304')	EB1D
+[-28,100]	3675466147	{	-146685.1749	h	3.6676044396877755e142	('2017-10-25','2100-02-28 18:07:18','2055-10-14 06:36:20.056','14949dae-dfa8-a124-af83-887348b2f609')	6D88
+[-23]	2514120753	(`u,	-119659.6174	w	1.3231258347475906e34	('2141-04-06','2074-08-10 06:25:12','1976-12-04 18:31:55.745','86a9b3c1-4593-4d56-7762-3aa1dd22cbbf')	AD43
+[11,-36]	3308237300	\N	171205.1896	\N	5.634708707075817e195	('1974-10-31','1993-12-24 09:38:45','2038-07-15 05:22:51.805','63d999b8-8cca-e237-c4a4-4dd7d0096f65')	609E
+[39]	1614362420	`4A8P	157144.0630	o	-1.1843143253872814e-255	('2147-08-18','2072-09-28 18:27:27','2073-07-10 12:19:58.146','6483f5c0-8733-364c-4fa0-9948d32e8903')	A886
+[48,-120]	3848918261	1<Lu3	91487.2852	h	-1.9300793134783347e263	('2050-12-04','2076-04-05 09:33:05','2103-12-13 23:48:44.066','e522b794-b8fa-3f11-003b-3b6b088ff941')	556E
+[55]	3047524030	li&lF	93462.3661	h	2.8979254388809897e54	('1976-01-10','1987-07-14 00:25:51','2021-11-19 04:44:08.986','486e5b26-5fe8-fe3e-12ef-09aee40643e0')	9E75
+[100,-42]	3999367674		-112975.9852	h	2.658098863752086e-160	('2081-05-13','2071-08-07 13:34:33','1980-11-11 12:00:44.669','9754e8ac-5145-befb-63d9-a12dd1cf1f3a')	DF63
 -
diff --git a/tests/queries/0_stateless/01125_generate_random_qoega.reference b/tests/queries/0_stateless/01125_generate_random_qoega.reference
index af3f8c99896..22bc4946401 100644
--- a/tests/queries/0_stateless/01125_generate_random_qoega.reference
+++ b/tests/queries/0_stateless/01125_generate_random_qoega.reference
@@ -1 +1 @@
-100	663736399314727673
+100	9702509002514908721
diff --git a/tests/queries/0_stateless/01128_generate_random_nested.reference b/tests/queries/0_stateless/01128_generate_random_nested.reference
index 6d2e90d8193..12701aed1ab 100644
--- a/tests/queries/0_stateless/01128_generate_random_nested.reference
+++ b/tests/queries/0_stateless/01128_generate_random_nested.reference
@@ -1,2 +1,2 @@
-100	12122376849981951205
-109	6180823897498688294
+100	8533268631048830017
+99	923254289621389072
diff --git a/tests/queries/0_stateless/01569_query_profiler_big_query_id.reference b/tests/queries/0_stateless/01569_query_profiler_big_query_id.reference
new file mode 100644
index 00000000000..0d66ea1aee9
--- /dev/null
+++ b/tests/queries/0_stateless/01569_query_profiler_big_query_id.reference
@@ -0,0 +1,2 @@
+0
+1
diff --git a/tests/queries/0_stateless/01569_query_profiler_big_query_id.sh b/tests/queries/0_stateless/01569_query_profiler_big_query_id.sh
new file mode 100755
index 00000000000..98e85e9b196
--- /dev/null
+++ b/tests/queries/0_stateless/01569_query_profiler_big_query_id.sh
@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+
+CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+# shellcheck source=../shell_config.sh
+. "$CURDIR"/../shell_config.sh
+
+query_id="aggregating_merge_tree_simple_aggregate_function_string_query100_profile100_$CLICKHOUSE_DATABASE"
+${CLICKHOUSE_CLIENT} --query="select sleep(1)" --query_id="$query_id" --query_profiler_real_time_period_ns=10000000
+${CLICKHOUSE_CLIENT} --query="system flush logs"
+${CLICKHOUSE_CLIENT} --query="select count(*) > 1 from system.trace_log where query_id = '$query_id'"
+
diff --git a/tests/queries/0_stateless/01666_gcd_ubsan.reference b/tests/queries/0_stateless/01666_gcd_ubsan.reference
index af041bdcbde..37b1968542e 100644
--- a/tests/queries/0_stateless/01666_gcd_ubsan.reference
+++ b/tests/queries/0_stateless/01666_gcd_ubsan.reference
@@ -5,8 +5,10 @@ SELECT gcd(-9223372036854775808, 9223372036854775807); -- { serverError 407 }
 SELECT gcd(-9223372036854775807, 9223372036854775808); -- { serverError 407 }
 SELECT gcd(9223372036854775808, -1); -- { serverError 407 }
 SELECT lcm(-170141183460469231731687303715884105728, -170141183460469231731687303715884105728); -- { serverError 43 }
-SELECT lcm(toInt128(-170141183460469231731687303715884105728), toInt128(-170141183460469231731687303715884105728)); -- { serverError 407 }
-SELECT lcm(toInt128(-170141183460469231731687303715884105720), toInt128(-170141183460469231731687303715884105720)); -- { serverError 407 }
+SELECT lcm(toInt128(-170141183460469231731687303715884105728), toInt128(-170141183460469231731687303715884105728));
+170141183460469231722463931679029329921
+SELECT lcm(toInt128(-170141183460469231731687303715884105720), toInt128(-170141183460469231731687303715884105720));
+170141183460469231722463931679029329921
 SELECT lcm(toInt128('-170141183460469231731687303715884105720'), toInt128('-170141183460469231731687303715884105720'));
 170141183460469231731687303715884105720
 SELECT gcd(-9223372036854775806, -9223372036854775806);
diff --git a/tests/queries/0_stateless/01666_gcd_ubsan.sql b/tests/queries/0_stateless/01666_gcd_ubsan.sql
index a1f501cda0b..da41022ddeb 100644
--- a/tests/queries/0_stateless/01666_gcd_ubsan.sql
+++ b/tests/queries/0_stateless/01666_gcd_ubsan.sql
@@ -5,7 +5,7 @@ SELECT gcd(-9223372036854775808, 9223372036854775807); -- { serverError 407 }
 SELECT gcd(-9223372036854775807, 9223372036854775808); -- { serverError 407 }
 SELECT gcd(9223372036854775808, -1); -- { serverError 407 }
 SELECT lcm(-170141183460469231731687303715884105728, -170141183460469231731687303715884105728); -- { serverError 43 }
-SELECT lcm(toInt128(-170141183460469231731687303715884105728), toInt128(-170141183460469231731687303715884105728)); -- { serverError 407 }
-SELECT lcm(toInt128(-170141183460469231731687303715884105720), toInt128(-170141183460469231731687303715884105720)); -- { serverError 407 }
+SELECT lcm(toInt128(-170141183460469231731687303715884105728), toInt128(-170141183460469231731687303715884105728));
+SELECT lcm(toInt128(-170141183460469231731687303715884105720), toInt128(-170141183460469231731687303715884105720));
 SELECT lcm(toInt128('-170141183460469231731687303715884105720'), toInt128('-170141183460469231731687303715884105720'));
 SELECT gcd(-9223372036854775806, -9223372036854775806);
diff --git a/tests/queries/0_stateless/01666_lcm_ubsan.reference b/tests/queries/0_stateless/01666_lcm_ubsan.reference
index d8ed13191d3..bd1972e8a6d 100644
--- a/tests/queries/0_stateless/01666_lcm_ubsan.reference
+++ b/tests/queries/0_stateless/01666_lcm_ubsan.reference
@@ -5,8 +5,10 @@ SELECT lcm(-9223372036854775808, 9223372036854775807); -- { serverError 407 }
 SELECT lcm(-9223372036854775807, 9223372036854775808); -- { serverError 407 }
 SELECT lcm(9223372036854775808, -1); -- { serverError 407 }
 SELECT lcm(-170141183460469231731687303715884105728, -170141183460469231731687303715884105728); -- { serverError 43 }
-SELECT lcm(toInt128(-170141183460469231731687303715884105728), toInt128(-170141183460469231731687303715884105728)); -- { serverError 407 }
-SELECT lcm(toInt128(-170141183460469231731687303715884105720), toInt128(-170141183460469231731687303715884105720)); -- { serverError 407 }
+SELECT lcm(toInt128(-170141183460469231731687303715884105728), toInt128(-170141183460469231731687303715884105728));
+170141183460469231722463931679029329921
+SELECT lcm(toInt128(-170141183460469231731687303715884105720), toInt128(-170141183460469231731687303715884105720));
+170141183460469231722463931679029329921
 SELECT lcm(toInt128('-170141183460469231731687303715884105720'), toInt128('-170141183460469231731687303715884105720'));
 170141183460469231731687303715884105720
 SELECT lcm(-9223372036854775806, -9223372036854775806);
diff --git a/tests/queries/0_stateless/01666_lcm_ubsan.sql b/tests/queries/0_stateless/01666_lcm_ubsan.sql
index b3b869c80ed..8ebdf148a65 100644
--- a/tests/queries/0_stateless/01666_lcm_ubsan.sql
+++ b/tests/queries/0_stateless/01666_lcm_ubsan.sql
@@ -5,7 +5,7 @@ SELECT lcm(-9223372036854775808, 9223372036854775807); -- { serverError 407 }
 SELECT lcm(-9223372036854775807, 9223372036854775808); -- { serverError 407 }
 SELECT lcm(9223372036854775808, -1); -- { serverError 407 }
 SELECT lcm(-170141183460469231731687303715884105728, -170141183460469231731687303715884105728); -- { serverError 43 }
-SELECT lcm(toInt128(-170141183460469231731687303715884105728), toInt128(-170141183460469231731687303715884105728)); -- { serverError 407 }
-SELECT lcm(toInt128(-170141183460469231731687303715884105720), toInt128(-170141183460469231731687303715884105720)); -- { serverError 407 }
+SELECT lcm(toInt128(-170141183460469231731687303715884105728), toInt128(-170141183460469231731687303715884105728));
+SELECT lcm(toInt128(-170141183460469231731687303715884105720), toInt128(-170141183460469231731687303715884105720));
 SELECT lcm(toInt128('-170141183460469231731687303715884105720'), toInt128('-170141183460469231731687303715884105720'));
 SELECT lcm(-9223372036854775806, -9223372036854775806);
diff --git a/tests/queries/0_stateless/01720_type_map_and_casts.reference b/tests/queries/0_stateless/01720_type_map_and_casts.reference
index 590bdedd7f2..760624d7f40 100644
--- a/tests/queries/0_stateless/01720_type_map_and_casts.reference
+++ b/tests/queries/0_stateless/01720_type_map_and_casts.reference
@@ -32,7 +32,7 @@ Map(UUID, UInt16)
 {'00001192-0000-4000-8000-000000000001':1,'00001192-0000-4000-7000-000000000001':2}
 0	2	1
 Map(Int128, String)
-{-1:'a',0:'b',1234567898765432193024000:'c',-1234567898765432193024000:'d'}
+{-1:'a',0:'b',1234567898765432123456789:'c',-1234567898765432123456789:'d'}
 a	b	c	d
 
 a
diff --git a/tests/queries/0_stateless/01720_type_map_and_casts.sql b/tests/queries/0_stateless/01720_type_map_and_casts.sql
index d7991999ef7..f03773d9084 100644
--- a/tests/queries/0_stateless/01720_type_map_and_casts.sql
+++ b/tests/queries/0_stateless/01720_type_map_and_casts.sql
@@ -65,15 +65,15 @@ CREATE TABLE table_map_with_key_integer (d DATE, m Map(Int128, String))
 ENGINE = MergeTree() ORDER BY d;
 
 
-INSERT INTO table_map_with_key_integer SELECT '2020-01-01', map(-1, 'a', 0, 'b', toInt128(1234567898765432123456789), 'c', toInt128(-1234567898765432123456789), 'd');
+INSERT INTO table_map_with_key_integer SELECT '2020-01-01', map(-1, 'a', 0, 'b', toInt128('1234567898765432123456789'), 'c', toInt128('-1234567898765432123456789'), 'd');
 
 SELECT 'Map(Int128, String)';
 
 SELECT m FROM table_map_with_key_integer;
-SELECT m[toInt128(-1)], m[toInt128(0)], m[toInt128(1234567898765432123456789)], m[toInt128(-1234567898765432123456789)] FROM table_map_with_key_integer;
+SELECT m[toInt128(-1)], m[toInt128(0)], m[toInt128('1234567898765432123456789')], m[toInt128('-1234567898765432123456789')] FROM table_map_with_key_integer;
 SELECT m[toInt128(number - 2)] FROM table_map_with_key_integer ARRAY JOIN [0, 1, 2, 3] AS number;
 
-SELECT m[-1], m[0], m[toInt128(1234567898765432123456789)], m[toInt128(-1234567898765432123456789)] FROM table_map_with_key_integer;
+SELECT m[-1], m[0], m[toInt128('1234567898765432123456789')], m[toInt128('-1234567898765432123456789')] FROM table_map_with_key_integer;
 SELECT m[toUInt64(0)], m[toInt64(0)], m[toUInt8(0)], m[toUInt16(0)] FROM table_map_with_key_integer;
 
 DROP TABLE IF EXISTS table_map_with_key_integer;
diff --git a/tests/queries/0_stateless/01798_uniq_theta_sketch.reference b/tests/queries/0_stateless/01798_uniq_theta_sketch.reference
new file mode 100644
index 00000000000..214d581f4b2
--- /dev/null
+++ b/tests/queries/0_stateless/01798_uniq_theta_sketch.reference
@@ -0,0 +1,230 @@
+uniqThetaSketch many agrs
+10	10	100	100	1000	1000
+17	10	10	100	100	610	610	766
+52	10	10	100	100	608	608	766
+5	10	10	100	100	608	608	765
+9	10	10	100	100	608	608	765
+13	10	10	100	100	607	607	765
+46	10	10	100	100	607	607	765
+48	10	10	100	100	609	609	765
+50	10	10	100	100	608	608	765
+54	10	10	100	100	609	609	765
+56	10	10	100	100	608	608	765
+uniqThetaSketch distinct
+123
+143
+uniqThetaSketch arrays
+2
+3
+3
+uniqThetaSketch complex types
+3
+3
+3
+3
+3
+3
+3
+3
+3
+uniqThetaSketch decimals
+(0,0,0)
+(101,101,101)
+uniqThetaSketch remove injective
+SELECT uniqThetaSketch(x)
+FROM 
+(
+    SELECT number % 2 AS x
+    FROM numbers(10)
+)
+SELECT uniqThetaSketch(x + y)
+FROM 
+(
+    SELECT
+        number % 2 AS x,
+        number % 3 AS y
+    FROM numbers(10)
+)
+SELECT uniqThetaSketch(x)
+FROM 
+(
+    SELECT number % 2 AS x
+    FROM numbers(10)
+)
+SELECT uniqThetaSketch(x)
+FROM 
+(
+    SELECT number % 2 AS x
+    FROM numbers(10)
+)
+SELECT uniqThetaSketch(x)
+FROM 
+(
+    SELECT number % 2 AS x
+    FROM numbers(10)
+)
+SELECT uniqThetaSketch(x)
+FROM 
+(
+    SELECT number % 2 AS x
+    FROM numbers(10)
+)
+SELECT uniqThetaSketch(x)
+FROM 
+(
+    SELECT number % 2 AS x
+    FROM numbers(10)
+)
+SELECT uniqThetaSketch(x + y)
+FROM 
+(
+    SELECT
+        number % 2 AS x,
+        number % 3 AS y
+    FROM numbers(10)
+)
+SELECT uniqThetaSketch(-x)
+FROM 
+(
+    SELECT number % 2 AS x
+    FROM numbers(10)
+)
+SELECT uniqThetaSketch(bitNot(x))
+FROM 
+(
+    SELECT number % 2 AS x
+    FROM numbers(10)
+)
+SELECT uniqThetaSketch(bitNot(-x))
+FROM 
+(
+    SELECT number % 2 AS x
+    FROM numbers(10)
+)
+SELECT uniqThetaSketch(-bitNot(-x))
+FROM 
+(
+    SELECT number % 2 AS x
+    FROM numbers(10)
+)
+1000	1000
+2014-06-01	1000	1000
+1000	1000
+2014-06-01	1000	1000
+2014-06-01	0	0	7	7
+2014-06-01	0	1	7	7
+2014-06-01	0	2	7	7
+2014-06-01	0	3	7	7
+2014-06-01	0	4	7	7
+2014-06-01	0	5	7	7
+2014-06-01	0	6	7	7
+2014-06-01	0	7	7	7
+2014-06-01	0	8	7	7
+2014-06-01	0	9	7	7
+2014-06-01	1	10	7	7
+2014-06-01	1	11	7	7
+2014-06-01	1	12	7	7
+2014-06-01	1	13	7	7
+2014-06-01	1	14	7	7
+2014-06-01	1	15	7	7
+2014-06-01	1	16	7	7
+2014-06-01	1	17	7	7
+2014-06-01	1	18	7	7
+2014-06-01	1	19	7	7
+2014-06-01	2	20	7	7
+2014-06-01	2	21	7	7
+2014-06-01	2	22	7	7
+2014-06-01	2	23	7	7
+2014-06-01	2	24	7	7
+2014-06-01	2	25	7	7
+2014-06-01	2	26	7	7
+2014-06-01	2	27	7	7
+2014-06-01	2	28	7	7
+2014-06-01	2	29	7	7
+2014-06-01	3	30	7	7
+2014-06-01	3	31	7	7
+2014-06-01	3	32	7	7
+2014-06-01	3	33	7	7
+2014-06-01	3	34	7	7
+2014-06-01	3	35	7	7
+2014-06-01	3	36	7	7
+2014-06-01	3	37	7	7
+2014-06-01	3	38	7	7
+2014-06-01	3	39	7	7
+2014-06-01	4	40	7	7
+2014-06-01	4	41	7	7
+2014-06-01	4	42	7	7
+2014-06-01	4	43	7	7
+2014-06-01	4	44	7	7
+2014-06-01	4	45	7	7
+2014-06-01	4	46	7	7
+2014-06-01	4	47	7	7
+2014-06-01	4	48	7	7
+2014-06-01	4	49	7	7
+2014-06-01	5	50	7	7
+2014-06-01	5	51	7	7
+2014-06-01	5	52	7	7
+2014-06-01	5	53	7	7
+2014-06-01	5	54	7	7
+2014-06-01	5	55	7	7
+2014-06-01	5	56	7	7
+2014-06-01	5	57	7	7
+2014-06-01	5	58	7	7
+2014-06-01	5	59	7	7
+2014-06-01	6	60	7	7
+2014-06-01	6	61	7	7
+2014-06-01	6	62	7	7
+2014-06-01	6	63	7	7
+2014-06-01	6	64	7	7
+2014-06-01	6	65	7	7
+2014-06-01	6	66	7	7
+2014-06-01	6	67	7	7
+2014-06-01	6	68	7	7
+2014-06-01	6	69	7	7
+2014-06-01	7	70	7	7
+2014-06-01	7	71	7	7
+2014-06-01	7	72	7	7
+2014-06-01	7	73	7	7
+2014-06-01	7	74	7	7
+2014-06-01	7	75	7	7
+2014-06-01	7	76	7	7
+2014-06-01	7	77	7	7
+2014-06-01	7	78	7	7
+2014-06-01	7	79	7	7
+2014-06-01	8	80	7	7
+2014-06-01	8	81	7	7
+2014-06-01	8	82	7	7
+2014-06-01	8	83	7	7
+2014-06-01	8	84	7	7
+2014-06-01	8	85	7	7
+2014-06-01	8	86	7	7
+2014-06-01	8	87	7	7
+2014-06-01	8	88	7	7
+2014-06-01	8	89	7	7
+2014-06-01	9	90	7	7
+2014-06-01	9	91	7	7
+2014-06-01	9	92	7	7
+2014-06-01	9	93	7	7
+2014-06-01	9	94	7	7
+2014-06-01	9	95	7	7
+2014-06-01	9	96	7	7
+2014-06-01	9	97	7	7
+2014-06-01	9	98	7	7
+2014-06-01	9	99	7	7
+2014-06-01	0	7	7
+2014-06-01	1	7	7
+2014-06-01	2	7	7
+2014-06-01	3	7	7
+2014-06-01	4	7	7
+2014-06-01	5	7	7
+2014-06-01	6	7	7
+2014-06-01	7	7	7
+2014-06-01	8	7	7
+2014-06-01	9	7	7
+2014-06-01	7	7
+0	333333	53	53
+1	333333	53	53
+2	333333	53	53
+0	333333	53	53
+1	333333	53	53
+2	333333	53	53
diff --git a/tests/queries/0_stateless/01798_uniq_theta_sketch.sql b/tests/queries/0_stateless/01798_uniq_theta_sketch.sql
new file mode 100644
index 00000000000..0093eb4c345
--- /dev/null
+++ b/tests/queries/0_stateless/01798_uniq_theta_sketch.sql
@@ -0,0 +1,211 @@
+SELECT 'uniqThetaSketch many agrs';
+
+SELECT
+    uniqThetaSketch(x), uniqThetaSketch((x)), uniqThetaSketch(x, y), uniqThetaSketch((x, y)), uniqThetaSketch(x, y, z), uniqThetaSketch((x, y, z))
+FROM
+(
+    SELECT
+        number % 10 AS x,
+        intDiv(number, 10) % 10 AS y,
+        toString(intDiv(number, 100) % 10) AS z
+    FROM system.numbers LIMIT 1000
+);
+
+
+SELECT k,
+    uniqThetaSketch(x), uniqThetaSketch((x)), uniqThetaSketch(x, y), uniqThetaSketch((x, y)), uniqThetaSketch(x, y, z), uniqThetaSketch((x, y, z)),
+    count() AS c
+FROM
+(
+    SELECT
+        (number + 0x8ffcbd8257219a26) * 0x66bb3430c06d2353 % 131 AS k,
+        number % 10 AS x,
+        intDiv(number, 10) % 10 AS y,
+        toString(intDiv(number, 100) % 10) AS z
+    FROM system.numbers LIMIT 100000
+)
+GROUP BY k
+ORDER BY c DESC, k ASC
+LIMIT 10;
+
+
+SELECT 'uniqThetaSketch distinct';
+
+SET count_distinct_implementation = 'uniqThetaSketch';
+SELECT count(DISTINCT x) FROM (SELECT number % 123 AS x FROM system.numbers LIMIT 1000);
+SELECT count(DISTINCT x, y) FROM (SELECT number % 11 AS x, number % 13 AS y FROM system.numbers LIMIT 1000);
+
+
+SELECT 'uniqThetaSketch arrays';
+
+SELECT uniqThetaSketchArray([0, 1, 1], [0, 1, 1], [0, 1, 1]);
+SELECT uniqThetaSketchArray([0, 1, 1], [0, 1, 1], [0, 1, 0]);
+SELECT uniqThetaSketch(x) FROM (SELECT arrayJoin([[1, 2], [1, 2], [1, 2, 3], []]) AS x);
+
+
+SELECT 'uniqThetaSketch complex types';
+
+SELECT uniqThetaSketch(x) FROM (SELECT arrayJoin([[], ['a'], ['a', 'b'], []]) AS x);
+SELECT uniqThetaSketch(x) FROM (SELECT arrayJoin([[[]], [['a', 'b']], [['a'], ['b']], [['a', 'b']]]) AS x);
+SELECT uniqThetaSketch(x, x) FROM (SELECT arrayJoin([[], ['a'], ['a', 'b'], []]) AS x);
+SELECT uniqThetaSketch(x, arrayMap(elem -> [elem, elem], x)) FROM (SELECT arrayJoin([[], ['a'], ['a', 'b'], []]) AS x);
+SELECT uniqThetaSketch(x, toString(x)) FROM (SELECT arrayJoin([[], ['a'], ['a', 'b'], []]) AS x);
+SELECT uniqThetaSketch((x, x)) FROM (SELECT arrayJoin([[], ['a'], ['a', 'b'], []]) AS x);
+SELECT uniqThetaSketch((x, arrayMap(elem -> [elem, elem], x))) FROM (SELECT arrayJoin([[], ['a'], ['a', 'b'], []]) AS x);
+SELECT uniqThetaSketch((x, toString(x))) FROM (SELECT arrayJoin([[], ['a'], ['a', 'b'], []]) AS x);
+SELECT uniqThetaSketch(x) FROM (SELECT arrayJoin([[], ['a'], ['a', NULL, 'b'], []]) AS x);
+
+
+SELECT 'uniqThetaSketch decimals';
+
+DROP TABLE IF EXISTS decimal;
+CREATE TABLE decimal
+(
+    a Decimal32(4),
+    b Decimal64(8),
+    c Decimal128(8)
+) ENGINE = Memory;
+
+SELECT (uniqThetaSketch(a), uniqThetaSketch(b), uniqThetaSketch(c))
+FROM (SELECT * FROM decimal ORDER BY a);
+
+INSERT INTO decimal (a, b, c)
+SELECT toDecimal32(number - 50, 4), toDecimal64(number - 50, 8) / 3, toDecimal128(number - 50, 8) / 5
+FROM system.numbers LIMIT 101;
+
+SELECT (uniqThetaSketch(a), uniqThetaSketch(b), uniqThetaSketch(c))
+FROM (SELECT * FROM decimal ORDER BY a);
+
+DROP TABLE decimal;
+
+
+SELECT 'uniqThetaSketch remove injective';
+
+set optimize_injective_functions_inside_uniq = 1;
+
+EXPLAIN SYNTAX select uniqThetaSketch(x) from (select number % 2 as x from numbers(10));
+EXPLAIN SYNTAX select uniqThetaSketch(x + y) from (select number % 2 as x, number % 3 y from numbers(10));
+EXPLAIN SYNTAX select uniqThetaSketch(-x) from (select number % 2 as x from numbers(10));
+EXPLAIN SYNTAX select uniqThetaSketch(bitNot(x)) from (select number % 2 as x from numbers(10));
+EXPLAIN SYNTAX select uniqThetaSketch(bitNot(-x)) from (select number % 2 as x from numbers(10));
+EXPLAIN SYNTAX select uniqThetaSketch(-bitNot(-x)) from (select number % 2 as x from numbers(10));
+
+set optimize_injective_functions_inside_uniq = 0;
+
+EXPLAIN SYNTAX select uniqThetaSketch(x) from (select number % 2 as x from numbers(10));
+EXPLAIN SYNTAX select uniqThetaSketch(x + y) from (select number % 2 as x, number % 3 y from numbers(10));
+EXPLAIN SYNTAX select uniqThetaSketch(-x) from (select number % 2 as x from numbers(10));
+EXPLAIN SYNTAX select uniqThetaSketch(bitNot(x)) from (select number % 2 as x from numbers(10));
+EXPLAIN SYNTAX select uniqThetaSketch(bitNot(-x)) from (select number % 2 as x from numbers(10));
+EXPLAIN SYNTAX select uniqThetaSketch(-bitNot(-x)) from (select number % 2 as x from numbers(10));
+
+
+DROP TABLE IF EXISTS stored_aggregates;
+
+-- simple
+CREATE TABLE stored_aggregates
+(
+    d Date,
+    Uniq AggregateFunction(uniq, UInt64),
+    UniqThetaSketch AggregateFunction(uniqThetaSketch, UInt64)
+)
+ENGINE = AggregatingMergeTree(d, d, 8192);
+
+INSERT INTO stored_aggregates
+SELECT
+    toDate('2014-06-01') AS d,
+    uniqState(number) AS Uniq,
+    uniqThetaSketchState(number) AS UniqThetaSketch
+FROM
+(
+    SELECT * FROM system.numbers LIMIT 1000
+);
+
+SELECT uniqMerge(Uniq), uniqThetaSketchMerge(UniqThetaSketch) FROM stored_aggregates;
+
+SELECT d, uniqMerge(Uniq), uniqThetaSketchMerge(UniqThetaSketch) FROM stored_aggregates GROUP BY d ORDER BY d;
+
+OPTIMIZE TABLE stored_aggregates;
+
+SELECT uniqMerge(Uniq), uniqThetaSketchMerge(UniqThetaSketch) FROM stored_aggregates;
+
+SELECT d, uniqMerge(Uniq), uniqThetaSketchMerge(UniqThetaSketch) FROM stored_aggregates GROUP BY d ORDER BY d;
+
+DROP TABLE stored_aggregates;
+
+-- complex
+CREATE TABLE stored_aggregates
+(
+	d	Date,
+	k1 	UInt64,
+	k2 	String,
+	Uniq 			AggregateFunction(uniq, UInt64),
+    UniqThetaSketch	AggregateFunction(uniqThetaSketch, UInt64)
+)
+ENGINE = AggregatingMergeTree(d, (d, k1, k2), 8192);
+
+INSERT INTO stored_aggregates
+SELECT
+	toDate('2014-06-01') AS d,
+	intDiv(number, 100) AS k1,
+	toString(intDiv(number, 10)) AS k2,
+	uniqState(toUInt64(number % 7)) AS Uniq,
+    uniqThetaSketchState(toUInt64(number % 7)) AS UniqThetaSketch
+FROM
+(
+	SELECT * FROM system.numbers LIMIT 1000
+)
+GROUP BY d, k1, k2
+ORDER BY d, k1, k2;
+
+SELECT d, k1, k2,
+	uniqMerge(Uniq), uniqThetaSketchMerge(UniqThetaSketch)
+FROM stored_aggregates
+GROUP BY d, k1, k2
+ORDER BY d, k1, k2;
+
+SELECT d, k1,
+	uniqMerge(Uniq), uniqThetaSketchMerge(UniqThetaSketch)
+FROM stored_aggregates
+GROUP BY d, k1
+ORDER BY d, k1;
+
+SELECT d,
+	uniqMerge(Uniq), uniqThetaSketchMerge(UniqThetaSketch)
+FROM stored_aggregates
+GROUP BY d
+ORDER BY d;
+
+DROP TABLE stored_aggregates;
+
+---- sum + uniq with more data
+drop table if exists summing_merge_tree_null;
+drop table if exists summing_merge_tree_aggregate_function;
+create table summing_merge_tree_null (
+    d materialized today(),
+    k UInt64,
+    c UInt64,
+    u UInt64
+) engine=Null;
+
+create materialized view summing_merge_tree_aggregate_function (
+    d Date,
+    k UInt64,
+    c UInt64,
+    un AggregateFunction(uniq, UInt64),
+    ut AggregateFunction(uniqThetaSketch, UInt64)
+) engine=SummingMergeTree(d, k, 8192)
+as select d, k, sum(c) as c, uniqState(u) as un, uniqThetaSketchState(u) as ut
+from summing_merge_tree_null
+group by d, k;
+
+-- prime number 53 to avoid resonanse between %3 and %53
+insert into summing_merge_tree_null select number % 3, 1, number % 53 from numbers(999999);
+
+select k, sum(c), uniqMerge(un), uniqThetaSketchMerge(ut) from summing_merge_tree_aggregate_function group by k order by k;
+optimize table summing_merge_tree_aggregate_function;
+select k, sum(c), uniqMerge(un), uniqThetaSketchMerge(ut) from summing_merge_tree_aggregate_function group by k order by k;
+
+drop table summing_merge_tree_aggregate_function;
+drop table summing_merge_tree_null;
+
diff --git a/tests/queries/0_stateless/01799_long_uniq_theta_sketch.reference b/tests/queries/0_stateless/01799_long_uniq_theta_sketch.reference
new file mode 100644
index 00000000000..c3f96cab493
--- /dev/null
+++ b/tests/queries/0_stateless/01799_long_uniq_theta_sketch.reference
@@ -0,0 +1,219 @@
+uniqThetaSketch
+1	1
+3	1
+6	1
+7	1
+9	1
+11	1
+14	1
+17	1
+19	1
+20	2
+26	1
+31	1
+35	1
+36	1
+0	162
+1	162
+3	162
+6	162
+7	163
+9	163
+10	81
+11	163
+13	162
+14	162
+17	162
+19	162
+20	162
+21	162
+22	162
+26	162
+31	162
+35	162
+36	162
+0	55018
+1	54020
+3	53774
+6	53947
+7	53839
+9	54408
+10	26876
+11	54985
+13	53479
+14	53516
+17	53331
+19	53680
+20	54211
+21	53054
+22	54690
+26	53716
+31	54139
+35	52331
+36	53766
+uniqThetaSketch round(float)
+0.125	1
+0.5	1
+0.05	1
+0.143	1
+0.056	1
+0.048	2
+0.083	1
+0.25	1
+0.1	1
+0.028	1
+0.027	1
+0.031	1
+0.067	1
+0.037	1
+0.045	162
+0.125	163
+0.5	162
+0.05	162
+0.143	162
+0.091	81
+0.056	162
+0.048	162
+0.083	163
+0.25	162
+1	162
+0.1	163
+0.028	162
+0.027	162
+0.031	162
+0.067	162
+0.043	162
+0.037	162
+0.071	162
+0.045	53054
+0.125	53839
+0.5	54020
+0.05	53680
+0.143	53947
+0.091	26876
+0.056	53331
+0.048	54211
+0.083	54985
+0.25	53774
+1	55018
+0.1	54408
+0.028	52331
+0.027	53766
+0.031	54139
+0.067	53516
+0.043	54690
+0.037	53716
+0.071	53479
+uniqThetaSketch round(toFloat32())
+0.5	1
+0.05	1
+0.25	1
+0.048	2
+0.083	1
+0.125	1
+0.031	1
+0.143	1
+0.028	1
+0.067	1
+0.027	1
+0.056	1
+0.037	1
+0.1	1
+0.5	162
+0.05	162
+0.25	162
+0.048	162
+0.091	81
+0.043	162
+0.071	162
+0.083	163
+0.125	163
+0.031	162
+0.143	162
+0.028	162
+0.067	162
+0.045	162
+0.027	162
+0.056	162
+0.037	162
+0.1	163
+1	162
+0.5	54020
+0.05	53680
+0.25	53774
+0.048	54211
+0.091	26876
+0.043	54690
+0.071	53479
+0.083	54985
+0.125	53839
+0.031	54139
+0.143	53947
+0.028	52331
+0.067	53516
+0.045	53054
+0.027	53766
+0.056	53331
+0.037	53716
+0.1	54408
+1	55018
+uniqThetaSketch IPv4NumToString
+1	1
+3	1
+6	1
+7	1
+9	1
+11	1
+14	1
+17	1
+19	1
+20	2
+26	1
+31	1
+35	1
+36	1
+0	162
+1	162
+3	162
+6	162
+7	163
+9	163
+10	81
+11	163
+13	162
+14	162
+17	162
+19	162
+20	162
+21	162
+22	162
+26	162
+31	162
+35	162
+36	162
+0	54929
+1	53802
+3	54706
+6	54700
+7	53592
+9	54036
+10	27392
+11	53768
+13	54566
+14	53104
+17	54243
+19	55003
+20	53398
+21	53831
+22	54603
+26	54607
+31	54012
+35	54826
+36	54910
+uniqThetaSketch remote()
+1
+uniqThetaSketch precise
+10000000
+10021957
+10021969
+10094819
diff --git a/tests/queries/0_stateless/01799_long_uniq_theta_sketch.sql b/tests/queries/0_stateless/01799_long_uniq_theta_sketch.sql
new file mode 100644
index 00000000000..572c26634bb
--- /dev/null
+++ b/tests/queries/0_stateless/01799_long_uniq_theta_sketch.sql
@@ -0,0 +1,35 @@
+SELECT 'uniqThetaSketch';
+
+SELECT Y, uniqThetaSketch(X) FROM (SELECT number AS X, (3*X*X - 7*X + 11) % 37 AS Y FROM system.numbers LIMIT 15) GROUP BY Y;
+SELECT Y, uniqThetaSketch(X) FROM (SELECT number AS X, (3*X*X - 7*X + 11) % 37 AS Y FROM system.numbers LIMIT 3000) GROUP BY Y;
+SELECT Y, uniqThetaSketch(X) FROM (SELECT number AS X, (3*X*X - 7*X + 11) % 37 AS Y FROM system.numbers LIMIT 1000000) GROUP BY Y;
+
+SELECT 'uniqThetaSketch round(float)';
+
+SELECT Y, uniqThetaSketch(X) FROM (SELECT number AS X, round(1/(1 + (3*X*X - 7*X + 11) % 37), 3) AS Y FROM system.numbers LIMIT 15) GROUP BY Y;
+SELECT Y, uniqThetaSketch(X) FROM (SELECT number AS X, round(1/(1 + (3*X*X - 7*X + 11) % 37), 3) AS Y FROM system.numbers LIMIT 3000) GROUP BY Y;
+SELECT Y, uniqThetaSketch(X) FROM (SELECT number AS X, round(1/(1 + (3*X*X - 7*X + 11) % 37), 3) AS Y FROM system.numbers LIMIT 1000000) GROUP BY Y;
+
+SELECT 'uniqThetaSketch round(toFloat32())';
+
+SELECT Y, uniqThetaSketch(X) FROM (SELECT number AS X, round(toFloat32(1/(1 + (3*X*X - 7*X + 11) % 37)), 3) AS Y FROM system.numbers LIMIT 15) GROUP BY Y;
+SELECT Y, uniqThetaSketch(X) FROM (SELECT number AS X, round(toFloat32(1/(1 + (3*X*X - 7*X + 11) % 37)), 3) AS Y FROM system.numbers LIMIT 3000) GROUP BY Y;
+SELECT Y, uniqThetaSketch(X) FROM (SELECT number AS X, round(toFloat32(1/(1 + (3*X*X - 7*X + 11) % 37)), 3) AS Y FROM system.numbers LIMIT 1000000) GROUP BY Y;
+
+SELECT 'uniqThetaSketch IPv4NumToString';
+
+SELECT Y, uniqThetaSketch(Z) FROM (SELECT number AS X, IPv4NumToString(toUInt32(X)) AS Z, (3*X*X - 7*X + 11) % 37 AS Y FROM system.numbers LIMIT 15) GROUP BY Y;
+SELECT Y, uniqThetaSketch(Z) FROM (SELECT number AS X, IPv4NumToString(toUInt32(X)) AS Z, (3*X*X - 7*X + 11) % 37 AS Y FROM system.numbers LIMIT 3000) GROUP BY Y;
+SELECT Y, uniqThetaSketch(Z) FROM (SELECT number AS X, IPv4NumToString(toUInt32(X)) AS Z, (3*X*X - 7*X + 11) % 37 AS Y FROM system.numbers LIMIT 1000000) GROUP BY Y;
+
+SELECT 'uniqThetaSketch remote()';
+
+SELECT uniqThetaSketch(dummy) FROM remote('127.0.0.{2,3}', system.one);
+
+
+SELECT 'uniqThetaSketch precise';
+SELECT uniqExact(number) FROM numbers(1e7);
+SELECT uniqCombined(number) FROM numbers(1e7);
+SELECT uniqCombined64(number) FROM numbers(1e7);
+SELECT uniqThetaSketch(number) FROM numbers(1e7);
+
diff --git a/tests/queries/0_stateless/01848_partition_value_column.reference b/tests/queries/0_stateless/01848_partition_value_column.reference
new file mode 100644
index 00000000000..e83beda6895
--- /dev/null
+++ b/tests/queries/0_stateless/01848_partition_value_column.reference
@@ -0,0 +1,4 @@
+1
+4
+4
+1
diff --git a/tests/queries/0_stateless/01848_partition_value_column.sql b/tests/queries/0_stateless/01848_partition_value_column.sql
new file mode 100644
index 00000000000..0fc4fbe2802
--- /dev/null
+++ b/tests/queries/0_stateless/01848_partition_value_column.sql
@@ -0,0 +1,18 @@
+drop table if exists tbl;
+drop table if exists tbl2;
+
+create table tbl(dt DateTime, i int, j String, v Float64) engine MergeTree partition by (toDate(dt), i % 2, length(j)) order by i settings index_granularity = 1;
+
+insert into tbl values ('2021-04-01 00:01:02', 1, '123', 4), ('2021-04-01 01:01:02', 1, '12', 4), ('2021-04-01 02:11:02', 2, '345', 4), ('2021-04-01 04:31:02', 2, '2', 4), ('2021-04-02 00:01:02', 1, '1234', 4), ('2021-04-02 00:01:02', 2, '123', 4), ('2021-04-02 00:01:02', 3, '12', 4), ('2021-04-02 00:01:02', 4, '1', 4);
+
+select count() from tbl where _partition_value = ('2021-04-01', 1, 2) settings max_rows_to_read = 1;
+select count() from tbl where _partition_value.1 = '2021-04-01' settings max_rows_to_read = 4;
+select count() from tbl where _partition_value.2 = 0 settings max_rows_to_read = 4;
+select count() from tbl where _partition_value.3 = 4 settings max_rows_to_read = 1;
+
+create table tbl2(i int) engine MergeTree order by i;
+insert into tbl2 values (1);
+select _partition_value from tbl2; -- { serverError 16 }
+
+drop table tbl;
+drop table tbl2;
diff --git a/tests/queries/0_stateless/01864_dictionary_range_hashed_min_max_attr.reference b/tests/queries/0_stateless/01851_array_difference_decimal_overflow_ubsan.reference
similarity index 100%
rename from tests/queries/0_stateless/01864_dictionary_range_hashed_min_max_attr.reference
rename to tests/queries/0_stateless/01851_array_difference_decimal_overflow_ubsan.reference
diff --git a/tests/queries/0_stateless/01851_array_difference_decimal_overflow_ubsan.sql b/tests/queries/0_stateless/01851_array_difference_decimal_overflow_ubsan.sql
new file mode 100644
index 00000000000..ebf2efda4f1
--- /dev/null
+++ b/tests/queries/0_stateless/01851_array_difference_decimal_overflow_ubsan.sql
@@ -0,0 +1 @@
+SELECT arrayDifference([toDecimal32(100.0000991821289, 0), -2147483647]) AS x; --{serverError 407}
diff --git a/tests/queries/0_stateless/01852_dictionary_found_rate_long.reference b/tests/queries/0_stateless/01852_dictionary_found_rate_long.reference
new file mode 100644
index 00000000000..9e898591f58
--- /dev/null
+++ b/tests/queries/0_stateless/01852_dictionary_found_rate_long.reference
@@ -0,0 +1,33 @@
+simple_key_flat_dictionary_01862	1
+simple_key_flat_dictionary_01862	1
+simple_key_flat_dictionary_01862	0.67
+simple_key_direct_dictionary_01862	0
+simple_key_direct_dictionary_01862	0
+simple_key_direct_dictionary_01862	1
+simple_key_direct_dictionary_01862	0.5
+simple_key_hashed_dictionary_01862	0
+simple_key_hashed_dictionary_01862	1
+simple_key_hashed_dictionary_01862	0.5
+simple_key_sparse_hashed_dictionary_01862	0
+simple_key_sparse_hashed_dictionary_01862	1
+simple_key_sparse_hashed_dictionary_01862	0.5
+simple_key_cache_dictionary_01862	0
+simple_key_cache_dictionary_01862	1
+simple_key_cache_dictionary_01862	0.5
+complex_key_hashed_dictionary_01862	0
+complex_key_hashed_dictionary_01862	1
+complex_key_hashed_dictionary_01862	0.5
+complex_key_direct_dictionary_01862	0
+complex_key_direct_dictionary_01862	1
+complex_key_direct_dictionary_01862	0.5
+complex_key_cache_dictionary_01862	0
+complex_key_cache_dictionary_01862	1
+complex_key_cache_dictionary_01862	0.5
+simple_key_range_hashed_dictionary_01862	0
+simple_key_range_hashed_dictionary_01862	1
+simple_key_range_hashed_dictionary_01862	0.5
+ip_trie_dictionary_01862	0
+ip_trie_dictionary_01862	1
+ip_trie_dictionary_01862	0.5
+polygon_dictionary_01862	0
+polygon_dictionary_01862	0.8
diff --git a/tests/queries/0_stateless/01852_dictionary_found_rate_long.sql b/tests/queries/0_stateless/01852_dictionary_found_rate_long.sql
new file mode 100644
index 00000000000..2501e21b95e
--- /dev/null
+++ b/tests/queries/0_stateless/01852_dictionary_found_rate_long.sql
@@ -0,0 +1,309 @@
+--
+-- Simple key
+--
+
+DROP TABLE IF EXISTS simple_key_source_table_01862;
+CREATE TABLE simple_key_source_table_01862
+(
+    id UInt64,
+    value String
+) ENGINE = Memory();
+
+INSERT INTO simple_key_source_table_01862 VALUES (1, 'First');
+INSERT INTO simple_key_source_table_01862 VALUES (1, 'First');
+
+-- simple flat
+DROP DICTIONARY IF EXISTS simple_key_flat_dictionary_01862;
+CREATE DICTIONARY simple_key_flat_dictionary_01862
+(
+    id UInt64,
+    value String
+)
+PRIMARY KEY id
+SOURCE(CLICKHOUSE(HOST 'localhost' PORT tcpPort() TABLE 'simple_key_source_table_01862'))
+LAYOUT(FLAT())
+LIFETIME(MIN 0 MAX 1000);
+
+SELECT * FROM simple_key_flat_dictionary_01862 FORMAT Null;
+SELECT name, found_rate FROM system.dictionaries WHERE database = currentDatabase() AND name = 'simple_key_flat_dictionary_01862';
+SELECT * FROM simple_key_flat_dictionary_01862 WHERE id = 0 FORMAT Null;
+SELECT name, found_rate FROM system.dictionaries WHERE database = currentDatabase() AND name = 'simple_key_flat_dictionary_01862';
+SELECT dictGet('simple_key_flat_dictionary_01862', 'value', toUInt64(2)) FORMAT Null;
+SELECT name, round(found_rate, 2) FROM system.dictionaries WHERE database = currentDatabase() AND name = 'simple_key_flat_dictionary_01862';
+
+DROP DICTIONARY simple_key_flat_dictionary_01862;
+
+-- simple direct
+DROP DICTIONARY IF EXISTS simple_key_direct_dictionary_01862;
+CREATE DICTIONARY simple_key_direct_dictionary_01862
+(
+    id UInt64,
+    value String
+)
+PRIMARY KEY id
+SOURCE(CLICKHOUSE(HOST 'localhost' PORT tcpPort() TABLE 'simple_key_source_table_01862'))
+LAYOUT(DIRECT());
+
+-- check that found_rate is 0, not nan
+SELECT name, found_rate FROM system.dictionaries WHERE database = currentDatabase() AND name = 'simple_key_direct_dictionary_01862';
+SELECT * FROM simple_key_direct_dictionary_01862 FORMAT Null;
+SELECT name, found_rate FROM system.dictionaries WHERE database = currentDatabase() AND name = 'simple_key_direct_dictionary_01862';
+SELECT dictGet('simple_key_direct_dictionary_01862', 'value', toUInt64(1)) FORMAT Null;
+SELECT name, found_rate FROM system.dictionaries WHERE database = currentDatabase() AND name = 'simple_key_direct_dictionary_01862';
+SELECT dictGet('simple_key_direct_dictionary_01862', 'value', toUInt64(2)) FORMAT Null;
+SELECT name, found_rate FROM system.dictionaries WHERE database = currentDatabase() AND name = 'simple_key_direct_dictionary_01862';
+
+DROP DICTIONARY simple_key_direct_dictionary_01862;
+
+-- simple hashed
+DROP DICTIONARY IF EXISTS simple_key_hashed_dictionary_01862;
+CREATE DICTIONARY simple_key_hashed_dictionary_01862
+(
+    id UInt64,
+    value String
+)
+PRIMARY KEY id
+SOURCE(CLICKHOUSE(HOST 'localhost' PORT tcpPort() TABLE 'simple_key_source_table_01862'))
+LAYOUT(HASHED())
+LIFETIME(MIN 0 MAX 1000);
+
+SELECT name, found_rate FROM system.dictionaries WHERE database = currentDatabase() AND name = 'simple_key_hashed_dictionary_01862';
+SELECT dictGet('simple_key_hashed_dictionary_01862', 'value', toUInt64(1)) FORMAT Null;
+SELECT name, found_rate FROM system.dictionaries WHERE database = currentDatabase() AND name = 'simple_key_hashed_dictionary_01862';
+SELECT dictGet('simple_key_hashed_dictionary_01862', 'value', toUInt64(2)) FORMAT Null;
+SELECT name, found_rate FROM system.dictionaries WHERE database = currentDatabase() AND name = 'simple_key_hashed_dictionary_01862';
+
+DROP DICTIONARY simple_key_hashed_dictionary_01862;
+
+-- simple sparse_hashed
+DROP DICTIONARY IF EXISTS simple_key_sparse_hashed_dictionary_01862;
+CREATE DICTIONARY simple_key_sparse_hashed_dictionary_01862
+(
+    id UInt64,
+    value String
+)
+PRIMARY KEY id
+SOURCE(CLICKHOUSE(HOST 'localhost' PORT tcpPort() TABLE 'simple_key_source_table_01862'))
+LAYOUT(SPARSE_HASHED())
+LIFETIME(MIN 0 MAX 1000);
+
+SELECT name, found_rate FROM system.dictionaries WHERE database = currentDatabase() AND name = 'simple_key_sparse_hashed_dictionary_01862';
+SELECT dictGet('simple_key_sparse_hashed_dictionary_01862', 'value', toUInt64(1)) FORMAT Null;
+SELECT name, found_rate FROM system.dictionaries WHERE database = currentDatabase() AND name = 'simple_key_sparse_hashed_dictionary_01862';
+SELECT dictGet('simple_key_sparse_hashed_dictionary_01862', 'value', toUInt64(2)) FORMAT Null;
+SELECT name, found_rate FROM system.dictionaries WHERE database = currentDatabase() AND name = 'simple_key_sparse_hashed_dictionary_01862';
+
+DROP DICTIONARY simple_key_sparse_hashed_dictionary_01862;
+
+-- simple cache
+DROP DICTIONARY IF EXISTS simple_key_cache_dictionary_01862;
+CREATE DICTIONARY simple_key_cache_dictionary_01862
+(
+    id UInt64,
+    value String
+)
+PRIMARY KEY id
+SOURCE(CLICKHOUSE(HOST 'localhost' PORT tcpPort() TABLE 'simple_key_source_table_01862'))
+LAYOUT(CACHE(SIZE_IN_CELLS 100000))
+LIFETIME(MIN 0 MAX 1000);
+
+SELECT name, found_rate FROM system.dictionaries WHERE database = currentDatabase() AND name = 'simple_key_cache_dictionary_01862';
+SELECT toUInt64(1) as key, dictGet('simple_key_cache_dictionary_01862', 'value', key) FORMAT Null;
+SELECT name, found_rate FROM system.dictionaries WHERE database = currentDatabase() AND name = 'simple_key_cache_dictionary_01862';
+SELECT toUInt64(2) as key, dictGet('simple_key_cache_dictionary_01862', 'value', key) FORMAT Null;
+SELECT name, found_rate FROM system.dictionaries WHERE database = currentDatabase() AND name = 'simple_key_cache_dictionary_01862';
+
+DROP DICTIONARY simple_key_cache_dictionary_01862;
+
+DROP TABLE simple_key_source_table_01862;
+
+--
+-- Complex key
+--
+
+DROP TABLE IF EXISTS complex_key_source_table_01862;
+CREATE TABLE complex_key_source_table_01862
+(
+    id UInt64,
+    id_key String,
+    value String
+) ENGINE = Memory();
+
+INSERT INTO complex_key_source_table_01862 VALUES (1, 'FirstKey', 'First');
+INSERT INTO complex_key_source_table_01862 VALUES (1, 'FirstKey', 'First');
+
+-- complex hashed
+DROP DICTIONARY IF EXISTS complex_key_hashed_dictionary_01862;
+CREATE DICTIONARY complex_key_hashed_dictionary_01862
+(
+    id UInt64,
+    id_key String,
+    value String
+)
+PRIMARY KEY id, id_key
+SOURCE(CLICKHOUSE(HOST 'localhost' PORT tcpPort() TABLE 'complex_key_source_table_01862'))
+LAYOUT(COMPLEX_KEY_HASHED())
+LIFETIME(MIN 0 MAX 1000);
+
+SELECT name, found_rate FROM system.dictionaries WHERE database = currentDatabase() AND name = 'complex_key_hashed_dictionary_01862';
+SELECT dictGet('complex_key_hashed_dictionary_01862', 'value', (toUInt64(1), 'FirstKey')) FORMAT Null;
+SELECT name, found_rate FROM system.dictionaries WHERE database = currentDatabase() AND name = 'complex_key_hashed_dictionary_01862';
+SELECT dictGet('complex_key_hashed_dictionary_01862', 'value', (toUInt64(2), 'FirstKey')) FORMAT Null;
+SELECT name, found_rate FROM system.dictionaries WHERE database = currentDatabase() AND name = 'complex_key_hashed_dictionary_01862';
+
+DROP DICTIONARY complex_key_hashed_dictionary_01862;
+
+-- complex direct
+DROP DICTIONARY IF EXISTS complex_key_direct_dictionary_01862;
+CREATE DICTIONARY complex_key_direct_dictionary_01862
+(
+    id UInt64,
+    id_key String,
+    value String
+)
+PRIMARY KEY id, id_key
+SOURCE(CLICKHOUSE(HOST 'localhost' PORT tcpPort() TABLE 'complex_key_source_table_01862'))
+LAYOUT(COMPLEX_KEY_DIRECT());
+
+SELECT name, found_rate FROM system.dictionaries WHERE database = currentDatabase() AND name = 'complex_key_direct_dictionary_01862';
+SELECT dictGet('complex_key_direct_dictionary_01862', 'value', (toUInt64(1), 'FirstKey')) FORMAT Null;
+SELECT name, found_rate FROM system.dictionaries WHERE database = currentDatabase() AND name = 'complex_key_direct_dictionary_01862';
+SELECT dictGet('complex_key_direct_dictionary_01862', 'value', (toUInt64(2), 'FirstKey')) FORMAT Null;
+SELECT name, found_rate FROM system.dictionaries WHERE database = currentDatabase() AND name = 'complex_key_direct_dictionary_01862';
+
+DROP DICTIONARY complex_key_direct_dictionary_01862;
+
+-- complex cache
+DROP DICTIONARY IF EXISTS complex_key_cache_dictionary_01862;
+CREATE DICTIONARY complex_key_cache_dictionary_01862
+(
+    id UInt64,
+    id_key String,
+    value String
+)
+PRIMARY KEY id, id_key
+SOURCE(CLICKHOUSE(HOST 'localhost' PORT tcpPort() TABLE 'complex_key_source_table_01862'))
+LAYOUT(COMPLEX_KEY_CACHE(SIZE_IN_CELLS 100000))
+LIFETIME(MIN 0 MAX 1000);
+
+SELECT name, found_rate FROM system.dictionaries WHERE database = currentDatabase() AND name = 'complex_key_cache_dictionary_01862';
+SELECT dictGet('complex_key_cache_dictionary_01862', 'value', (toUInt64(1), 'FirstKey')) FORMAT Null;
+SELECT name, found_rate FROM system.dictionaries WHERE database = currentDatabase() AND name = 'complex_key_cache_dictionary_01862';
+SELECT dictGet('complex_key_cache_dictionary_01862', 'value', (toUInt64(2), 'FirstKey')) FORMAT Null;
+SELECT name, found_rate FROM system.dictionaries WHERE database = currentDatabase() AND name = 'complex_key_cache_dictionary_01862';
+
+DROP DICTIONARY complex_key_cache_dictionary_01862;
+
+DROP TABLE complex_key_source_table_01862;
+
+--
+-- Range
+--
+DROP TABLE IF EXISTS range_key_source_table_01862;
+CREATE TABLE range_key_source_table_01862
+(
+    id UInt64,
+    value String,
+    first Date,
+    last Date
+) ENGINE = Memory();
+
+INSERT INTO range_key_source_table_01862 VALUES (1, 'First', today(), today());
+INSERT INTO range_key_source_table_01862 VALUES (1, 'First', today(), today());
+
+-- simple range_hashed
+DROP DICTIONARY IF EXISTS simple_key_range_hashed_dictionary_01862;
+CREATE DICTIONARY simple_key_range_hashed_dictionary_01862
+(
+    id UInt64,
+    value String,
+    first Date,
+    last Date
+)
+PRIMARY KEY id
+SOURCE(CLICKHOUSE(HOST 'localhost' PORT tcpPort() TABLE 'range_key_source_table_01862'))
+LAYOUT(RANGE_HASHED())
+RANGE(MIN first MAX last)
+LIFETIME(MIN 0 MAX 1000);
+
+SELECT name, found_rate FROM system.dictionaries WHERE database = currentDatabase() AND name = 'simple_key_range_hashed_dictionary_01862';
+SELECT dictGet('simple_key_range_hashed_dictionary_01862', 'value', toUInt64(1), today()) FORMAT Null;
+SELECT name, found_rate FROM system.dictionaries WHERE database = currentDatabase() AND name = 'simple_key_range_hashed_dictionary_01862';
+SELECT dictGet('simple_key_range_hashed_dictionary_01862', 'value', toUInt64(2), today()) FORMAT Null;
+SELECT name, found_rate FROM system.dictionaries WHERE database = currentDatabase() AND name = 'simple_key_range_hashed_dictionary_01862';
+
+DROP DICTIONARY simple_key_range_hashed_dictionary_01862;
+
+DROP TABLE range_key_source_table_01862;
+
+--
+-- IP Trie
+--
+DROP TABLE IF EXISTS ip_trie_source_table_01862;
+CREATE TABLE ip_trie_source_table_01862
+(
+    prefix String,
+    value String
+) ENGINE = Memory();
+
+INSERT INTO ip_trie_source_table_01862 VALUES ('127.0.0.0/8', 'First');
+INSERT INTO ip_trie_source_table_01862 VALUES ('127.0.0.0/8', 'First');
+
+-- ip_trie
+DROP DICTIONARY IF EXISTS ip_trie_dictionary_01862;
+CREATE DICTIONARY ip_trie_dictionary_01862
+(
+    prefix String,
+    value String
+)
+PRIMARY KEY prefix
+SOURCE(CLICKHOUSE(HOST 'localhost' PORT tcpPort() TABLE 'ip_trie_source_table_01862'))
+LAYOUT(IP_TRIE())
+LIFETIME(MIN 0 MAX 1000);
+
+SELECT name, found_rate FROM system.dictionaries WHERE database = currentDatabase() AND name = 'ip_trie_dictionary_01862';
+SELECT dictGet('ip_trie_dictionary_01862', 'value', tuple(toIPv4('127.0.0.1'))) FORMAT Null;
+SELECT name, found_rate FROM system.dictionaries WHERE database = currentDatabase() AND name = 'ip_trie_dictionary_01862';
+SELECT dictGet('ip_trie_dictionary_01862', 'value', tuple(toIPv4('1.1.1.1'))) FORMAT Null;
+SELECT name, found_rate FROM system.dictionaries WHERE database = currentDatabase() AND name = 'ip_trie_dictionary_01862';
+
+DROP DICTIONARY ip_trie_dictionary_01862;
+
+DROP TABLE ip_trie_source_table_01862;
+
+-- Polygon
+DROP TABLE IF EXISTS polygons_01862;
+CREATE TABLE polygons_01862 (
+    key Array(Array(Array(Tuple(Float64, Float64)))),
+    name String
+) ENGINE = Memory;
+INSERT INTO polygons_01862 VALUES ([[[(3, 1), (0, 1), (0, -1), (3, -1)]]], 'Click East');
+INSERT INTO polygons_01862 VALUES ([[[(-1, 1), (1, 1), (1, 3), (-1, 3)]]], 'Click North');
+INSERT INTO polygons_01862 VALUES ([[[(-3, 1), (-3, -1), (0, -1), (0, 1)]]], 'Click South');
+INSERT INTO polygons_01862 VALUES ([[[(-1, -1), (1, -1), (1, -3), (-1, -3)]]], 'Click West');
+
+DROP TABLE IF EXISTS points_01862;
+CREATE TABLE points_01862 (x Float64, y Float64) ENGINE = Memory;
+INSERT INTO points_01862 VALUES ( 0.1,  0.0);
+INSERT INTO points_01862 VALUES (-0.1,  0.0);
+INSERT INTO points_01862 VALUES ( 0.0,  1.1);
+INSERT INTO points_01862 VALUES ( 0.0, -1.1);
+INSERT INTO points_01862 VALUES ( 3.0,  3.0);
+
+DROP DICTIONARY IF EXISTS polygon_dictionary_01862;
+CREATE DICTIONARY polygon_dictionary_01862
+(
+    key Array(Array(Array(Tuple(Float64, Float64)))),
+    name String
+)
+PRIMARY KEY key
+SOURCE(CLICKHOUSE(HOST 'localhost' PORT tcpPort() USER 'default' TABLE 'polygons_01862'))
+LIFETIME(0)
+LAYOUT(POLYGON());
+
+SELECT name, found_rate FROM system.dictionaries WHERE database = currentDatabase() AND name = 'polygon_dictionary_01862';
+SELECT tuple(x, y) as key, dictGet('polygon_dictionary_01862', 'name', key) FROM points_01862 FORMAT Null;
+SELECT name, found_rate FROM system.dictionaries WHERE database = currentDatabase() AND name = 'polygon_dictionary_01862';
+
+DROP TABLE polygons_01862;
+DROP TABLE points_01862;
diff --git a/tests/queries/0_stateless/01852_jit_if.reference b/tests/queries/0_stateless/01852_jit_if.reference
new file mode 100644
index 00000000000..907ee5cd66d
--- /dev/null
+++ b/tests/queries/0_stateless/01852_jit_if.reference
@@ -0,0 +1,7 @@
+test_jit_nonnull
+0	0	0
+1	2	1
+test_jit_nullable
+0	0	0
+1	2	1
+\N	0	0
diff --git a/tests/queries/0_stateless/01852_jit_if.sql b/tests/queries/0_stateless/01852_jit_if.sql
new file mode 100644
index 00000000000..cdfeba5b895
--- /dev/null
+++ b/tests/queries/0_stateless/01852_jit_if.sql
@@ -0,0 +1,16 @@
+SET compile_expressions = 1;
+SET min_count_to_compile_expression = 0;
+
+DROP TABLE IF EXISTS test_jit_nonnull;
+CREATE TABLE test_jit_nonnull (value UInt8) ENGINE = TinyLog;
+INSERT INTO test_jit_nonnull VALUES (0), (1);
+
+SELECT 'test_jit_nonnull';
+SELECT value, multiIf(value = 1, 2, value, 1, 0), if (value, 1, 0) FROM test_jit_nonnull;
+
+DROP TABLE IF EXISTS test_jit_nullable;
+CREATE TABLE test_jit_nullable (value Nullable(UInt8)) ENGINE = TinyLog;
+INSERT INTO test_jit_nullable VALUES (0), (1), (NULL);
+
+SELECT 'test_jit_nullable';
+SELECT value, multiIf(value = 1, 2, value, 1, 0), if (value, 1, 0) FROM test_jit_nullable;
diff --git a/tests/queries/0_stateless/01863_dictionary_cache_duplicates.reference b/tests/queries/0_stateless/01853_dictionary_cache_duplicates.reference
similarity index 100%
rename from tests/queries/0_stateless/01863_dictionary_cache_duplicates.reference
rename to tests/queries/0_stateless/01853_dictionary_cache_duplicates.reference
diff --git a/tests/queries/0_stateless/01863_dictionary_cache_duplicates.sh b/tests/queries/0_stateless/01853_dictionary_cache_duplicates.sh
similarity index 100%
rename from tests/queries/0_stateless/01863_dictionary_cache_duplicates.sh
rename to tests/queries/0_stateless/01853_dictionary_cache_duplicates.sh
diff --git a/tests/queries/0_stateless/01854_HTTP_dict_decompression.python b/tests/queries/0_stateless/01854_HTTP_dict_decompression.python
new file mode 100644
index 00000000000..98581a1e47c
--- /dev/null
+++ b/tests/queries/0_stateless/01854_HTTP_dict_decompression.python
@@ -0,0 +1,168 @@
+#!/usr/bin/env python3
+
+from http.server import SimpleHTTPRequestHandler,HTTPServer
+import socket
+import csv
+import sys
+import tempfile
+import threading
+import os
+import gzip
+import traceback
+import urllib.request
+import subprocess
+import lzma
+
+def get_local_port(host):
+    with socket.socket() as fd:
+        fd.bind((host, 0))
+        return fd.getsockname()[1]
+
+CLICKHOUSE_HOST = os.environ.get('CLICKHOUSE_HOST', '127.0.0.1')
+CLICKHOUSE_PORT_HTTP = os.environ.get('CLICKHOUSE_PORT_HTTP', '8123')
+
+#####################################################################################
+# This test starts an HTTP server and serves data to clickhouse url-engine based table.
+# The main goal of this test is checking that compress methods are working.
+# In order for it to work ip+port of http server (given below) should be
+# accessible from clickhouse server.
+#####################################################################################
+
+# IP-address of this host accessible from outside world.
+HTTP_SERVER_HOST = subprocess.check_output(['hostname', '-i']).decode('utf-8').strip()
+HTTP_SERVER_PORT = get_local_port(HTTP_SERVER_HOST)
+
+# IP address and port of the HTTP server started from this script.
+HTTP_SERVER_ADDRESS = (HTTP_SERVER_HOST, HTTP_SERVER_PORT)
+HTTP_SERVER_URL_STR = 'http://' + ':'.join(str(s) for s in HTTP_SERVER_ADDRESS) + "/"
+
+# Because we need to check content of file.csv we can create this content and avoid reading csv 
+CSV_DATA = "Hello, 1\nWorld, 2\nThis, 152\nis, 9283\ntesting, 2313213\ndata, 555\n"
+
+
+# Choose compression method 
+# (Will change during test, need to check standart data sending, to make sure that nothing broke)
+COMPRESS_METHOD = 'none'
+ADDING_ENDING = ''
+ENDINGS = ['.gz', '.xz']
+SEND_ENCODING = True
+
+def get_ch_answer(query):
+    url = os.environ.get('CLICKHOUSE_URL', 'http://{host}:{port}'.format(host=CLICKHOUSE_HOST, port=CLICKHOUSE_PORT_HTTP))
+    return urllib.request.urlopen(url, data=query.encode()).read().decode()
+
+def check_answers(query, answer):
+    ch_answer = get_ch_answer(query)
+    if ch_answer.strip() != answer.strip():
+        print("FAIL on query:", query, file=sys.stderr)
+        print("Expected answer:", answer, file=sys.stderr)
+        print("Fetched answer :", ch_answer, file=sys.stderr)
+        raise Exception("Fail on query")
+
+# Server with head method which is useful for debuging by hands
+class HttpProcessor(SimpleHTTPRequestHandler):
+    def _set_headers(self):
+        self.send_response(200)
+        if SEND_ENCODING:
+            self.send_header('Content-Encoding', COMPRESS_METHOD)
+        if COMPRESS_METHOD == 'none':
+            self.send_header('Content-Length', len(CSV_DATA.encode()))
+        else:
+            self.compress_data()
+            self.send_header('Content-Length', len(self.data))
+        self.send_header('Content-Type', 'text/csv')
+        self.end_headers()
+
+    def do_HEAD(self):
+        self._set_headers()
+        return
+
+    def compress_data(self):
+        if COMPRESS_METHOD == 'gzip':
+            self.data = gzip.compress((CSV_DATA).encode())
+        elif COMPRESS_METHOD == 'lzma':
+            self.data = lzma.compress((CSV_DATA).encode())
+        else:
+            self.data = 'WRONG CONVERSATION'.encode()
+
+
+    def do_GET(self):
+        self._set_headers()
+    
+        if COMPRESS_METHOD == 'none':
+            self.wfile.write(CSV_DATA.encode())
+        else:
+            self.wfile.write(self.data)
+        return
+
+    def log_message(self, format, *args):
+        return
+
+def start_server(requests_amount):
+    httpd = HTTPServer(HTTP_SERVER_ADDRESS, HttpProcessor)
+
+    def real_func():
+        for i in range(requests_amount):
+            httpd.handle_request()
+
+    t = threading.Thread(target=real_func)
+    return t
+
+#####################################################################
+# Testing area.
+#####################################################################
+
+def test_select(dict_name="", schema="word String, counter UInt32", requests=[], answers=[], test_data=""):
+    global ADDING_ENDING
+    global SEND_ENCODING
+    global COMPRESS_METHOD
+    for i in range(len(requests)):
+        if i > 2:
+            ADDING_ENDING = ENDINGS[i-3]
+            SEND_ENCODING = False
+        
+        if dict_name:
+            get_ch_answer("drop dictionary if exists {}".format(dict_name))
+            get_ch_answer('''CREATE DICTIONARY {} ({})
+            PRIMARY KEY word
+            SOURCE(HTTP(url '{}' format 'CSV'))
+            LAYOUT(complex_key_hashed())
+            LIFETIME(0)'''.format(dict_name, schema, HTTP_SERVER_URL_STR+'/test.csv' + ADDING_ENDING))
+
+        COMPRESS_METHOD = requests[i]
+        print(i, COMPRESS_METHOD, ADDING_ENDING, SEND_ENCODING)
+        check_answers("select * from {}".format(dict_name), answers[i])
+
+def main():
+    # first three for encoding, second three for url
+    insert_requests = [
+            'none',
+            'gzip',
+            'lzma',
+            'gzip',
+            'lzma'
+    ]
+
+    # This answers got experemently in non compressed mode and they are correct
+    answers = ['''This	152\nHello	1\nis	9283\ndata	555\nWorld	2\ntesting	2313213'''] * 5
+
+    t = start_server(len(insert_requests))
+    t.start()
+    test_select(dict_name="test_table_select", requests=insert_requests, answers=answers)
+    t.join()
+    print("PASSED")
+
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as ex:
+        exc_type, exc_value, exc_traceback = sys.exc_info()
+        traceback.print_tb(exc_traceback, file=sys.stderr)
+        print(ex, file=sys.stderr)
+        sys.stderr.flush()
+
+        os._exit(1)
+
+
diff --git a/tests/queries/0_stateless/01854_HTTP_dict_decompression.reference b/tests/queries/0_stateless/01854_HTTP_dict_decompression.reference
new file mode 100644
index 00000000000..61bde4a9736
--- /dev/null
+++ b/tests/queries/0_stateless/01854_HTTP_dict_decompression.reference
@@ -0,0 +1,6 @@
+0 none  True
+1 gzip  True
+2 lzma  True
+3 gzip .gz False
+4 lzma .xz False
+PASSED
diff --git a/tests/queries/0_stateless/01854_HTTP_dict_decompression.sh b/tests/queries/0_stateless/01854_HTTP_dict_decompression.sh
new file mode 100755
index 00000000000..cca710e85cf
--- /dev/null
+++ b/tests/queries/0_stateless/01854_HTTP_dict_decompression.sh
@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+
+CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+# shellcheck source=../shell_config.sh
+. "$CURDIR"/../shell_config.sh
+
+python3 "$CURDIR"/01854_HTTP_dict_decompression.python
diff --git a/tests/queries/0_stateless/01854_dictionary_range_hashed_min_max_attr.reference b/tests/queries/0_stateless/01854_dictionary_range_hashed_min_max_attr.reference
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/tests/queries/0_stateless/01864_dictionary_range_hashed_min_max_attr.sql b/tests/queries/0_stateless/01854_dictionary_range_hashed_min_max_attr.sql
similarity index 100%
rename from tests/queries/0_stateless/01864_dictionary_range_hashed_min_max_attr.sql
rename to tests/queries/0_stateless/01854_dictionary_range_hashed_min_max_attr.sql
diff --git a/tests/queries/0_stateless/01855_jit_comparison_constant_result.reference b/tests/queries/0_stateless/01855_jit_comparison_constant_result.reference
new file mode 100644
index 00000000000..a9e2f17562a
--- /dev/null
+++ b/tests/queries/0_stateless/01855_jit_comparison_constant_result.reference
@@ -0,0 +1,6 @@
+1
+1
+1
+1
+1
+1
diff --git a/tests/queries/0_stateless/01855_jit_comparison_constant_result.sql b/tests/queries/0_stateless/01855_jit_comparison_constant_result.sql
new file mode 100644
index 00000000000..b8d06e218e0
--- /dev/null
+++ b/tests/queries/0_stateless/01855_jit_comparison_constant_result.sql
@@ -0,0 +1,15 @@
+SET compile_expressions = 1;
+SET min_count_to_compile_expression = 0;
+
+DROP TABLE IF EXISTS test_table;
+CREATE TABLE test_table (a UInt64) ENGINE = MergeTree() ORDER BY tuple();
+INSERT INTO test_table VALUES (1);
+
+SELECT test_table.a FROM test_table ORDER BY (test_table.a > test_table.a) + 1;
+SELECT test_table.a FROM test_table ORDER BY (test_table.a >= test_table.a) + 1;
+
+SELECT test_table.a FROM test_table ORDER BY (test_table.a < test_table.a) + 1;
+SELECT test_table.a FROM test_table ORDER BY (test_table.a <= test_table.a) + 1;
+
+SELECT test_table.a FROM test_table ORDER BY (test_table.a == test_table.a) + 1;
+SELECT test_table.a FROM test_table ORDER BY (test_table.a != test_table.a) + 1;
diff --git a/tests/queries/0_stateless/01865_aggregator_overflow_row.reference b/tests/queries/0_stateless/01865_aggregator_overflow_row.reference
new file mode 100644
index 00000000000..b6cfb5c6eee
--- /dev/null
+++ b/tests/queries/0_stateless/01865_aggregator_overflow_row.reference
@@ -0,0 +1,12 @@
+1
+1
+1
+1
+1
+1
+1
+1
+1
+1
+
+10020
diff --git a/tests/queries/0_stateless/01865_aggregator_overflow_row.sql b/tests/queries/0_stateless/01865_aggregator_overflow_row.sql
new file mode 100644
index 00000000000..bd7e431ec13
--- /dev/null
+++ b/tests/queries/0_stateless/01865_aggregator_overflow_row.sql
@@ -0,0 +1,20 @@
+SELECT uniqCombined(number)
+FROM numbers(10000)
+GROUP BY number
+    WITH TOTALS
+ORDER BY number DESC
+LIMIT 10
+SETTINGS
+    /* force aggregates serialization to trigger the issue with */
+    max_bytes_before_external_group_by=1,
+    /* overflow row: */
+    max_rows_to_group_by=10000000000,
+    group_by_overflow_mode='any',
+    totals_mode='before_having',
+    /* this is to account memory under 4MB (for max_bytes_before_external_group_by) to use less rows */
+    max_untracked_memory=0,
+    group_by_two_level_threshold=10000,
+    /* explicitly */
+    max_block_size=1000,
+    max_threads=1
+;
diff --git a/tests/queries/0_stateless/arcadia_skip_list.txt b/tests/queries/0_stateless/arcadia_skip_list.txt
index 08587395001..e84934dbc34 100644
--- a/tests/queries/0_stateless/arcadia_skip_list.txt
+++ b/tests/queries/0_stateless/arcadia_skip_list.txt
@@ -228,6 +228,8 @@
 01780_clickhouse_dictionary_source_loop
 01790_dist_INSERT_block_structure_mismatch_types_and_names
 01791_dist_INSERT_block_structure_mismatch
+01798_uniq_theta_sketch
+01799_long_uniq_theta_sketch
 01801_distinct_group_by_shard
 01804_dictionary_decimal256_type
 01801_s3_distributed
diff --git a/tests/testflows/datetime64_extended_range/__init__.py b/tests/testflows/datetime64_extended_range/__init__.py
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/tests/testflows/datetime64_extended_range/common.py b/tests/testflows/datetime64_extended_range/common.py
new file mode 100644
index 00000000000..f441cd2b469
--- /dev/null
+++ b/tests/testflows/datetime64_extended_range/common.py
@@ -0,0 +1,46 @@
+from multiprocessing.dummy import Pool
+
+from testflows.core import *
+
+def join(tasks, test=None):
+    """Join all parallel tests.
+    """
+    exc = None
+
+    if test is None:
+        test = current()
+
+    for task in tasks:
+        try:
+            task.get()
+        except Exception as e:
+            exc = e
+
+    if exc:
+        raise exc
+
+def start(pool, tasks, scenario, kwargs=None, test=None):
+    """Start parallel test.
+    """
+    if test is None:
+        test = current()
+    if kwargs is None:
+        kwargs = {}
+
+    task = pool.apply_async(scenario, [], kwargs)
+    tasks.append(task)
+    return task
+
+def run_scenario(pool, tasks, scenario, kwargs=None):
+    """Run scenario in parallel if parallel flag is set
+    in the context.
+    """
+    if kwargs is None:
+        kwargs = {}
+
+    if current().context.parallel:
+        start(pool, tasks, scenario, kwargs)
+    else:
+        scenario(**kwargs)
+
+
diff --git a/tests/testflows/datetime64_extended_range/configs/clickhouse/common.xml b/tests/testflows/datetime64_extended_range/configs/clickhouse/common.xml
new file mode 100644
index 00000000000..df952b28c82
--- /dev/null
+++ b/tests/testflows/datetime64_extended_range/configs/clickhouse/common.xml
@@ -0,0 +1,6 @@
+<yandex>
+    <timezone>Europe/Moscow</timezone>
+    <listen_host replace="replace">0.0.0.0</listen_host>
+    <path>/var/lib/clickhouse/</path>
+    <tmp_path>/var/lib/clickhouse/tmp/</tmp_path>
+</yandex>
diff --git a/tests/testflows/datetime64_extended_range/configs/clickhouse/config.d/logs.xml b/tests/testflows/datetime64_extended_range/configs/clickhouse/config.d/logs.xml
new file mode 100644
index 00000000000..bdf1bbc11c1
--- /dev/null
+++ b/tests/testflows/datetime64_extended_range/configs/clickhouse/config.d/logs.xml
@@ -0,0 +1,17 @@
+<yandex>
+    <shutdown_wait_unfinished>3</shutdown_wait_unfinished>
+    <logger>
+        <level>trace</level>
+        <log>/var/log/clickhouse-server/log.log</log>
+        <errorlog>/var/log/clickhouse-server/log.err.log</errorlog>
+        <size>1000M</size>
+        <count>10</count>
+        <stderr>/var/log/clickhouse-server/stderr.log</stderr>
+        <stdout>/var/log/clickhouse-server/stdout.log</stdout>
+    </logger>
+    <part_log>
+        <database>system</database>
+        <table>part_log</table>
+        <flush_interval_milliseconds>500</flush_interval_milliseconds>
+    </part_log>
+</yandex>
diff --git a/tests/testflows/datetime64_extended_range/configs/clickhouse/config.d/ports.xml b/tests/testflows/datetime64_extended_range/configs/clickhouse/config.d/ports.xml
new file mode 100644
index 00000000000..fbc6cea74c0
--- /dev/null
+++ b/tests/testflows/datetime64_extended_range/configs/clickhouse/config.d/ports.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0"?>
+<yandex>
+    <https_port>8443</https_port>
+    <tcp_port_secure>9440</tcp_port_secure>
+</yandex>
\ No newline at end of file
diff --git a/tests/testflows/datetime64_extended_range/configs/clickhouse/config.d/remote.xml b/tests/testflows/datetime64_extended_range/configs/clickhouse/config.d/remote.xml
new file mode 100644
index 00000000000..51be2a6e8e3
--- /dev/null
+++ b/tests/testflows/datetime64_extended_range/configs/clickhouse/config.d/remote.xml
@@ -0,0 +1,107 @@
+<?xml version="1.0"?>
+<yandex>
+    <remote_servers>
+        <replicated_cluster>
+            <shard>
+                <internal_replication>true</internal_replication>
+                <replica>
+                    <host>clickhouse1</host>
+                    <port>9000</port>
+                </replica>
+                <replica>
+                    <host>clickhouse2</host>
+                    <port>9000</port>
+                </replica>
+                <replica>
+                    <host>clickhouse3</host>
+                    <port>9000</port>
+                </replica>
+            </shard>
+        </replicated_cluster>
+        <!--
+        <replicated_cluster_readonly>
+            <shard>
+                <internal_replication>true</internal_replication>
+                <replica>
+                    <host>clickhouse1</host>
+                    <port>9000</port>
+                    <user>readonly</user>
+                </replica>
+                <replica>
+                    <host>clickhouse2</host>
+                    <port>9000</port>
+                    <user>readonly</user>
+                </replica>
+                <replica>
+                    <host>clickhouse3</host>
+                    <port>9000</port>
+                    <user>readonly</user>
+                </replica>
+            </shard>
+        </replicated_cluster_readonly>
+        -->
+        <replicated_cluster_secure>
+            <shard>
+                <internal_replication>true</internal_replication>
+                <replica>
+                    <host>clickhouse1</host>
+                    <port>9440</port>
+                    <secure>1</secure>
+                </replica>
+                <replica>
+                    <host>clickhouse2</host>
+                    <port>9440</port>
+                    <secure>1</secure>
+                </replica>
+                <replica>
+                    <host>clickhouse3</host>
+                    <port>9440</port>
+                    <secure>1</secure>
+                </replica>
+            </shard>
+        </replicated_cluster_secure>
+        <sharded_cluster>
+            <shard>
+                <replica>
+                    <host>clickhouse1</host>
+                    <port>9000</port>
+                </replica>
+            </shard>
+            <shard>
+                <replica>
+                    <host>clickhouse2</host>
+                    <port>9000</port>
+                </replica>
+            </shard>
+            <shard>
+                <replica>
+                    <host>clickhouse3</host>
+                    <port>9000</port>
+                </replica>
+            </shard>
+        </sharded_cluster>
+        <sharded_cluster_secure>
+            <shard>
+                <replica>
+                    <host>clickhouse1</host>
+                    <port>9440</port>
+                    <secure>1</secure>
+                </replica>
+            </shard>
+            <shard>
+                <replica>
+                    <host>clickhouse2</host>
+                    <port>9440</port>
+                    <secure>1</secure>
+                </replica>
+            </shard>
+            <shard>
+                <replica>
+                    <host>clickhouse3</host>
+                    <port>9440</port>
+                    <secure>1</secure>
+                </replica>
+            </shard>
+        </sharded_cluster_secure>
+    </remote_servers>
+</yandex>
diff --git a/tests/testflows/datetime64_extended_range/configs/clickhouse/config.d/ssl.xml b/tests/testflows/datetime64_extended_range/configs/clickhouse/config.d/ssl.xml
new file mode 100644
index 00000000000..ca65ffd5e04
--- /dev/null
+++ b/tests/testflows/datetime64_extended_range/configs/clickhouse/config.d/ssl.xml
@@ -0,0 +1,17 @@
+<yandex>
+    <openSSL>
+        <server>
+            <certificateFile>/etc/clickhouse-server/ssl/server.crt</certificateFile>
+            <privateKeyFile>/etc/clickhouse-server/ssl/server.key</privateKeyFile>
+            <verificationMode>none</verificationMode>
+            <cacheSessions>true</cacheSessions>
+        </server>
+        <client>
+            <cacheSessions>true</cacheSessions>
+            <verificationMode>none</verificationMode>
+            <invalidCertificateHandler>
+                <name>AcceptCertificateHandler</name>
+            </invalidCertificateHandler>
+        </client>
+    </openSSL>
+</yandex>
diff --git a/tests/testflows/datetime64_extended_range/configs/clickhouse/config.d/storage.xml b/tests/testflows/datetime64_extended_range/configs/clickhouse/config.d/storage.xml
new file mode 100644
index 00000000000..618fd6b6d24
--- /dev/null
+++ b/tests/testflows/datetime64_extended_range/configs/clickhouse/config.d/storage.xml
@@ -0,0 +1,20 @@
+<yandex>
+
+<storage_configuration>
+    <disks>
+        <default>
+            <keep_free_space_bytes>1024</keep_free_space_bytes>
+        </default>
+    </disks>
+    <policies>
+        <default>
+            <volumes>
+                <default>
+                    <disk>default</disk>
+                </default>
+            </volumes>
+        </default>
+    </policies>
+</storage_configuration>
+
+</yandex>
diff --git a/tests/testflows/datetime64_extended_range/configs/clickhouse/config.d/zookeeper.xml b/tests/testflows/datetime64_extended_range/configs/clickhouse/config.d/zookeeper.xml
new file mode 100644
index 00000000000..96270e7b645
--- /dev/null
+++ b/tests/testflows/datetime64_extended_range/configs/clickhouse/config.d/zookeeper.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0"?>
+<yandex>
+    <zookeeper>
+	    <node index="1">
+		    <host>zookeeper</host>
+		    <port>2181</port>
+	    </node>
+        <session_timeout_ms>15000</session_timeout_ms>
+    </zookeeper>
+</yandex>
diff --git a/tests/testflows/datetime64_extended_range/configs/clickhouse/config.xml b/tests/testflows/datetime64_extended_range/configs/clickhouse/config.xml
new file mode 100644
index 00000000000..d34d2c35253
--- /dev/null
+++ b/tests/testflows/datetime64_extended_range/configs/clickhouse/config.xml
@@ -0,0 +1,436 @@
+<?xml version="1.0"?>
+<!--
+  NOTE: User and query level settings are set up in "users.xml" file.
+-->
+<yandex>
+    <logger>
+        <!-- Possible levels: https://github.com/pocoproject/poco/blob/develop/Foundation/include/Poco/Logger.h#L105 -->
+        <level>trace</level>
+        <log>/var/log/clickhouse-server/clickhouse-server.log</log>
+        <errorlog>/var/log/clickhouse-server/clickhouse-server.err.log</errorlog>
+        <size>1000M</size>
+        <count>10</count>
+        <!-- <console>1</console> --> <!-- Default behavior is autodetection (log to console if not daemon mode and is tty) -->
+    </logger>
+    <!--display_name>production</display_name--> <!-- It is the name that will be shown in the client -->
+    <http_port>8123</http_port>
+    <tcp_port>9000</tcp_port>
+
+    <!-- For HTTPS and SSL over native protocol. -->
+    <!--
+    <https_port>8443</https_port>
+    <tcp_port_secure>9440</tcp_port_secure>
+    -->
+
+    <!-- Used with https_port and tcp_port_secure. Full ssl options list: https://github.com/ClickHouse-Extras/poco/blob/master/NetSSL_OpenSSL/include/Poco/Net/SSLManager.h#L71 -->
+    <openSSL>
+        <server> <!-- Used for https server AND secure tcp port -->
+            <!-- openssl req -subj "/CN=localhost" -new -newkey rsa:2048 -days 365 -nodes -x509 -keyout /etc/clickhouse-server/server.key -out /etc/clickhouse-server/server.crt -->
+            <certificateFile>/etc/clickhouse-server/server.crt</certificateFile>
+            <privateKeyFile>/etc/clickhouse-server/server.key</privateKeyFile>
+            <!-- openssl dhparam -out /etc/clickhouse-server/dhparam.pem 4096 -->
+            <dhParamsFile>/etc/clickhouse-server/dhparam.pem</dhParamsFile>
+            <verificationMode>none</verificationMode>
+            <loadDefaultCAFile>true</loadDefaultCAFile>
+            <cacheSessions>true</cacheSessions>
+            <disableProtocols>sslv2,sslv3</disableProtocols>
+            <preferServerCiphers>true</preferServerCiphers>
+        </server>
+
+        <client> <!-- Used for connecting to https dictionary source -->
+            <loadDefaultCAFile>true</loadDefaultCAFile>
+            <cacheSessions>true</cacheSessions>
+            <disableProtocols>sslv2,sslv3</disableProtocols>
+            <preferServerCiphers>true</preferServerCiphers>
+            <!-- Use for self-signed: <verificationMode>none</verificationMode> -->
+            <invalidCertificateHandler>
+                <!-- Use for self-signed: <name>AcceptCertificateHandler</name> -->
+                <name>RejectCertificateHandler</name>
+            </invalidCertificateHandler>
+        </client>
+    </openSSL>
+
+    <!-- Default root page on http[s] server. For example load UI from https://tabix.io/ when opening http://localhost:8123 -->
+    <!--
+    <http_server_default_response><![CDATA[<html ng-app="SMI2"><head><base href="http://ui.tabix.io/"></head><body><div ui-view="" class="content-ui"></div><script src="http://loader.tabix.io/master.js"></script></body></html>]]></http_server_default_response>
+    -->
+
+    <!-- Port for communication between replicas. Used for data exchange. -->
+    <interserver_http_port>9009</interserver_http_port>
+
+    <!-- Hostname that is used by other replicas to request this server.
+         If not specified, than it is determined analoguous to 'hostname -f' command.
+         This setting could be used to switch replication to another network interface.
+      -->
+    <!--
+    <interserver_http_host>example.yandex.ru</interserver_http_host>
+    -->
+
+    <!-- Listen specified host. use :: (wildcard IPv6 address), if you want to accept connections both with IPv4 and IPv6 from everywhere. -->
+    <!-- <listen_host>::</listen_host> -->
+    <!-- Same for hosts with disabled ipv6: -->
+    <!-- <listen_host>0.0.0.0</listen_host> -->
+
+    <!-- Default values - try listen localhost on ipv4 and ipv6: -->
+    <!--
+    <listen_host>::1</listen_host>
+    <listen_host>127.0.0.1</listen_host>
+    -->
+    <!-- Don't exit if ipv6 or ipv4 unavailable, but listen_host with this protocol specified -->
+    <!-- <listen_try>0</listen_try> -->
+
+    <!-- Allow listen on same address:port -->
+    <!-- <listen_reuse_port>0</listen_reuse_port> -->
+
+    <!-- <listen_backlog>64</listen_backlog> -->
+
+    <max_connections>4096</max_connections>
+    <keep_alive_timeout>3</keep_alive_timeout>
+
+    <!-- Maximum number of concurrent queries. -->
+    <max_concurrent_queries>100</max_concurrent_queries>
+
+    <!-- Set limit on number of open files (default: maximum). This setting makes sense on Mac OS X because getrlimit() fails to retrieve
+         correct maximum value. -->
+    <!-- <max_open_files>262144</max_open_files> -->
+
+    <!-- Size of cache of uncompressed blocks of data, used in tables of MergeTree family.
+         In bytes. Cache is single for server. Memory is allocated only on demand.
+         Cache is used when 'use_uncompressed_cache' user setting turned on (off by default).
+         Uncompressed cache is advantageous only for very short queries and in rare cases.
+      -->
+    <uncompressed_cache_size>8589934592</uncompressed_cache_size>
+
+    <!-- Approximate size of mark cache, used in tables of MergeTree family.
+         In bytes. Cache is single for server. Memory is allocated only on demand.
+         You should not lower this value.
+      -->
+    <mark_cache_size>5368709120</mark_cache_size>
+
+
+    <!-- Path to data directory, with trailing slash. -->
+    <path>/var/lib/clickhouse/</path>
+
+    <!-- Path to temporary data for processing hard queries. -->
+    <tmp_path>/var/lib/clickhouse/tmp/</tmp_path>
+
+    <!-- Directory with user provided files that are accessible by 'file' table function. -->
+    <user_files_path>/var/lib/clickhouse/user_files/</user_files_path>
+
+    <!-- Path to folder where users and roles created by SQL commands are stored. -->
+    <access_control_path>/var/lib/clickhouse/access/</access_control_path>
+
+    <!-- Path to configuration file with users, access rights, profiles of settings, quotas. -->
+    <users_config>users.xml</users_config>
+
+    <!-- Default profile of settings. -->
+    <default_profile>default</default_profile>
+
+    <!-- System profile of settings. This settings are used by internal processes (Buffer storage, Distibuted DDL worker and so on). -->
+    <!-- <system_profile>default</system_profile> -->
+
+    <!-- Default database. -->
+    <default_database>default</default_database>
+
+    <!-- Server time zone could be set here.
+
+         Time zone is used when converting between String and DateTime types,
+          when printing DateTime in text formats and parsing DateTime from text,
+          it is used in date and time related functions, if specific time zone was not passed as an argument.
+
+         Time zone is specified as identifier from IANA time zone database, like UTC or Africa/Abidjan.
+         If not specified, system time zone at server startup is used.
+
+         Please note, that server could display time zone alias instead of specified name.
+         Example: W-SU is an alias for Europe/Moscow and Zulu is an alias for UTC.
+    -->
+    <!-- <timezone>Europe/Moscow</timezone> -->
+
+    <!-- You can specify umask here (see "man umask"). Server will apply it on startup.
+         Number is always parsed as octal. Default umask is 027 (other users cannot read logs, data files, etc; group can only read).
+    -->
+    <!-- <umask>022</umask> -->
+
+    <!-- Perform mlockall after startup to lower first queries latency
+          and to prevent clickhouse executable from being paged out under high IO load.
+         Enabling this option is recommended but will lead to increased startup time for up to a few seconds.
+    -->
+    <mlock_executable>false</mlock_executable>
+
+    <!-- Configuration of clusters that could be used in Distributed tables.
+         https://clickhouse.yandex/docs/en/table_engines/distributed/
+      -->
+    <remote_servers incl="remote" >
+        <!-- Test only shard config for testing distributed storage -->
+        <test_shard_localhost>
+            <shard>
+                <replica>
+                    <host>localhost</host>
+                    <port>9000</port>
+                </replica>
+            </shard>
+        </test_shard_localhost>
+        <test_cluster_two_shards_localhost>
+             <shard>
+                 <replica>
+                     <host>localhost</host>
+                     <port>9000</port>
+                 </replica>
+             </shard>
+             <shard>
+                 <replica>
+                     <host>localhost</host>
+                     <port>9000</port>
+                 </replica>
+             </shard>
+         </test_cluster_two_shards_localhost>
+        <test_shard_localhost_secure>
+            <shard>
+                <replica>
+                    <host>localhost</host>
+                    <port>9440</port>
+                    <secure>1</secure>
+                </replica>
+            </shard>
+        </test_shard_localhost_secure>
+        <test_unavailable_shard>
+            <shard>
+                <replica>
+                    <host>localhost</host>
+                    <port>9000</port>
+                </replica>
+            </shard>
+            <shard>
+                <replica>
+                    <host>localhost</host>
+                    <port>1</port>
+                </replica>
+            </shard>
+        </test_unavailable_shard>
+    </remote_servers>
+
+
+    <!-- If element has 'incl' attribute, then for it's value will be used corresponding substitution from another file.
+         By default, path to file with substitutions is /etc/metrika.xml. It could be changed in config in 'include_from' element.
+         Values for substitutions are specified in /yandex/name_of_substitution elements in that file.
+      -->
+
+    <!-- ZooKeeper is used to store metadata about replicas, when using Replicated tables.
+         Optional. If you don't use replicated tables, you could omit that.
+
+         See https://clickhouse.yandex/docs/en/table_engines/replication/
+      -->
+    <zookeeper incl="zookeeper" optional="true" />
+
+    <!-- Substitutions for parameters of replicated tables.
+          Optional. If you don't use replicated tables, you could omit that.
+
+         See https://clickhouse.yandex/docs/en/table_engines/replication/#creating-replicated-tables
+      -->
+    <macros incl="macros" optional="true" />
+
+
+    <!-- Reloading interval for embedded dictionaries, in seconds. Default: 3600. -->
+    <builtin_dictionaries_reload_interval>3600</builtin_dictionaries_reload_interval>
+
+
+    <!-- Maximum session timeout, in seconds. Default: 3600. -->
+    <max_session_timeout>3600</max_session_timeout>
+
+    <!-- Default session timeout, in seconds. Default: 60. -->
+    <default_session_timeout>60</default_session_timeout>
+
+    <!-- Sending data to Graphite for monitoring. Several sections can be defined. -->
+    <!--
+        interval - send every X second
+        root_path - prefix for keys
+        hostname_in_path - append hostname to root_path (default = true)
+        metrics - send data from table system.metrics
+        events - send data from table system.events
+        asynchronous_metrics - send data from table system.asynchronous_metrics
+    -->
+    <!--
+    <graphite>
+        <host>localhost</host>
+        <port>42000</port>
+        <timeout>0.1</timeout>
+        <interval>60</interval>
+        <root_path>one_min</root_path>
+        <hostname_in_path>true</hostname_in_path>
+
+        <metrics>true</metrics>
+        <events>true</events>
+        <asynchronous_metrics>true</asynchronous_metrics>
+    </graphite>
+    <graphite>
+        <host>localhost</host>
+        <port>42000</port>
+        <timeout>0.1</timeout>
+        <interval>1</interval>
+        <root_path>one_sec</root_path>
+
+        <metrics>true</metrics>
+        <events>true</events>
+        <asynchronous_metrics>false</asynchronous_metrics>
+    </graphite>
+    -->
+
+
+    <!-- Query log. Used only for queries with setting log_queries = 1. -->
+    <query_log>
+        <!-- What table to insert data. If table is not exist, it will be created.
+             When query log structure is changed after system update,
+              then old table will be renamed and new table will be created automatically.
+        -->
+        <database>system</database>
+        <table>query_log</table>
+        <!--
+            PARTITION BY expr https://clickhouse.yandex/docs/en/table_engines/custom_partitioning_key/
+            Example:
+                event_date
+                toMonday(event_date)
+                toYYYYMM(event_date)
+                toStartOfHour(event_time)
+        -->
+        <partition_by>toYYYYMM(event_date)</partition_by>
+        <!-- Interval of flushing data. -->
+        <flush_interval_milliseconds>7500</flush_interval_milliseconds>
+    </query_log>
+
+    <!-- Trace log. Stores stack traces collected by query profilers.
+         See query_profiler_real_time_period_ns and query_profiler_cpu_time_period_ns settings. -->
+    <trace_log>
+        <database>system</database>
+        <table>trace_log</table>
+
+        <partition_by>toYYYYMM(event_date)</partition_by>
+        <flush_interval_milliseconds>7500</flush_interval_milliseconds>
+    </trace_log>
+
+    <!-- Query thread log. Has information about all threads participated in query execution.
+         Used only for queries with setting log_query_threads = 1. -->
+    <query_thread_log>
+        <database>system</database>
+        <table>query_thread_log</table>
+        <partition_by>toYYYYMM(event_date)</partition_by>
+        <flush_interval_milliseconds>7500</flush_interval_milliseconds>
+    </query_thread_log>
+
+    <!-- Uncomment if use part log.
+         Part log contains information about all actions with parts in MergeTree tables (creation, deletion, merges, downloads).
+    <part_log>
+        <database>system</database>
+        <table>part_log</table>
+        <flush_interval_milliseconds>7500</flush_interval_milliseconds>
+    </part_log>
+    -->
+
+    <!-- Uncomment to write text log into table.
+         Text log contains all information from usual server log but stores it in structured and efficient way.
+    <text_log>
+        <database>system</database>
+        <table>text_log</table>
+        <flush_interval_milliseconds>7500</flush_interval_milliseconds>
+    </text_log>
+    -->
+
+    <!-- Parameters for embedded dictionaries, used in Yandex.Metrica.
+         See https://clickhouse.yandex/docs/en/dicts/internal_dicts/
+    -->
+
+    <!-- Path to file with region hierarchy. -->
+    <!-- <path_to_regions_hierarchy_file>/opt/geo/regions_hierarchy.txt</path_to_regions_hierarchy_file> -->
+
+    <!-- Path to directory with files containing names of regions -->
+    <!-- <path_to_regions_names_files>/opt/geo/</path_to_regions_names_files> -->
+
+
+    <!-- Configuration of external dictionaries. See:
+         https://clickhouse.yandex/docs/en/dicts/external_dicts/
+    -->
+    <dictionaries_config>*_dictionary.xml</dictionaries_config>
+
+    <!-- Uncomment if you want data to be compressed 30-100% better.
+         Don't do that if you just started using ClickHouse.
+      -->
+    <compression incl="compression">
+    <!--
+        <!- - Set of variants. Checked in order. Last matching case wins. If nothing matches, lz4 will be used. - ->
+        <case>
+
+            <!- - Conditions. All must be satisfied. Some conditions may be omitted. - ->
+            <min_part_size>10000000000</min_part_size>        <!- - Min part size in bytes. - ->
+            <min_part_size_ratio>0.01</min_part_size_ratio>   <!- - Min size of part relative to whole table size. - ->
+
+            <!- - What compression method to use. - ->
+            <method>zstd</method>
+        </case>
+    -->
+    </compression>
+
+    <!-- Allow to execute distributed DDL queries (CREATE, DROP, ALTER, RENAME) on cluster.
+         Works only if ZooKeeper is enabled. Comment it if such functionality isn't required. -->
+    <distributed_ddl>
+        <!-- Path in ZooKeeper to queue with DDL queries -->
+        <path>/clickhouse/task_queue/ddl</path>
+
+        <!-- Settings from this profile will be used to execute DDL queries -->
+        <!-- <profile>default</profile> -->
+    </distributed_ddl>
+
+    <!-- Settings to fine tune MergeTree tables. See documentation in source code, in MergeTreeSettings.h -->
+    <!--
+    <merge_tree>
+        <max_suspicious_broken_parts>5</max_suspicious_broken_parts>
+    </merge_tree>
+    -->
+
+    <!-- Protection from accidental DROP.
+         If size of a MergeTree table is greater than max_table_size_to_drop (in bytes) than table could not be dropped with any DROP query.
+         If you want do delete one table and don't want to restart clickhouse-server, you could create special file <clickhouse-path>/flags/force_drop_table and make DROP once.
+         By default max_table_size_to_drop is 50GB; max_table_size_to_drop=0 allows to DROP any tables.
+         The same for max_partition_size_to_drop.
+         Uncomment to disable protection.
+    -->
+    <!-- <max_table_size_to_drop>0</max_table_size_to_drop> -->
+    <!-- <max_partition_size_to_drop>0</max_partition_size_to_drop> -->
+
+    <!-- Example of parameters for GraphiteMergeTree table engine -->
+    <graphite_rollup_example>
+        <pattern>
+            <regexp>click_cost</regexp>
+            <function>any</function>
+            <retention>
+                <age>0</age>
+                <precision>3600</precision>
+            </retention>
+            <retention>
+                <age>86400</age>
+                <precision>60</precision>
+            </retention>
+        </pattern>
+        <default>
+            <function>max</function>
+            <retention>
+                <age>0</age>
+                <precision>60</precision>
+            </retention>
+            <retention>
+                <age>3600</age>
+                <precision>300</precision>
+            </retention>
+            <retention>
+                <age>86400</age>
+                <precision>3600</precision>
+            </retention>
+        </default>
+    </graphite_rollup_example>
+
+    <!-- Directory in <clickhouse-path> containing schema files for various input formats.
+         The directory will be created if it doesn't exist.
+      -->
+    <format_schema_path>/var/lib/clickhouse/format_schemas/</format_schema_path>
+
+    <!-- Uncomment to disable ClickHouse internal DNS caching. -->
+    <!-- <disable_internal_dns_cache>1</disable_internal_dns_cache> -->
+</yandex>
diff --git a/tests/testflows/datetime64_extended_range/configs/clickhouse/ssl/dhparam.pem b/tests/testflows/datetime64_extended_range/configs/clickhouse/ssl/dhparam.pem
new file mode 100644
index 00000000000..2e6cee0798d
--- /dev/null
+++ b/tests/testflows/datetime64_extended_range/configs/clickhouse/ssl/dhparam.pem
@@ -0,0 +1,8 @@
+-----BEGIN DH PARAMETERS-----
+MIIBCAKCAQEAua92DDli13gJ+//ZXyGaggjIuidqB0crXfhUlsrBk9BV1hH3i7fR
+XGP9rUdk2ubnB3k2ejBStL5oBrkHm9SzUFSQHqfDjLZjKoUpOEmuDc4cHvX1XTR5
+Pr1vf5cd0yEncJWG5W4zyUB8k++SUdL2qaeslSs+f491HBLDYn/h8zCgRbBvxhxb
+9qeho1xcbnWeqkN6Kc9bgGozA16P9NLuuLttNnOblkH+lMBf42BSne/TWt3AlGZf
+slKmmZcySUhF8aKfJnLKbkBCFqOtFRh8zBA9a7g+BT/lSANATCDPaAk1YVih2EKb
+dpc3briTDbRsiqg2JKMI7+VdULY9bh3EawIBAg==
+-----END DH PARAMETERS-----
diff --git a/tests/testflows/datetime64_extended_range/configs/clickhouse/ssl/server.crt b/tests/testflows/datetime64_extended_range/configs/clickhouse/ssl/server.crt
new file mode 100644
index 00000000000..7ade2d96273
--- /dev/null
+++ b/tests/testflows/datetime64_extended_range/configs/clickhouse/ssl/server.crt
@@ -0,0 +1,19 @@
+-----BEGIN CERTIFICATE-----
+MIIC/TCCAeWgAwIBAgIJANjx1QSR77HBMA0GCSqGSIb3DQEBCwUAMBQxEjAQBgNV
+BAMMCWxvY2FsaG9zdDAgFw0xODA3MzAxODE2MDhaGA8yMjkyMDUxNDE4MTYwOFow
+FDESMBAGA1UEAwwJbG9jYWxob3N0MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIB
+CgKCAQEAs9uSo6lJG8o8pw0fbVGVu0tPOljSWcVSXH9uiJBwlZLQnhN4SFSFohfI
+4K8U1tBDTnxPLUo/V1K9yzoLiRDGMkwVj6+4+hE2udS2ePTQv5oaMeJ9wrs+5c9T
+4pOtlq3pLAdm04ZMB1nbrEysceVudHRkQbGHzHp6VG29Fw7Ga6YpqyHQihRmEkTU
+7UCYNA+Vk7aDPdMS/khweyTpXYZimaK9f0ECU3/VOeG3fH6Sp2X6FN4tUj/aFXEj
+sRmU5G2TlYiSIUMF2JPdhSihfk1hJVALrHPTU38SOL+GyyBRWdNcrIwVwbpvsvPg
+pryMSNxnpr0AK0dFhjwnupIv5hJIOQIDAQABo1AwTjAdBgNVHQ4EFgQUjPLb3uYC
+kcamyZHK4/EV8jAP0wQwHwYDVR0jBBgwFoAUjPLb3uYCkcamyZHK4/EV8jAP0wQw
+DAYDVR0TBAUwAwEB/zANBgkqhkiG9w0BAQsFAAOCAQEAM/ocuDvfPus/KpMVD51j
+4IdlU8R0vmnYLQ+ygzOAo7+hUWP5j0yvq4ILWNmQX6HNvUggCgFv9bjwDFhb/5Vr
+85ieWfTd9+LTjrOzTw4avdGwpX9G+6jJJSSq15tw5ElOIFb/qNA9O4dBiu8vn03C
+L/zRSXrARhSqTW5w/tZkUcSTT+M5h28+Lgn9ysx4Ff5vi44LJ1NnrbJbEAIYsAAD
++UA+4MBFKx1r6hHINULev8+lCfkpwIaeS8RL+op4fr6kQPxnULw8wT8gkuc8I4+L
+P9gg/xDHB44T3ADGZ5Ib6O0DJaNiToO6rnoaaxs0KkotbvDWvRoxEytSbXKoYjYp
+0g==
+-----END CERTIFICATE-----
diff --git a/tests/testflows/datetime64_extended_range/configs/clickhouse/ssl/server.key b/tests/testflows/datetime64_extended_range/configs/clickhouse/ssl/server.key
new file mode 100644
index 00000000000..f0fb61ac443
--- /dev/null
+++ b/tests/testflows/datetime64_extended_range/configs/clickhouse/ssl/server.key
@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCz25KjqUkbyjyn
+DR9tUZW7S086WNJZxVJcf26IkHCVktCeE3hIVIWiF8jgrxTW0ENOfE8tSj9XUr3L
+OguJEMYyTBWPr7j6ETa51LZ49NC/mhox4n3Cuz7lz1Pik62WreksB2bThkwHWdus
+TKxx5W50dGRBsYfMenpUbb0XDsZrpimrIdCKFGYSRNTtQJg0D5WTtoM90xL+SHB7
+JOldhmKZor1/QQJTf9U54bd8fpKnZfoU3i1SP9oVcSOxGZTkbZOViJIhQwXYk92F
+KKF+TWElUAusc9NTfxI4v4bLIFFZ01ysjBXBum+y8+CmvIxI3GemvQArR0WGPCe6
+ki/mEkg5AgMBAAECggEATrbIBIxwDJOD2/BoUqWkDCY3dGevF8697vFuZKIiQ7PP
+TX9j4vPq0DfsmDjHvAPFkTHiTQXzlroFik3LAp+uvhCCVzImmHq0IrwvZ9xtB43f
+7Pkc5P6h1l3Ybo8HJ6zRIY3TuLtLxuPSuiOMTQSGRL0zq3SQ5DKuGwkz+kVjHXUN
+MR2TECFwMHKQ5VLrC+7PMpsJYyOMlDAWhRfUalxC55xOXTpaN8TxNnwQ8K2ISVY5
+212Jz/a4hn4LdwxSz3Tiu95PN072K87HLWx3EdT6vW4Ge5P/A3y+smIuNAlanMnu
+plHBRtpATLiTxZt/n6npyrfQVbYjSH7KWhB8hBHtaQKBgQDh9Cq1c/KtqDtE0Ccr
+/r9tZNTUwBE6VP+3OJeKdEdtsfuxjOCkS1oAjgBJiSDOiWPh1DdoDeVZjPKq6pIu
+Mq12OE3Doa8znfCXGbkSzEKOb2unKZMJxzrz99kXt40W5DtrqKPNb24CNqTiY8Aa
+CjtcX+3weat82VRXvph6U8ltMwKBgQDLxjiQQzNoY7qvg7CwJCjf9qq8jmLK766g
+1FHXopqS+dTxDLM8eJSRrpmxGWJvNeNc1uPhsKsKgotqAMdBUQTf7rSTbt4MyoH5
+bUcRLtr+0QTK9hDWMOOvleqNXha68vATkohWYfCueNsC60qD44o8RZAS6UNy3ENq
+cM1cxqe84wKBgQDKkHutWnooJtajlTxY27O/nZKT/HA1bDgniMuKaz4R4Gr1PIez
+on3YW3V0d0P7BP6PWRIm7bY79vkiMtLEKdiKUGWeyZdo3eHvhDb/3DCawtau8L2K
+GZsHVp2//mS1Lfz7Qh8/L/NedqCQ+L4iWiPnZ3THjjwn3CoZ05ucpvrAMwKBgB54
+nay039MUVq44Owub3KDg+dcIU62U+cAC/9oG7qZbxYPmKkc4oL7IJSNecGHA5SbU
+2268RFdl/gLz6tfRjbEOuOHzCjFPdvAdbysanpTMHLNc6FefJ+zxtgk9sJh0C4Jh
+vxFrw9nTKKzfEl12gQ1SOaEaUIO0fEBGbe8ZpauRAoGAMAlGV+2/K4ebvAJKOVTa
+dKAzQ+TD2SJmeR1HZmKDYddNqwtZlzg3v4ZhCk4eaUmGeC1Bdh8MDuB3QQvXz4Dr
+vOIP4UVaOr+uM+7TgAgVnP4/K6IeJGzUDhX93pmpWhODfdu/oojEKVcpCojmEmS1
+KCBtmIrQLqzMpnBpLNuSY+Q=
+-----END PRIVATE KEY-----
diff --git a/tests/testflows/datetime64_extended_range/configs/clickhouse/users.xml b/tests/testflows/datetime64_extended_range/configs/clickhouse/users.xml
new file mode 100644
index 00000000000..86b2cd9e1e3
--- /dev/null
+++ b/tests/testflows/datetime64_extended_range/configs/clickhouse/users.xml
@@ -0,0 +1,133 @@
+<?xml version="1.0"?>
+<yandex>
+    <!-- Profiles of settings. -->
+    <profiles>
+        <!-- Default settings. -->
+        <default>
+            <!-- Maximum memory usage for processing single query, in bytes. -->
+            <max_memory_usage>10000000000</max_memory_usage>
+
+            <!-- Use cache of uncompressed blocks of data. Meaningful only for processing many of very short queries. -->
+            <use_uncompressed_cache>0</use_uncompressed_cache>
+
+            <!-- How to choose between replicas during distributed query processing.
+                 random - choose random replica from set of replicas with minimum number of errors
+                 nearest_hostname - from set of replicas with minimum number of errors, choose replica
+                  with minimum number of different symbols between replica's hostname and local hostname
+                  (Hamming distance).
+                 in_order - first live replica is chosen in specified order.
+                 first_or_random - if first replica one has higher number of errors, pick a random one from replicas with minimum number of errors.
+            -->
+            <load_balancing>random</load_balancing>
+        </default>
+
+        <!-- Profile that allows only read queries. -->
+        <readonly>
+            <readonly>1</readonly>
+        </readonly>
+    </profiles>
+
+    <!-- Users and ACL. -->
+    <users>
+        <!-- If user name was not specified, 'default' user is used. -->
+        <default>
+            <!-- Password could be specified in plaintext or in SHA256 (in hex format).
+
+                 If you want to specify password in plaintext (not recommended), place it in 'password' element.
+                 Example: <password>qwerty</password>.
+                 Password could be empty.
+
+                 If you want to specify SHA256, place it in 'password_sha256_hex' element.
+                 Example: <password_sha256_hex>65e84be33532fb784c48129675f9eff3a682b27168c0ea744b2cf58ee02337c5</password_sha256_hex>
+                 Restrictions of SHA256: impossibility to connect to ClickHouse using MySQL JS client (as of July 2019).
+
+                 If you want to specify double SHA1, place it in 'password_double_sha1_hex' element.
+                 Example: <password_double_sha1_hex>e395796d6546b1b65db9d665cd43f0e858dd4303</password_double_sha1_hex>
+
+                 How to generate decent password:
+                 Execute: PASSWORD=$(base64 < /dev/urandom | head -c8); echo "$PASSWORD"; echo -n "$PASSWORD" | sha256sum | tr -d '-'
+                 In first line will be password and in second - corresponding SHA256.
+
+                 How to generate double SHA1:
+                 Execute: PASSWORD=$(base64 < /dev/urandom | head -c8); echo "$PASSWORD"; echo -n "$PASSWORD" | openssl dgst -sha1 -binary | openssl dgst -sha1
+                 In first line will be password and in second - corresponding double SHA1.
+            -->
+            <password></password>
+
+            <!-- List of networks with open access.
+
+                 To open access from everywhere, specify:
+                    <ip>::/0</ip>
+
+                 To open access only from localhost, specify:
+                    <ip>::1</ip>
+                    <ip>127.0.0.1</ip>
+
+                 Each element of list has one of the following forms:
+                 <ip> IP-address or network mask. Examples: 213.180.204.3 or 10.0.0.1/8 or 10.0.0.1/255.255.255.0
+                     2a02:6b8::3 or 2a02:6b8::3/64 or 2a02:6b8::3/ffff:ffff:ffff:ffff::.
+                 <host> Hostname. Example: server01.yandex.ru.
+                     To check access, DNS query is performed, and all received addresses compared to peer address.
+                 <host_regexp> Regular expression for host names. Example, ^server\d\d-\d\d-\d\.yandex\.ru$
+                     To check access, DNS PTR query is performed for peer address and then regexp is applied.
+                     Then, for result of PTR query, another DNS query is performed and all received addresses compared to peer address.
+                     Strongly recommended that regexp is ends with $
+                 All results of DNS requests are cached till server restart.
+            -->
+            <networks incl="networks" replace="replace">
+                <ip>::/0</ip>
+            </networks>
+
+            <!-- Settings profile for user. -->
+            <profile>default</profile>
+
+            <!-- Quota for user. -->
+            <quota>default</quota>
+
+            <!-- Allow access management -->
+            <access_management>1</access_management>
+
+            <!-- Example of row level security policy. -->
+            <!-- <databases>
+                <test>
+                    <filtered_table1>
+                        <filter>a = 1</filter>
+                    </filtered_table1>
+                    <filtered_table2>
+                        <filter>a + b &lt; 1 or c - d &gt; 5</filter>
+                    </filtered_table2>
+                </test>
+            </databases> -->
+        </default>
+
+        <!-- Example of user with readonly access. -->
+        <!-- <readonly>
+            <password></password>
+            <networks incl="networks" replace="replace">
+                <ip>::1</ip>
+                <ip>127.0.0.1</ip>
+            </networks>
+            <profile>readonly</profile>
+            <quota>default</quota>
+        </readonly> -->
+    </users>
+
+    <!-- Quotas. -->
+    <quotas>
+        <!-- Name of quota. -->
+        <default>
+            <!-- Limits for time interval. You could specify many intervals with different limits. -->
+            <interval>
+                <!-- Length of interval. -->
+                <duration>3600</duration>
+
+                <!-- No limits. Just calculate resource usage for time interval. -->
+                <queries>0</queries>
+                <errors>0</errors>
+                <result_rows>0</result_rows>
+                <read_rows>0</read_rows>
+                <execution_time>0</execution_time>
+            </interval>
+        </default>
+    </quotas>
+</yandex>
diff --git a/tests/testflows/datetime64_extended_range/configs/clickhouse1/config.d/macros.xml b/tests/testflows/datetime64_extended_range/configs/clickhouse1/config.d/macros.xml
new file mode 100644
index 00000000000..6cdcc1b440c
--- /dev/null
+++ b/tests/testflows/datetime64_extended_range/configs/clickhouse1/config.d/macros.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0"?>
+<yandex>
+    <macros>
+        <replica>clickhouse1</replica>
+        <shard>01</shard>
+        <shard2>01</shard2>
+    </macros>
+</yandex>
diff --git a/tests/testflows/datetime64_extended_range/configs/clickhouse2/config.d/macros.xml b/tests/testflows/datetime64_extended_range/configs/clickhouse2/config.d/macros.xml
new file mode 100644
index 00000000000..a114a9ce4ab
--- /dev/null
+++ b/tests/testflows/datetime64_extended_range/configs/clickhouse2/config.d/macros.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0"?>
+<yandex>
+    <macros>
+        <replica>clickhouse2</replica>
+        <shard>01</shard>
+        <shard2>02</shard2>
+    </macros>
+</yandex>
diff --git a/tests/testflows/datetime64_extended_range/configs/clickhouse3/config.d/macros.xml b/tests/testflows/datetime64_extended_range/configs/clickhouse3/config.d/macros.xml
new file mode 100644
index 00000000000..904a27b0172
--- /dev/null
+++ b/tests/testflows/datetime64_extended_range/configs/clickhouse3/config.d/macros.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0"?>
+<yandex>
+    <macros>
+        <replica>clickhouse3</replica>
+        <shard>01</shard>
+        <shard2>03</shard2>
+    </macros>
+</yandex>
diff --git a/tests/testflows/datetime64_extended_range/docker-compose/clickhouse-service.yml b/tests/testflows/datetime64_extended_range/docker-compose/clickhouse-service.yml
new file mode 100644
index 00000000000..155028369bc
--- /dev/null
+++ b/tests/testflows/datetime64_extended_range/docker-compose/clickhouse-service.yml
@@ -0,0 +1,28 @@
+version: '2.3'
+
+services:
+    clickhouse:
+        image: yandex/clickhouse-integration-test
+        expose:
+            - "9000"
+            - "9009"
+            - "8123"
+        volumes:
+            - "${CLICKHOUSE_TESTS_DIR}/configs/clickhouse/config.d:/etc/clickhouse-server/config.d"
+            - "${CLICKHOUSE_TESTS_DIR}/configs/clickhouse/users.d/:/etc/clickhouse-server/users.d"
+            - "${CLICKHOUSE_TESTS_DIR}/configs/clickhouse/ssl:/etc/clickhouse-server/ssl"
+            - "${CLICKHOUSE_TESTS_DIR}/configs/clickhouse/config.xml:/etc/clickhouse-server/config.xml"
+            - "${CLICKHOUSE_TESTS_DIR}/configs/clickhouse/users.xml:/etc/clickhouse-server/users.xml"
+            - "${CLICKHOUSE_TESTS_SERVER_BIN_PATH:-/usr/bin/clickhouse}:/usr/bin/clickhouse"
+            - "${CLICKHOUSE_TESTS_ODBC_BRIDGE_BIN_PATH:-/usr/bin/clickhouse-odbc-bridge}:/usr/bin/clickhouse-odbc-bridge"
+        entrypoint: bash -c "clickhouse server --config-file=/etc/clickhouse-server/config.xml --log-file=/var/log/clickhouse-server/clickhouse-server.log --errorlog-file=/var/log/clickhouse-server/clickhouse-server.err.log"
+        healthcheck:
+            test: clickhouse client --query='select 1'
+            interval: 3s
+            timeout: 2s
+            retries: 40
+            start_period: 2s
+        cap_add:
+            - SYS_PTRACE
+        security_opt:
+            - label:disable
diff --git a/tests/testflows/datetime64_extended_range/docker-compose/docker-compose.yml b/tests/testflows/datetime64_extended_range/docker-compose/docker-compose.yml
new file mode 100644
index 00000000000..665e355d51e
--- /dev/null
+++ b/tests/testflows/datetime64_extended_range/docker-compose/docker-compose.yml
@@ -0,0 +1,61 @@
+version: '2.3'
+
+services:
+    zookeeper:
+        extends:
+            file: zookeeper-service.yml
+            service: zookeeper
+
+    clickhouse1:
+        extends:
+            file: clickhouse-service.yml
+            service: clickhouse
+        hostname: clickhouse1
+        volumes:
+            - "${CLICKHOUSE_TESTS_DIR}/_instances/clickhouse1/database/:/var/lib/clickhouse/"
+            - "${CLICKHOUSE_TESTS_DIR}/_instances/clickhouse1/logs/:/var/log/clickhouse-server/"
+            - "${CLICKHOUSE_TESTS_DIR}/configs/clickhouse1/config.d:/etc/clickhouse-server/config.d"
+            - "${CLICKHOUSE_TESTS_DIR}/configs/clickhouse1/users.d:/etc/clickhouse-server/users.d"
+        depends_on:
+            zookeeper:
+                condition: service_healthy
+
+    clickhouse2:
+        extends:
+            file: clickhouse-service.yml
+            service: clickhouse
+        hostname: clickhouse2
+        volumes:
+            - "${CLICKHOUSE_TESTS_DIR}/_instances/clickhouse2/database/:/var/lib/clickhouse/"
+            - "${CLICKHOUSE_TESTS_DIR}/_instances/clickhouse2/logs/:/var/log/clickhouse-server/"
+            - "${CLICKHOUSE_TESTS_DIR}/configs/clickhouse2/config.d:/etc/clickhouse-server/config.d"
+            - "${CLICKHOUSE_TESTS_DIR}/configs/clickhouse2/users.d:/etc/clickhouse-server/users.d"
+        depends_on:
+            zookeeper:
+                condition: service_healthy
+
+    clickhouse3:
+        extends:
+            file: clickhouse-service.yml
+            service: clickhouse
+        hostname: clickhouse3
+        volumes:
+            - "${CLICKHOUSE_TESTS_DIR}/_instances/clickhouse3/database/:/var/lib/clickhouse/"
+            - "${CLICKHOUSE_TESTS_DIR}/_instances/clickhouse3/logs/:/var/log/clickhouse-server/"
+            - "${CLICKHOUSE_TESTS_DIR}/configs/clickhouse3/config.d:/etc/clickhouse-server/config.d"
+            - "${CLICKHOUSE_TESTS_DIR}/configs/clickhouse3/users.d:/etc/clickhouse-server/users.d"
+        depends_on:
+            zookeeper:
+                condition: service_healthy
+
+    all_services_ready:
+        image: hello-world
+        depends_on:
+            clickhouse1:
+                condition: service_healthy
+            clickhouse2:
+                condition: service_healthy
+            clickhouse3:
+                condition: service_healthy
+            zookeeper:
+                condition: service_healthy
diff --git a/tests/testflows/datetime64_extended_range/docker-compose/zookeeper-service.yml b/tests/testflows/datetime64_extended_range/docker-compose/zookeeper-service.yml
new file mode 100644
index 00000000000..063b4307f13
--- /dev/null
+++ b/tests/testflows/datetime64_extended_range/docker-compose/zookeeper-service.yml
@@ -0,0 +1,18 @@
+version: '2.3'
+
+services:
+    zookeeper:
+        image: zookeeper:3.4.12
+        expose:
+            - "2181"
+        environment:
+            ZOO_TICK_TIME: 500
+            ZOO_MY_ID: 1
+        healthcheck:
+            test: echo stat | nc localhost 2181
+            interval: 3s
+            timeout: 2s
+            retries: 5
+            start_period: 2s
+        security_opt:
+            - label:disable
diff --git a/tests/testflows/datetime64_extended_range/regression.py b/tests/testflows/datetime64_extended_range/regression.py
new file mode 100755
index 00000000000..ad0b03bc7a4
--- /dev/null
+++ b/tests/testflows/datetime64_extended_range/regression.py
@@ -0,0 +1,79 @@
+#!/usr/bin/env python3
+import sys
+from testflows.core import *
+
+append_path(sys.path, "..")
+
+from helpers.cluster import Cluster
+from helpers.argparser import argparser
+from datetime64_extended_range.requirements import *
+from datetime64_extended_range.common import *
+
+# cross-outs
+# https://github.com/ClickHouse/ClickHouse/issues/16581#issuecomment-804360350: 128 and 256-bit types are not supported for now
+# https://github.com/ClickHouse/ClickHouse/issues/17079#issuecomment-783396589 : leap seconds unsupported
+# https://github.com/ClickHouse/ClickHouse/issues/22824 : dateDiff not working woth dt64
+# https://github.com/ClickHouse/ClickHouse/issues/22852 : formatDateTime wrong value
+# https://github.com/ClickHouse/ClickHouse/issues/22854 : timeSlot(), toMonday() wrong when out of normal
+# https://github.com/ClickHouse/ClickHouse/issues/16260 : timeSlots(), dateDiff() not working with DT64
+# https://github.com/ClickHouse/ClickHouse/issues/22927#issuecomment-816574952 : toRelative...Num() wrong when out of normal range
+# https://github.com/ClickHouse/ClickHouse/issues/22928 : toStartOf...() wrong when out of normal range
+# https://github.com/ClickHouse/ClickHouse/issues/22929 : toUnixTimestamp() exception when out of normal
+# https://github.com/ClickHouse/ClickHouse/issues/22930 : toWeek()
+# https://github.com/ClickHouse/ClickHouse/issues/22948 : toYearWeek()
+# https://github.com/ClickHouse/ClickHouse/issues/22959 : toUnixTimestamp64*() wrong fractal seconds treatment
+
+# For `reference times` test it is unclear how to evaluate correctness - majority of test cases are correct, and ONLY
+# Juba and Monrovia timezones are damaged - probably, due to wrong DST shifts lookup tables
+
+xfails = {
+    "type conversion/to int 8 16 32 64 128 256/:": [(Fail, "https://github.com/ClickHouse/ClickHouse/issues/16581#issuecomment-804360350")],
+    "type conversion/to uint 8 16 32 64 256/:": [(Fail, "https://github.com/ClickHouse/ClickHouse/issues/16581#issuecomment-804360350")],
+    "non existent time/leap seconds/:": [(Fail, "https://github.com/ClickHouse/ClickHouse/issues/17079#issuecomment-783396589")],
+    "date time funcs/date diff/:": [(Fail, "https://github.com/ClickHouse/ClickHouse/issues/22824")],
+    "date time funcs/format date time/:": [(Fail, "https://github.com/ClickHouse/ClickHouse/issues/22852")],
+    "date time funcs/time slot/:": [(Fail, "https://github.com/ClickHouse/ClickHouse/issues/22854")],
+    "date time funcs/to monday/:": [(Fail, "https://github.com/ClickHouse/ClickHouse/issues/22854")],
+    "date time funcs/time slots/:": [(Fail, "https://github.com/ClickHouse/ClickHouse/issues/16260")],
+    "date time funcs/to relative :/:": [(Fail, "https://github.com/ClickHouse/ClickHouse/issues/22927#issuecomment-816574952")],
+    "date time funcs/to start of :/:": [(Fail, "https://github.com/ClickHouse/ClickHouse/issues/22928")],
+    "date time funcs/to unix timestamp/:": [(Fail, "https://github.com/ClickHouse/ClickHouse/issues/22929")],
+    "date time funcs/to week/:": [(Fail, "https://github.com/ClickHouse/ClickHouse/issues/22930")],
+    "date time funcs/to year week/:": [(Fail, "https://github.com/ClickHouse/ClickHouse/issues/22948")],
+    "type conversion/to unix timestamp64 */:": [(Fail, "https://github.com/ClickHouse/ClickHouse/issues/22959")],
+    "type conversion/from unix timestamp64 */:": [(Fail, "https://github.com/ClickHouse/ClickHouse/issues/22959")],
+    "type conversion/to int 8 16 32 64 128 256/:": [(Fail, "https://github.com/ClickHouse/ClickHouse/issues/16581#issuecomment-804360350")],
+    "reference times/:": [(Fail, "check procedure unclear")],
+}
+
+
+@TestModule
+@Name("datetime64 extended range")
+@ArgumentParser(argparser)
+@Specifications(
+    QA_SRS010_ClickHouse_DateTime64_Extended_Range
+)
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange("1.0"),
+)
+@XFails(xfails)
+def regression(self, local, clickhouse_binary_path, parallel=False, stress=False):
+    """ClickHouse DateTime64 Extended Range regression module.
+    """
+    nodes = {
+        "clickhouse": ("clickhouse1", "clickhouse2", "clickhouse3"),
+    }
+
+    with Cluster(local, clickhouse_binary_path, nodes=nodes) as cluster:
+        self.context.cluster = cluster
+        self.context.parallel = parallel
+        self.context.stress = stress
+
+        Scenario(run=load("datetime64_extended_range.tests.generic", "generic"), flags=TE)
+        Scenario(run=load("datetime64_extended_range.tests.non_existent_time", "feature"), flags=TE)
+        Scenario(run=load("datetime64_extended_range.tests.reference_times", "reference_times"), flags=TE)
+        Scenario(run=load("datetime64_extended_range.tests.date_time_functions", "date_time_funcs"), flags=TE)
+        Scenario(run=load("datetime64_extended_range.tests.type_conversion", "type_conversion"), flags=TE)
+
+if main():
+    regression()
diff --git a/tests/testflows/datetime64_extended_range/requirements/__init__.py b/tests/testflows/datetime64_extended_range/requirements/__init__.py
new file mode 100644
index 00000000000..02f7d430154
--- /dev/null
+++ b/tests/testflows/datetime64_extended_range/requirements/__init__.py
@@ -0,0 +1 @@
+from .requirements import *
diff --git a/tests/testflows/datetime64_extended_range/requirements/requirements.md b/tests/testflows/datetime64_extended_range/requirements/requirements.md
new file mode 100644
index 00000000000..31d6f9aa677
--- /dev/null
+++ b/tests/testflows/datetime64_extended_range/requirements/requirements.md
@@ -0,0 +1,805 @@
+# QA-SRS010 ClickHouse DateTime64 Extended Range
+# Software Requirements Specification
+
+## Table of Contents
+
+* 1 [Revision History](#revision-history)
+* 2 [Introduction](#introduction)
+* 3 [Terminology](#terminology)
+  * 3.1 [SRS](#srs)
+  * 3.2 [Normal Date Range](#normal-date-range)
+  * 3.3 [Extended Date Range](#extended-date-range)
+* 4 [Requirements](#requirements)
+  * 4.1 [Generic](#generic)
+      * 4.1.0.1 [RQ.SRS-010.DateTime64.ExtendedRange](#rqsrs-010datetime64extendedrange)
+      * 4.1.0.2 [RQ.SRS-010.DateTime64.ExtendedRange.NormalRange.Start](#rqsrs-010datetime64extendedrangenormalrangestart)
+      * 4.1.0.3 [RQ.SRS-010.DateTime64.ExtendedRange.NormalRange.Start.BeforeEpochForTimeZone](#rqsrs-010datetime64extendedrangenormalrangestartbeforeepochfortimezone)
+      * 4.1.0.4 [RQ.SRS-010.DateTime64.ExtendedRange.NormalRange.End](#rqsrs-010datetime64extendedrangenormalrangeend)
+      * 4.1.0.5 [RQ.SRS-010.DateTime64.ExtendedRange.NormalRange.End.AfterEpochForTimeZone](#rqsrs-010datetime64extendedrangenormalrangeendafterepochfortimezone)
+      * 4.1.0.6 [RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions](#rqsrs-010datetime64extendedrangetypeconversionfunctions)
+      * 4.1.0.7 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions](#rqsrs-010datetime64extendedrangedatesandtimesfunctions)
+      * 4.1.0.8 [RQ.SRS-010.DateTime64.ExtendedRange.TimeZones](#rqsrs-010datetime64extendedrangetimezones)
+      * 4.1.0.9 [RQ.SRS-010.DateTime64.ExtendedRange.NonExistentTime](#rqsrs-010datetime64extendedrangenonexistenttime)
+      * 4.1.0.10 [RQ.SRS-010.DateTime64.ExtendedRange.Comparison](#rqsrs-010datetime64extendedrangecomparison)
+      * 4.1.0.11 [RQ.SRS-010.DateTime64.ExtendedRange.SpecificTimestamps](#rqsrs-010datetime64extendedrangespecifictimestamps)
+  * 4.2 [Specific](#specific)
+      * 4.2.0.1 [RQ.SRS-010.DateTime64.ExtendedRange.Start](#rqsrs-010datetime64extendedrangestart)
+      * 4.2.0.2 [RQ.SRS-010.DateTime64.ExtendedRange.End](#rqsrs-010datetime64extendedrangeend)
+      * 4.2.0.3 [Non-Existent Time](#non-existent-time)
+        * 4.2.0.3.1 [RQ.SRS-010.DateTime64.ExtendedRange.NonExistentTime.InvalidDate](#rqsrs-010datetime64extendedrangenonexistenttimeinvaliddate)
+        * 4.2.0.3.2 [RQ.SRS-010.DateTime64.ExtendedRange.NonExistentTime.InvalidTime](#rqsrs-010datetime64extendedrangenonexistenttimeinvalidtime)
+        * 4.2.0.3.3 [RQ.SRS-010.DateTime64.ExtendedRange.NonExistentTime.TimeZoneSwitch](#rqsrs-010datetime64extendedrangenonexistenttimetimezoneswitch)
+        * 4.2.0.3.4 [RQ.SRS-010.DateTime64.ExtendedRange.NonExistentTime.DaylightSavingTime](#rqsrs-010datetime64extendedrangenonexistenttimedaylightsavingtime)
+        * 4.2.0.3.5 [RQ.SRS-010.DateTime64.ExtendedRange.NonExistentTime.DaylightSavingTime.Disappeared](#rqsrs-010datetime64extendedrangenonexistenttimedaylightsavingtimedisappeared)
+        * 4.2.0.3.6 [RQ.SRS-010.DateTime64.ExtendedRange.NonExistentTime.LeapSeconds](#rqsrs-010datetime64extendedrangenonexistenttimeleapseconds)
+      * 4.2.0.4 [Dates And Times Functions](#dates-and-times-functions)
+        * 4.2.0.4.1 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toTimeZone](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstotimezone)
+        * 4.2.0.4.2 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toYear](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstoyear)
+        * 4.2.0.4.3 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toQuarter](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstoquarter)
+        * 4.2.0.4.4 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toMonth](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstomonth)
+        * 4.2.0.4.5 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toDayOfYear](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstodayofyear)
+        * 4.2.0.4.6 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toDayOfMonth](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstodayofmonth)
+        * 4.2.0.4.7 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toDayOfWeek](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstodayofweek)
+        * 4.2.0.4.8 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toHour](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstohour)
+        * 4.2.0.4.9 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toMinute](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstominute)
+        * 4.2.0.4.10 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toSecond](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstosecond)
+        * 4.2.0.4.11 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toUnixTimestamp](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstounixtimestamp)
+        * 4.2.0.4.12 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfYear](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstostartofyear)
+        * 4.2.0.4.13 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfISOYear](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstostartofisoyear)
+        * 4.2.0.4.14 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfQuarter](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstostartofquarter)
+        * 4.2.0.4.15 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfMonth](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstostartofmonth)
+        * 4.2.0.4.16 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toMonday](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstomonday)
+        * 4.2.0.4.17 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfWeek](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstostartofweek)
+        * 4.2.0.4.18 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfDay](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstostartofday)
+        * 4.2.0.4.19 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfHour](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstostartofhour)
+        * 4.2.0.4.20 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfMinute](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstostartofminute)
+        * 4.2.0.4.21 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfSecond](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstostartofsecond)
+        * 4.2.0.4.22 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfFiveMinute](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstostartoffiveminute)
+        * 4.2.0.4.23 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfTenMinutes](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstostartoftenminutes)
+        * 4.2.0.4.24 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfFifteenMinutes](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstostartoffifteenminutes)
+        * 4.2.0.4.25 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfInterval](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstostartofinterval)
+        * 4.2.0.4.26 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toTime](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstotime)
+        * 4.2.0.4.27 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeYearNum](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstorelativeyearnum)
+        * 4.2.0.4.28 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeQuarterNum](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstorelativequarternum)
+        * 4.2.0.4.29 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeMonthNum](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstorelativemonthnum)
+        * 4.2.0.4.30 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeWeekNum](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstorelativeweeknum)
+        * 4.2.0.4.31 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeDayNum](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstorelativedaynum)
+        * 4.2.0.4.32 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeHourNum](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstorelativehournum)
+        * 4.2.0.4.33 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeMinuteNum](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstorelativeminutenum)
+        * 4.2.0.4.34 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeSecondNum](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstorelativesecondnum)
+        * 4.2.0.4.35 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toISOYear](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstoisoyear)
+        * 4.2.0.4.36 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toISOWeek](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstoisoweek)
+        * 4.2.0.4.37 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toWeek](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstoweek)
+        * 4.2.0.4.38 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toYearWeek](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstoyearweek)
+        * 4.2.0.4.39 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.now](#rqsrs-010datetime64extendedrangedatesandtimesfunctionsnow)
+        * 4.2.0.4.40 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.today](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstoday)
+        * 4.2.0.4.41 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.yesterday](#rqsrs-010datetime64extendedrangedatesandtimesfunctionsyesterday)
+        * 4.2.0.4.42 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.timeSlot](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstimeslot)
+        * 4.2.0.4.43 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toYYYYMM](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstoyyyymm)
+        * 4.2.0.4.44 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toYYYYMMDD](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstoyyyymmdd)
+        * 4.2.0.4.45 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toYYYYMMDDhhmmss](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstoyyyymmddhhmmss)
+        * 4.2.0.4.46 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addYears](#rqsrs-010datetime64extendedrangedatesandtimesfunctionsaddyears)
+        * 4.2.0.4.47 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addMonths](#rqsrs-010datetime64extendedrangedatesandtimesfunctionsaddmonths)
+        * 4.2.0.4.48 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addWeeks](#rqsrs-010datetime64extendedrangedatesandtimesfunctionsaddweeks)
+        * 4.2.0.4.49 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addDays](#rqsrs-010datetime64extendedrangedatesandtimesfunctionsadddays)
+        * 4.2.0.4.50 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addHours](#rqsrs-010datetime64extendedrangedatesandtimesfunctionsaddhours)
+        * 4.2.0.4.51 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addMinutes](#rqsrs-010datetime64extendedrangedatesandtimesfunctionsaddminutes)
+        * 4.2.0.4.52 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addSeconds](#rqsrs-010datetime64extendedrangedatesandtimesfunctionsaddseconds)
+        * 4.2.0.4.53 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addQuarters](#rqsrs-010datetime64extendedrangedatesandtimesfunctionsaddquarters)
+        * 4.2.0.4.54 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractYears](#rqsrs-010datetime64extendedrangedatesandtimesfunctionssubtractyears)
+        * 4.2.0.4.55 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractMonths](#rqsrs-010datetime64extendedrangedatesandtimesfunctionssubtractmonths)
+        * 4.2.0.4.56 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractWeeks](#rqsrs-010datetime64extendedrangedatesandtimesfunctionssubtractweeks)
+        * 4.2.0.4.57 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractDays](#rqsrs-010datetime64extendedrangedatesandtimesfunctionssubtractdays)
+        * 4.2.0.4.58 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractHours](#rqsrs-010datetime64extendedrangedatesandtimesfunctionssubtracthours)
+        * 4.2.0.4.59 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractMinutes](#rqsrs-010datetime64extendedrangedatesandtimesfunctionssubtractminutes)
+        * 4.2.0.4.60 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractSeconds](#rqsrs-010datetime64extendedrangedatesandtimesfunctionssubtractseconds)
+        * 4.2.0.4.61 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractQuarters](#rqsrs-010datetime64extendedrangedatesandtimesfunctionssubtractquarters)
+        * 4.2.0.4.62 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.dateDiff](#rqsrs-010datetime64extendedrangedatesandtimesfunctionsdatediff)
+        * 4.2.0.4.63 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.timeSlots](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstimeslots)
+        * 4.2.0.4.64 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.formatDateTime](#rqsrs-010datetime64extendedrangedatesandtimesfunctionsformatdatetime)
+    * 4.2.1 [Type Conversion Functions](#type-conversion-functions)
+        * 4.2.1.4.1 [RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toInt(8|16|32|64|128|256)](#rqsrs-010datetime64extendedrangetypeconversionfunctionstoint8163264128256)
+        * 4.2.1.4.2 [RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toUInt(8|16|32|64|256)](#rqsrs-010datetime64extendedrangetypeconversionfunctionstouint8163264256)
+        * 4.2.1.4.3 [RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toFloat(32|64)](#rqsrs-010datetime64extendedrangetypeconversionfunctionstofloat3264)
+        * 4.2.1.4.4 [RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toDate](#rqsrs-010datetime64extendedrangetypeconversionfunctionstodate)
+        * 4.2.1.4.5 [RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toDateTime](#rqsrs-010datetime64extendedrangetypeconversionfunctionstodatetime)
+        * 4.2.1.4.6 [RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toDateTime64](#rqsrs-010datetime64extendedrangetypeconversionfunctionstodatetime64)
+        * 4.2.1.4.7 [RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toDateTime64.FromString.MissingTime](#rqsrs-010datetime64extendedrangetypeconversionfunctionstodatetime64fromstringmissingtime)
+        * 4.2.1.4.8 [RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toDecimal(32|64|128|256)](#rqsrs-010datetime64extendedrangetypeconversionfunctionstodecimal3264128256)
+        * 4.2.1.4.9 [RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toString](#rqsrs-010datetime64extendedrangetypeconversionfunctionstostring)
+        * 4.2.1.4.10 [RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.CAST(x,T)](#rqsrs-010datetime64extendedrangetypeconversionfunctionscastxt)
+        * 4.2.1.4.11 [RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toUnixTimestamp64Milli](#rqsrs-010datetime64extendedrangetypeconversionfunctionstounixtimestamp64milli)
+        * 4.2.1.4.12 [RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toUnixTimestamp64Micro](#rqsrs-010datetime64extendedrangetypeconversionfunctionstounixtimestamp64micro)
+        * 4.2.1.4.13 [RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toUnixTimestamp64Nano](#rqsrs-010datetime64extendedrangetypeconversionfunctionstounixtimestamp64nano)
+        * 4.2.1.4.14 [RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.fromUnixTimestamp64Milli](#rqsrs-010datetime64extendedrangetypeconversionfunctionsfromunixtimestamp64milli)
+        * 4.2.1.4.15 [RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.fromUnixTimestamp64Micro](#rqsrs-010datetime64extendedrangetypeconversionfunctionsfromunixtimestamp64micro)
+        * 4.2.1.4.16 [RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.fromUnixTimestamp64Nano](#rqsrs-010datetime64extendedrangetypeconversionfunctionsfromunixtimestamp64nano)
+* 5 [References](#references)
+
+## Revision History
+
+This document is stored in an electronic form using [Git] source control management software
+hosted in a [GitHub Repository].
+All the updates are tracked using the [Revision History].
+
+## Introduction
+
+This document will cover requirements to support extended range for the [DateTime64] data type
+that is outside the normal **1970** (1970-01-02 00:00:00 UTC) to **2105** (2105-12-31 23:59:59.99999 UTC) date range.
+
+## Terminology
+
+### SRS
+
+Software Requirements Specification
+
+### Normal Date Range
+
+**1970** `1970-01-02T00:00:00.000000` to **2105** `2105-12-31T23:59:59.99999`
+
+### Extended Date Range
+
+**1925** `1925-01-01T00:00:00.000000` to **2238** `2238-12-31 23:59:59.99999`
+
+## Requirements
+
+### Generic
+
+##### RQ.SRS-010.DateTime64.ExtendedRange
+version: 1.0
+
+[ClickHouse] SHALL support extended range for the [DateTime64] data type that includes dates from the year **1925** to **2238**.
+
+##### RQ.SRS-010.DateTime64.ExtendedRange.NormalRange.Start
+version: 1.0
+
+[ClickHouse] SHALL support proper time handling around the normal date range that starts at `1970-01-01 00:00:00.000`
+expressed using the [ISO 8601 format].
+
+##### RQ.SRS-010.DateTime64.ExtendedRange.NormalRange.Start.BeforeEpochForTimeZone
+version: 1.0
+
+[ClickHouse] SHALL support proper time handling around the start of the [normal date range]
+when this time for the time zone is before the start of the [normal date range].
+
+##### RQ.SRS-010.DateTime64.ExtendedRange.NormalRange.End
+version: 1.0
+
+[ClickHouse] SHALL support proper time handling around the normal date range that ends at `2105-12-31T23:59:59.99999`
+expressed using the [ISO 8601 format].
+
+##### RQ.SRS-010.DateTime64.ExtendedRange.NormalRange.End.AfterEpochForTimeZone
+version: 1.0
+
+[ClickHouse] SHALL support proper time handling around the end of the [normal date range]
+when this time for the time zone is after the end of the [normal date range].
+
+##### RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions
+version: 1.0
+
+[ClickHouse] SHALL support proper conversion to and from [DateTime64] data type from other data types.
+
+##### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [Dates and Times Functions] with the [DateTime64] data type
+when it stores dates within the [normal date range] and the [extended date range].
+
+##### RQ.SRS-010.DateTime64.ExtendedRange.TimeZones
+version: 1.0
+
+[ClickHouse] SHALL support correct operation with the [DateTime64] extended range data type
+when combined with a supported time zone.
+
+##### RQ.SRS-010.DateTime64.ExtendedRange.NonExistentTime
+version: 1.0
+
+[ClickHouse] SHALL support proper handling of non-existent times when using [DateTime64] extended range data type.
+
+##### RQ.SRS-010.DateTime64.ExtendedRange.Comparison
+version: 1.0
+
+[ClickHouse] SHALL support proper handling of time comparison when using [DateTime64] extended range data type.
+For example, `SELECT toDateTime64('2019-05-05 20:20:12.050', 3) < now()`.
+
+##### RQ.SRS-010.DateTime64.ExtendedRange.SpecificTimestamps
+version: 1.0
+
+[ClickHouse] SHALL properly work with the following timestamps in all supported timezones:
+```
+[9961200,73476000,325666800,354675600,370400400,386125200,388566010,401850000,417574811,496803600,528253200,624423614,636516015,671011200,717555600,752047218,859683600,922582800,1018173600,1035705600,1143334800,1162105223,1174784400,1194156000,1206838823,1224982823,1236495624,1319936400,1319936424,1425798025,1459040400,1509872400,2090451627,2140668000]
+```
+
+
+### Specific
+
+##### RQ.SRS-010.DateTime64.ExtendedRange.Start
+version: 1.0
+
+[ClickHouse] SHALL support extended range for the [DateTime64] data type that starts at `1925-01-01T00:00:00.000000`
+expressed using the [ISO 8601 format].
+
+##### RQ.SRS-010.DateTime64.ExtendedRange.End
+version: 1.0
+
+[ClickHouse] SHALL support extended range for the [DateTime64] data type that ends at `2238-12-31T23:59:59.999999`
+expressed using the [ISO 8601 format].
+
+##### Non-Existent Time
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.NonExistentTime.InvalidDate
+version: 1.0
+
+[ClickHouse] SHALL support proper handling of invalid dates when using [DateTime64] extended range data type,
+such as:
+
+* `YYYY-04-31, YYYY-06-31, YYYY-09-31, YYYY-11-31`
+* `1990-02-30 00:00:02`
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.NonExistentTime.InvalidTime
+version: 1.0
+
+[ClickHouse] SHALL support proper handling of invalid time for a timezone
+when using [DateTime64] extended range data type, for example,
+
+* `2002-04-07 02:30:00` never happened at all in the US/Eastern timezone ([Stuart Bishop: pytz library](http://pytz.sourceforge.net/#problems-with-localtime))
+
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.NonExistentTime.TimeZoneSwitch
+version: 1.0
+
+[ClickHouse] SHALL support proper handling of invalid time when using [DateTime64] extended range data type
+when the invalid time is caused when *countries switch timezone definitions with no
+daylight savings time switch* [Stuart Bishop: pytz library](http://pytz.sourceforge.net/#problems-with-localtime).
+
+>
+> For example, in 1915 Warsaw switched from Warsaw time to Central European time with
+> no daylight savings transition. So at the stroke of midnight on August 5th 1915 the clocks
+> were wound back 24 minutes creating an ambiguous time period that cannot be specified without
+> referring to the timezone abbreviation or the actual UTC offset. In this case midnight happened twice,
+> neither time during a daylight saving time period. pytz handles this transition by treating the ambiguous
+> period before the switch as daylight savings time, and the ambiguous period after as standard time.
+>
+> [Stuart Bishop: pytz library](http://pytz.sourceforge.net/#problems-with-localtime)
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.NonExistentTime.DaylightSavingTime
+version: 1.0
+
+[ClickHouse] SHALL support proper handling of invalid time when using [DateTime64] extended range data type
+when for a given timezone time switches from standard to daylight saving.
+
+> For example, in the US/Eastern timezone on the last Sunday morning in October, the following sequence happens:
+>
+> 01:00 EDT occurs
+> 1 hour later, instead of 2:00am the clock is turned back 1 hour and 01:00 happens again (this time 01:00 EST)
+> In fact, every instant between 01:00 and 02:00 occurs twice.
+> [Stuart Bishop: pytz library](http://pytz.sourceforge.net/#problems-with-localtime)
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.NonExistentTime.DaylightSavingTime.Disappeared
+version: 1.0
+
+[ClickHouse] SHALL support proper handling of invalid time when using [DateTime64] extended range data type
+for a given timezone when transition from the standard to daylight saving time causes an hour to disappear.
+
+Expected behavior: if DateTime64 initialized by a skipped time value, it is being treated as DST and resulting value will be an hour earlier, e.g. `SELECT toDateTime64('2020-03-08 02:34:00', 0, 'America/Denver')` returns `2020-03-08 01:34:00`.
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.NonExistentTime.LeapSeconds
+version: 1.0
+
+[ClickHouse] SHALL support proper handling of leap seconds adjustments when using [DateTime64] extended range data type.
+
+##### Dates And Times Functions
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toTimeZone
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toTimeZone](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#totimezone)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toYear
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toYear](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#toyear)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toQuarter
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toQuarter](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#toquarter)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toMonth
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toMonth](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tomonth)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toDayOfYear
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toDayOfYear](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#todayofyear)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toDayOfMonth
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toDayOfMonth](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#todayofmonth)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toDayOfWeek
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toDayOfWeek](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#todayofweek)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toHour
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toHour](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tohour)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toMinute
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toMinute](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tominute)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toSecond
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toSecond](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tosecond)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toUnixTimestamp
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toUnitTimestamp](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#to-unix-timestamp)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+Timestamp value expected to be negative when DateTime64 value is prior to `1970-01-01` and positine otherwise.
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfYear
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toStartOfYear](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tostartofyear)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfISOYear
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toStartOfISOYear](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tostartofisoyear)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfQuarter
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toStartOfQuarter](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tostartofquarter)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfMonth
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toStartOfMonth](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tostartofmonth)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toMonday
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toMonday](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tomonday)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfWeek
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toStartOfWeek](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tostartofweektmode)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfDay
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toStartOfDay](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tostartofday)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfHour
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toStartOfHour](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tostartofhour)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfMinute
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toStartOfMinute](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tostartofminute)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfSecond
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toStartOfSecond](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tostartofsecond)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfFiveMinute
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toStartOfFiveMinute](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tostartoffiveminute)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfTenMinutes
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toStartOfTenMinutes](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tostartoftenminutes)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfFifteenMinutes
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toStartOfFifteenMinutes](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tostartoffifteenminutes)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfInterval
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toStartOfInterval](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tostartofintervaltime-or-data-interval-x-unit-time-zone)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+More detailed description can be found [here](https://github.com/ClickHouse/ClickHouse/issues/1201).
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toTime
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toTime](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#totime)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeYearNum
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toRelativeYearNum](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#torelativeyearnum)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeQuarterNum
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toRelativeQuarterNum](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#torelativequarternum)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeMonthNum
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toRelativeMonthNum](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#torelativemonthnum)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeWeekNum
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toRelativeWeekNum](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#torelativeweeknum)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeDayNum
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toRelativeDayNum](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#torelativedaynum)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeHourNum
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toRelativeHourNum](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#torelativehournum)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeMinuteNum
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toRelativeMinuteNum](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#torelativeminutenum)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeSecondNum
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toRelativeSecondNum](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#torelativesecondnum)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toISOYear
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toISOYear](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#toisoyear)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toISOWeek
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toISOWeek](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#toisoweek)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toWeek
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toWeek](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#toweekdatemode)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toYearWeek
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toYearWeek](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#toyearweekdatemode)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.now
+version: 1.0
+
+[ClickHouse] SHALL support conversion of output from the [now](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#now)
+function to the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.today
+version: 1.0
+
+[ClickHouse] SHALL support conversion of output from the [today](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#today)
+function to the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.yesterday
+version: 1.0
+
+[ClickHouse] SHALL support conversion of output from the [yesterday](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#yesterday)
+function to the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.timeSlot
+version: 1.0
+
+[ClickHouse] SHALL support conversion of output from the [timeSlot](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#timeslot)
+function to the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toYYYYMM
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toYYYYMM](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#toyyyymm)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toYYYYMMDD
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toYYYYMMDD](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#toyyyymmdd)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toYYYYMMDDhhmmss
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toYYYYMMDDhhmmss](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#toyyyymmddhhmmss)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addYears
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [addYears](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#addyears-addmonths-addweeks-adddays-addhours-addminutes-addseconds-addquarters)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addMonths
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [addMonths](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#addyears-addmonths-addweeks-adddays-addhours-addminutes-addseconds-addquarters)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addWeeks
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [addWeeks](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#addyears-addmonths-addweeks-adddays-addhours-addminutes-addseconds-addquarters)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addDays
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [addDays](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#addyears-addmonths-addweeks-adddays-addhours-addminutes-addseconds-addquarters)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addHours
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [addHours](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#addyears-addmonths-addweeks-adddays-addhours-addminutes-addseconds-addquarters)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addMinutes
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [addMinutes](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#addyears-addmonths-addweeks-adddays-addhours-addminutes-addseconds-addquarters)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addSeconds
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [addSeconds](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#addyears-addmonths-addweeks-adddays-addhours-addminutes-addseconds-addquarters)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addQuarters
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [addQuarters](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#addyears-addmonths-addweeks-adddays-addhours-addminutes-addseconds-addquarters)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractYears
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [subtractYears](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#subtractyears-subtractmonths-subtractweeks-subtractdays-subtracthours-subtractminutes-subtractseconds-subtractquarters)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractMonths
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [subtractMonths](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#subtractyears-subtractmonths-subtractweeks-subtractdays-subtracthours-subtractminutes-subtractseconds-subtractquarters)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractWeeks
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [subtractWeeks](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#subtractyears-subtractmonths-subtractweeks-subtractdays-subtracthours-subtractminutes-subtractseconds-subtractquarters)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractDays
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [subtractDays](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#subtractyears-subtractmonths-subtractweeks-subtractdays-subtracthours-subtractminutes-subtractseconds-subtractquarters)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractHours
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [subtractHours](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#subtractyears-subtractmonths-subtractweeks-subtractdays-subtracthours-subtractminutes-subtractseconds-subtractquarters)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractMinutes
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [subtractMinutes](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#subtractyears-subtractmonths-subtractweeks-subtractdays-subtracthours-subtractminutes-subtractseconds-subtractquarters)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractSeconds
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [subtractSeconds](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#subtractyears-subtractmonths-subtractweeks-subtractdays-subtracthours-subtractminutes-subtractseconds-subtractquarters)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractQuarters
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [subtractQuarters](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#subtractyears-subtractmonths-subtractweeks-subtractdays-subtracthours-subtractminutes-subtractseconds-subtractquarters)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.dateDiff
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [dateDiff](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#datediff)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.timeSlots
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [timeSlots](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#timeslotsstarttime-duration-size)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.formatDateTime
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [formatDateTime](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#formatdatetime)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+
+#### Type Conversion Functions
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toInt(8|16|32|64|128|256)
+version: 1.0
+
+[ClickHouse] SHALL support correct conversion of the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range]
+to integer types using [toInt(8|16|32|64|128|256)](https://clickhouse.tech/docs/en/sql-reference/functions/type-conversion-functions/#toint8163264128256) functions.
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toUInt(8|16|32|64|256)
+version: 1.0
+
+[ClickHouse] SHALL support correct conversion of the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range]
+to unsigned integer types using [toUInt(8|16|32|64|256)](https://clickhouse.tech/docs/en/sql-reference/functions/type-conversion-functions/#touint8163264256) functions.
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toFloat(32|64)
+version: 1.0
+
+[ClickHouse] SHALL support correct conversion of the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range]
+to float types using [toFloat(32|64)](https://clickhouse.tech/docs/en/sql-reference/functions/type-conversion-functions/#tofloat3264) functions.
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toDate
+version: 1.0
+
+[ClickHouse] SHALL support correct conversion of the [DateTime64] data type when it stores dates within the [normal date range]
+to the [Date](https://clickhouse.tech/docs/en/sql-reference/data-types/date/) type using the [toDate](https://clickhouse.tech/docs/en/sql-reference/functions/type-conversion-functions/#todate) function.
+This function is ONLY supposed to work in NORMAL RANGE.
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toDateTime
+version: 1.0
+
+[ClickHouse] SHALL support correct conversion of the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range]
+to the [DateTime](https://clickhouse.tech/docs/en/sql-reference/data-types/datetime/) type using the [toDateTime](https://clickhouse.tech/docs/en/sql-reference/functions/type-conversion-functions/#todatetime) function.
+This function is ONLY supposed to work in NORMAL RANGE.
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toDateTime64
+version: 1.0
+
+[ClickHouse] SHALL support correct conversion from the data types supported by the [toDateTime64](https://clickhouse.tech/docs/en/sql-reference/data-types/datetime64/) function
+to the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toDateTime64.FromString.MissingTime
+version: 1.0
+
+[ClickHouse] SHALL support correct conversion from the [String](https://clickhouse.tech/docs/en/sql-reference/data-types/string/)
+data type to the [DateTime64](https://clickhouse.tech/docs/en/sql-reference/data-types/datetime64/) data type
+when value of the string is missing the `hh:mm-ss.sss` part.
+For example, `toDateTime64('2020-01-01', 3)`.
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toDecimal(32|64|128|256)
+version: 1.0
+
+[ClickHouse] SHALL support correct conversion of the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range]
+to [Decimal](https://clickhouse.tech/docs/en/sql-reference/data-types/decimal/) types using [toDecimal(32|64|128|256)](https://clickhouse.tech/docs/en/sql-reference/functions/type-conversion-functions/#todecimal3264128256) functions.
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toString
+version: 1.0
+
+[ClickHouse] SHALL support correct conversion of the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range]
+to the [String](https://clickhouse.tech/docs/en/sql-reference/data-types/string/) type using the [toString](https://clickhouse.tech/docs/en/sql-reference/functions/type-conversion-functions/#tostring) function.
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.CAST(x,T)
+version: 1.0
+
+[ClickHouse] SHALL support correct conversion of the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range]
+to one of the supported data type using the [CAST(x,T)](https://clickhouse.tech/docs/en/sql-reference/functions/type-conversion-functions/#type_conversion_function-cast) function.
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toUnixTimestamp64Milli
+version: 1.0
+
+[ClickHouse] SHALL support correct conversion of the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range]
+to the [Int64](https://clickhouse.tech/docs/en/sql-reference/data-types/int-uint/) type using the [toUnixTimestamp64Milli](https://clickhouse.tech/docs/en/sql-reference/functions/type-conversion-functions/#tounixtimestamp64milli) function.
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toUnixTimestamp64Micro
+version: 1.0
+
+[ClickHouse] SHALL support correct conversion of the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range]
+to the [Int64](https://clickhouse.tech/docs/en/sql-reference/data-types/int-uint/) type using the [toUnixTimestamp64Micro](https://clickhouse.tech/docs/en/sql-reference/functions/type-conversion-functions/#tounixtimestamp64micro) function.
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toUnixTimestamp64Nano
+version: 1.0
+
+[ClickHouse] SHALL support correct conversion of the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range]
+to the [Int64](https://clickhouse.tech/docs/en/sql-reference/data-types/int-uint/) type using the [toUnixTimestamp64Nano](https://clickhouse.tech/docs/en/sql-reference/functions/type-conversion-functions/#tounixtimestamp64nano) function.
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.fromUnixTimestamp64Milli
+version: 1.0
+
+[ClickHouse] SHALL support correct conversion from the [Int64](https://clickhouse.tech/docs/en/sql-reference/data-types/int-uint/) type
+to the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range]
+using the [fromUnixTimestamp64Milli](https://clickhouse.tech/docs/en/sql-reference/functions/type-conversion-functions/#fromunixtimestamp64milli) function.
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.fromUnixTimestamp64Micro
+version: 1.0
+
+[ClickHouse] SHALL support correct conversion from the [Int64](https://clickhouse.tech/docs/en/sql-reference/data-types/int-uint/) type
+to the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range]
+using the [fromUnixTimestamp64Micro](https://clickhouse.tech/docs/en/sql-reference/functions/type-conversion-functions/#fromunixtimestamp64micro) function.
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.fromUnixTimestamp64Nano
+version: 1.0
+
+[ClickHouse] SHALL support correct conversion from the [Int64](https://clickhouse.tech/docs/en/sql-reference/data-types/int-uint/) type
+to the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range]
+using the [fromUnixTimestamp64Nano](https://clickhouse.tech/docs/en/sql-reference/functions/type-conversion-functions/#fromunixtimestamp64nano) function.
+
+## References
+
+* **DateTime64**: https://clickhouse.tech/docs/en/sql-reference/data-types/datetime64/
+* **ISO 8601 format**: https://en.wikipedia.org/wiki/ISO_8601
+* **ClickHouse:** https://clickhouse.tech
+* **GitHub Repository:** https://github.com/ClickHouse/ClickHouse/blob/master/tests/testflows/datetime64_extended_range/requirements/requirements.md
+* **Revision History:** https://github.com/ClickHouse/ClickHouse/commits/master/tests/testflows/datetime64_extended_range/requirements/requirements.md
+* **Git:** https://git-scm.com/
+
+[SRS]: #srs
+[normal date range]: #normal-date-range
+[extended date range]: #extended-date-range
+[Dates and Times Functions]: https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/
+[DateTime64]: https://clickhouse.tech/docs/en/sql-reference/data-types/datetime64/
+[ISO 8601 format]: https://en.wikipedia.org/wiki/ISO_8601
+[ClickHouse]: https://clickhouse.tech
+[GitHub Repository]: https://github.com/ClickHouse/ClickHouse/blob/master/tests/testflows/datetime64_extended_range/requirements/requirements.md
+[Revision History]: https://github.com/ClickHouse/ClickHouse/commits/master/tests/testflows/datetime64_extended_range/requirements/requirements.md
+[Git]: https://git-scm.com/
+[GitHub]: https://github.com
diff --git a/tests/testflows/datetime64_extended_range/requirements/requirements.py b/tests/testflows/datetime64_extended_range/requirements/requirements.py
new file mode 100644
index 00000000000..b6c90866e84
--- /dev/null
+++ b/tests/testflows/datetime64_extended_range/requirements/requirements.py
@@ -0,0 +1,2668 @@
+# These requirements were auto generated
+# from software requirements specification (SRS)
+# document by TestFlows v1.6.210312.1172513.
+# Do not edit by hand but re-generate instead
+# using 'tfs requirements generate' command.
+from testflows.core import Specification
+from testflows.core import Requirement
+
+Heading = Specification.Heading
+
+RQ_SRS_010_DateTime64_ExtendedRange = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support extended range for the [DateTime64] data type that includes dates from the year **1925** to **2238**.\n'
+        '\n'
+        ),
+    link=None,
+    level=4,
+    num='4.1.0.1')
+
+RQ_SRS_010_DateTime64_ExtendedRange_NormalRange_Start = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.NormalRange.Start',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support proper time handling around the normal date range that starts at `1970-01-01 00:00:00.000`\n'
+        'expressed using the [ISO 8601 format].\n'
+        '\n'
+        ),
+    link=None,
+    level=4,
+    num='4.1.0.2')
+
+RQ_SRS_010_DateTime64_ExtendedRange_NormalRange_Start_BeforeEpochForTimeZone = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.NormalRange.Start.BeforeEpochForTimeZone',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support proper time handling around the start of the [normal date range]\n'
+        'when this time for the time zone is before the start of the [normal date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=4,
+    num='4.1.0.3')
+
+RQ_SRS_010_DateTime64_ExtendedRange_NormalRange_End = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.NormalRange.End',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support proper time handling around the normal date range that ends at `2105-12-31T23:59:59.99999`\n'
+        'expressed using the [ISO 8601 format].\n'
+        '\n'
+        ),
+    link=None,
+    level=4,
+    num='4.1.0.4')
+
+RQ_SRS_010_DateTime64_ExtendedRange_NormalRange_End_AfterEpochForTimeZone = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.NormalRange.End.AfterEpochForTimeZone',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support proper time handling around the end of the [normal date range]\n'
+        'when this time for the time zone is after the end of the [normal date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=4,
+    num='4.1.0.5')
+
+RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support proper conversion to and from [DateTime64] data type from other data types.\n'
+        '\n'
+        ),
+    link=None,
+    level=4,
+    num='4.1.0.6')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [Dates and Times Functions] with the [DateTime64] data type\n'
+        'when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=4,
+    num='4.1.0.7')
+
+RQ_SRS_010_DateTime64_ExtendedRange_TimeZones = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.TimeZones',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation with the [DateTime64] extended range data type\n'
+        'when combined with a supported time zone.\n'
+        '\n'
+        ),
+    link=None,
+    level=4,
+    num='4.1.0.8')
+
+RQ_SRS_010_DateTime64_ExtendedRange_NonExistentTime = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.NonExistentTime',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support proper handling of non-existent times when using [DateTime64] extended range data type.\n'
+        '\n'
+        ),
+    link=None,
+    level=4,
+    num='4.1.0.9')
+
+RQ_SRS_010_DateTime64_ExtendedRange_Comparison = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.Comparison',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support proper handling of time comparison when using [DateTime64] extended range data type.\n'
+        "For example, `SELECT toDateTime64('2019-05-05 20:20:12.050', 3) < now()`.\n"
+        '\n'
+        ),
+    link=None,
+    level=4,
+    num='4.1.0.10')
+
+RQ_SRS_010_DateTime64_ExtendedRange_SpecificTimestamps = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.SpecificTimestamps',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL properly work with the following timestamps in all supported timezones:\n'
+        '```\n'
+        '[9961200,73476000,325666800,354675600,370400400,386125200,388566010,401850000,417574811,496803600,528253200,624423614,636516015,671011200,717555600,752047218,859683600,922582800,1018173600,1035705600,1143334800,1162105223,1174784400,1194156000,1206838823,1224982823,1236495624,1319936400,1319936424,1425798025,1459040400,1509872400,2090451627,2140668000]\n'
+        '```\n'
+        '\n'
+        '\n'
+        ),
+    link=None,
+    level=4,
+    num='4.1.0.11')
+
+RQ_SRS_010_DateTime64_ExtendedRange_Start = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.Start',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support extended range for the [DateTime64] data type that starts at `1925-01-01T00:00:00.000000`\n'
+        'expressed using the [ISO 8601 format].\n'
+        '\n'
+        ),
+    link=None,
+    level=4,
+    num='4.2.0.1')
+
+RQ_SRS_010_DateTime64_ExtendedRange_End = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.End',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support extended range for the [DateTime64] data type that ends at `2238-12-31T23:59:59.999999`\n'
+        'expressed using the [ISO 8601 format].\n'
+        '\n'
+        ),
+    link=None,
+    level=4,
+    num='4.2.0.2')
+
+RQ_SRS_010_DateTime64_ExtendedRange_NonExistentTime_InvalidDate = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.NonExistentTime.InvalidDate',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support proper handling of invalid dates when using [DateTime64] extended range data type,\n'
+        'such as:\n'
+        '\n'
+        '* `YYYY-04-31, YYYY-06-31, YYYY-09-31, YYYY-11-31`\n'
+        '* `1990-02-30 00:00:02`\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.3.1')
+
+RQ_SRS_010_DateTime64_ExtendedRange_NonExistentTime_InvalidTime = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.NonExistentTime.InvalidTime',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support proper handling of invalid time for a timezone\n'
+        'when using [DateTime64] extended range data type, for example,\n'
+        '\n'
+        '* `2002-04-07 02:30:00` never happened at all in the US/Eastern timezone ([Stuart Bishop: pytz library](http://pytz.sourceforge.net/#problems-with-localtime))\n'
+        '\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.3.2')
+
+RQ_SRS_010_DateTime64_ExtendedRange_NonExistentTime_TimeZoneSwitch = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.NonExistentTime.TimeZoneSwitch',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support proper handling of invalid time when using [DateTime64] extended range data type\n'
+        'when the invalid time is caused when *countries switch timezone definitions with no\n'
+        'daylight savings time switch* [Stuart Bishop: pytz library](http://pytz.sourceforge.net/#problems-with-localtime).\n'
+        '\n'
+        '>\n'
+        '> For example, in 1915 Warsaw switched from Warsaw time to Central European time with\n'
+        '> no daylight savings transition. So at the stroke of midnight on August 5th 1915 the clocks\n'
+        '> were wound back 24 minutes creating an ambiguous time period that cannot be specified without\n'
+        '> referring to the timezone abbreviation or the actual UTC offset. In this case midnight happened twice,\n'
+        '> neither time during a daylight saving time period. pytz handles this transition by treating the ambiguous\n'
+        '> period before the switch as daylight savings time, and the ambiguous period after as standard time.\n'
+        '>\n'
+        '> [Stuart Bishop: pytz library](http://pytz.sourceforge.net/#problems-with-localtime)\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.3.3')
+
+RQ_SRS_010_DateTime64_ExtendedRange_NonExistentTime_DaylightSavingTime = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.NonExistentTime.DaylightSavingTime',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support proper handling of invalid time when using [DateTime64] extended range data type\n'
+        'when for a given timezone time switches from standard to daylight saving.\n'
+        '\n'
+        '> For example, in the US/Eastern timezone on the last Sunday morning in October, the following sequence happens:\n'
+        '>\n'
+        '> 01:00 EDT occurs\n'
+        '> 1 hour later, instead of 2:00am the clock is turned back 1 hour and 01:00 happens again (this time 01:00 EST)\n'
+        '> In fact, every instant between 01:00 and 02:00 occurs twice.\n'
+        '> [Stuart Bishop: pytz library](http://pytz.sourceforge.net/#problems-with-localtime)\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.3.4')
+
+RQ_SRS_010_DateTime64_ExtendedRange_NonExistentTime_DaylightSavingTime_Disappeared = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.NonExistentTime.DaylightSavingTime.Disappeared',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support proper handling of invalid time when using [DateTime64] extended range data type\n'
+        'for a given timezone when transition from the standard to daylight saving time causes an hour to disappear.\n'
+        '\n'
+        "Expected behavior: if DateTime64 initialized by a skipped time value, it is being treated as DST and resulting value will be an hour earlier, e.g. `SELECT toDateTime64('2020-03-08 02:34:00', 0, 'America/Denver')` returns `2020-03-08 01:34:00`.\n"
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.3.5')
+
+RQ_SRS_010_DateTime64_ExtendedRange_NonExistentTime_LeapSeconds = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.NonExistentTime.LeapSeconds',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support proper handling of leap seconds adjustments when using [DateTime64] extended range data type.\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.3.6')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toTimeZone = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toTimeZone',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [toTimeZone](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#totimezone)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.1')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toYear = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toYear',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [toYear](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#toyear)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.2')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toQuarter = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toQuarter',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [toQuarter](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#toquarter)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.3')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toMonth = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toMonth',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [toMonth](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tomonth)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.4')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toDayOfYear = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toDayOfYear',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [toDayOfYear](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#todayofyear)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.5')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toDayOfMonth = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toDayOfMonth',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [toDayOfMonth](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#todayofmonth)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.6')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toDayOfWeek = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toDayOfWeek',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [toDayOfWeek](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#todayofweek)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.7')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toHour = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toHour',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [toHour](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tohour)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.8')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toMinute = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toMinute',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [toMinute](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tominute)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.9')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toSecond = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toSecond',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [toSecond](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tosecond)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.10')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toUnixTimestamp = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toUnixTimestamp',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [toUnitTimestamp](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#to-unix-timestamp)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        'Timestamp value expected to be negative when DateTime64 value is prior to `1970-01-01` and positine otherwise.\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.11')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toStartOfYear = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfYear',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [toStartOfYear](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tostartofyear)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.12')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toStartOfISOYear = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfISOYear',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [toStartOfISOYear](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tostartofisoyear)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.13')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toStartOfQuarter = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfQuarter',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [toStartOfQuarter](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tostartofquarter)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.14')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toStartOfMonth = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfMonth',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [toStartOfMonth](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tostartofmonth)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.15')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toMonday = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toMonday',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [toMonday](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tomonday)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.16')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toStartOfWeek = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfWeek',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [toStartOfWeek](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tostartofweektmode)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.17')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toStartOfDay = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfDay',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [toStartOfDay](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tostartofday)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.18')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toStartOfHour = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfHour',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [toStartOfHour](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tostartofhour)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.19')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toStartOfMinute = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfMinute',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [toStartOfMinute](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tostartofminute)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.20')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toStartOfSecond = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfSecond',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [toStartOfSecond](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tostartofsecond)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.21')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toStartOfFiveMinute = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfFiveMinute',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [toStartOfFiveMinute](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tostartoffiveminute)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.22')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toStartOfTenMinutes = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfTenMinutes',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [toStartOfTenMinutes](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tostartoftenminutes)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.23')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toStartOfFifteenMinutes = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfFifteenMinutes',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [toStartOfFifteenMinutes](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tostartoffifteenminutes)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.24')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toStartOfInterval = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfInterval',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [toStartOfInterval](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tostartofintervaltime-or-data-interval-x-unit-time-zone)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        'More detailed description can be found [here](https://github.com/ClickHouse/ClickHouse/issues/1201).\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.25')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toTime = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toTime',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [toTime](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#totime)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.26')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toRelativeYearNum = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeYearNum',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [toRelativeYearNum](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#torelativeyearnum)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.27')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toRelativeQuarterNum = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeQuarterNum',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [toRelativeQuarterNum](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#torelativequarternum)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.28')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toRelativeMonthNum = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeMonthNum',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [toRelativeMonthNum](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#torelativemonthnum)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.29')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toRelativeWeekNum = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeWeekNum',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [toRelativeWeekNum](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#torelativeweeknum)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.30')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toRelativeDayNum = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeDayNum',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [toRelativeDayNum](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#torelativedaynum)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.31')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toRelativeHourNum = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeHourNum',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [toRelativeHourNum](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#torelativehournum)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.32')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toRelativeMinuteNum = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeMinuteNum',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [toRelativeMinuteNum](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#torelativeminutenum)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.33')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toRelativeSecondNum = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeSecondNum',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [toRelativeSecondNum](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#torelativesecondnum)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.34')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toISOYear = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toISOYear',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [toISOYear](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#toisoyear)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.35')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toISOWeek = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toISOWeek',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [toISOWeek](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#toisoweek)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.36')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toWeek = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toWeek',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [toWeek](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#toweekdatemode)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.37')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toYearWeek = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toYearWeek',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [toYearWeek](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#toyearweekdatemode)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.38')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_now = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.now',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support conversion of output from the [now](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#now)\n'
+        'function to the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.39')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_today = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.today',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support conversion of output from the [today](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#today)\n'
+        'function to the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.40')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_yesterday = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.yesterday',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support conversion of output from the [yesterday](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#yesterday)\n'
+        'function to the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.41')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_timeSlot = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.timeSlot',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support conversion of output from the [timeSlot](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#timeslot)\n'
+        'function to the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.42')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toYYYYMM = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toYYYYMM',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [toYYYYMM](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#toyyyymm)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.43')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toYYYYMMDD = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toYYYYMMDD',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [toYYYYMMDD](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#toyyyymmdd)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.44')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toYYYYMMDDhhmmss = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toYYYYMMDDhhmmss',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [toYYYYMMDDhhmmss](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#toyyyymmddhhmmss)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.45')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_addYears = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addYears',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [addYears](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#addyears-addmonths-addweeks-adddays-addhours-addminutes-addseconds-addquarters)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.46')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_addMonths = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addMonths',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [addMonths](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#addyears-addmonths-addweeks-adddays-addhours-addminutes-addseconds-addquarters)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.47')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_addWeeks = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addWeeks',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [addWeeks](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#addyears-addmonths-addweeks-adddays-addhours-addminutes-addseconds-addquarters)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.48')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_addDays = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addDays',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [addDays](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#addyears-addmonths-addweeks-adddays-addhours-addminutes-addseconds-addquarters)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.49')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_addHours = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addHours',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [addHours](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#addyears-addmonths-addweeks-adddays-addhours-addminutes-addseconds-addquarters)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.50')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_addMinutes = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addMinutes',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [addMinutes](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#addyears-addmonths-addweeks-adddays-addhours-addminutes-addseconds-addquarters)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.51')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_addSeconds = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addSeconds',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [addSeconds](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#addyears-addmonths-addweeks-adddays-addhours-addminutes-addseconds-addquarters)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.52')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_addQuarters = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addQuarters',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [addQuarters](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#addyears-addmonths-addweeks-adddays-addhours-addminutes-addseconds-addquarters)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.53')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_subtractYears = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractYears',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [subtractYears](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#subtractyears-subtractmonths-subtractweeks-subtractdays-subtracthours-subtractminutes-subtractseconds-subtractquarters)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.54')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_subtractMonths = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractMonths',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [subtractMonths](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#subtractyears-subtractmonths-subtractweeks-subtractdays-subtracthours-subtractminutes-subtractseconds-subtractquarters)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.55')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_subtractWeeks = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractWeeks',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [subtractWeeks](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#subtractyears-subtractmonths-subtractweeks-subtractdays-subtracthours-subtractminutes-subtractseconds-subtractquarters)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.56')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_subtractDays = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractDays',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [subtractDays](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#subtractyears-subtractmonths-subtractweeks-subtractdays-subtracthours-subtractminutes-subtractseconds-subtractquarters)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.57')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_subtractHours = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractHours',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [subtractHours](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#subtractyears-subtractmonths-subtractweeks-subtractdays-subtracthours-subtractminutes-subtractseconds-subtractquarters)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.58')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_subtractMinutes = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractMinutes',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [subtractMinutes](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#subtractyears-subtractmonths-subtractweeks-subtractdays-subtracthours-subtractminutes-subtractseconds-subtractquarters)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.59')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_subtractSeconds = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractSeconds',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [subtractSeconds](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#subtractyears-subtractmonths-subtractweeks-subtractdays-subtracthours-subtractminutes-subtractseconds-subtractquarters)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.60')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_subtractQuarters = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractQuarters',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [subtractQuarters](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#subtractyears-subtractmonths-subtractweeks-subtractdays-subtracthours-subtractminutes-subtractseconds-subtractquarters)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.61')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_dateDiff = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.dateDiff',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [dateDiff](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#datediff)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.62')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_timeSlots = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.timeSlots',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [timeSlots](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#timeslotsstarttime-duration-size)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.63')
+
+RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_formatDateTime = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.formatDateTime',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct operation of the [formatDateTime](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#formatdatetime)\n'
+        'function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.0.4.64')
+
+RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_toInt_8_16_32_64_128_256_ = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toInt(8|16|32|64|128|256)',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct conversion of the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range]\n'
+        'to integer types using [toInt(8|16|32|64|128|256)](https://clickhouse.tech/docs/en/sql-reference/functions/type-conversion-functions/#toint8163264128256) functions.\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.1.4.1')
+
+RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_toUInt_8_16_32_64_256_ = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toUInt(8|16|32|64|256)',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct conversion of the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range]\n'
+        'to unsigned integer types using [toUInt(8|16|32|64|256)](https://clickhouse.tech/docs/en/sql-reference/functions/type-conversion-functions/#touint8163264256) functions.\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.1.4.2')
+
+RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_toFloat_32_64_ = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toFloat(32|64)',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct conversion of the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range]\n'
+        'to float types using [toFloat(32|64)](https://clickhouse.tech/docs/en/sql-reference/functions/type-conversion-functions/#tofloat3264) functions.\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.1.4.3')
+
+RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_toDate = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toDate',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct conversion of the [DateTime64] data type when it stores dates within the [normal date range]\n'
+        'to the [Date](https://clickhouse.tech/docs/en/sql-reference/data-types/date/) type using the [toDate](https://clickhouse.tech/docs/en/sql-reference/functions/type-conversion-functions/#todate) function.\n'
+        'This function is ONLY supposed to work in NORMAL RANGE.\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.1.4.4')
+
+RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_toDateTime = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toDateTime',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct conversion of the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range]\n'
+        'to the [DateTime](https://clickhouse.tech/docs/en/sql-reference/data-types/datetime/) type using the [toDateTime](https://clickhouse.tech/docs/en/sql-reference/functions/type-conversion-functions/#todatetime) function.\n'
+        'This function is ONLY supposed to work in NORMAL RANGE.\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.1.4.5')
+
+RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_toDateTime64 = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toDateTime64',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct conversion from the data types supported by the [toDateTime64](https://clickhouse.tech/docs/en/sql-reference/data-types/datetime64/) function\n'
+        'to the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.1.4.6')
+
+RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_toDateTime64_FromString_MissingTime = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toDateTime64.FromString.MissingTime',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct conversion from the [String](https://clickhouse.tech/docs/en/sql-reference/data-types/string/)\n'
+        'data type to the [DateTime64](https://clickhouse.tech/docs/en/sql-reference/data-types/datetime64/) data type\n'
+        'when value of the string is missing the `hh:mm-ss.sss` part.\n'
+        "For example, `toDateTime64('2020-01-01', 3)`.\n"
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.1.4.7')
+
+RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_toDecimal_32_64_128_256_ = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toDecimal(32|64|128|256)',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct conversion of the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range]\n'
+        'to [Decimal](https://clickhouse.tech/docs/en/sql-reference/data-types/decimal/) types using [toDecimal(32|64|128|256)](https://clickhouse.tech/docs/en/sql-reference/functions/type-conversion-functions/#todecimal3264128256) functions.\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.1.4.8')
+
+RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_toString = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toString',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct conversion of the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range]\n'
+        'to the [String](https://clickhouse.tech/docs/en/sql-reference/data-types/string/) type using the [toString](https://clickhouse.tech/docs/en/sql-reference/functions/type-conversion-functions/#tostring) function.\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.1.4.9')
+
+RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_CAST_x_T_ = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.CAST(x,T)',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct conversion of the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range]\n'
+        'to one of the supported data type using the [CAST(x,T)](https://clickhouse.tech/docs/en/sql-reference/functions/type-conversion-functions/#type_conversion_function-cast) function.\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.1.4.10')
+
+RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_toUnixTimestamp64Milli = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toUnixTimestamp64Milli',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct conversion of the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range]\n'
+        'to the [Int64](https://clickhouse.tech/docs/en/sql-reference/data-types/int-uint/) type using the [toUnixTimestamp64Milli](https://clickhouse.tech/docs/en/sql-reference/functions/type-conversion-functions/#tounixtimestamp64milli) function.\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.1.4.11')
+
+RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_toUnixTimestamp64Micro = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toUnixTimestamp64Micro',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct conversion of the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range]\n'
+        'to the [Int64](https://clickhouse.tech/docs/en/sql-reference/data-types/int-uint/) type using the [toUnixTimestamp64Micro](https://clickhouse.tech/docs/en/sql-reference/functions/type-conversion-functions/#tounixtimestamp64micro) function.\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.1.4.12')
+
+RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_toUnixTimestamp64Nano = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toUnixTimestamp64Nano',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct conversion of the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range]\n'
+        'to the [Int64](https://clickhouse.tech/docs/en/sql-reference/data-types/int-uint/) type using the [toUnixTimestamp64Nano](https://clickhouse.tech/docs/en/sql-reference/functions/type-conversion-functions/#tounixtimestamp64nano) function.\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.1.4.13')
+
+RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_fromUnixTimestamp64Milli = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.fromUnixTimestamp64Milli',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct conversion from the [Int64](https://clickhouse.tech/docs/en/sql-reference/data-types/int-uint/) type\n'
+        'to the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range]\n'
+        'using the [fromUnixTimestamp64Milli](https://clickhouse.tech/docs/en/sql-reference/functions/type-conversion-functions/#fromunixtimestamp64milli) function.\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.1.4.14')
+
+RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_fromUnixTimestamp64Micro = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.fromUnixTimestamp64Micro',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct conversion from the [Int64](https://clickhouse.tech/docs/en/sql-reference/data-types/int-uint/) type\n'
+        'to the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range]\n'
+        'using the [fromUnixTimestamp64Micro](https://clickhouse.tech/docs/en/sql-reference/functions/type-conversion-functions/#fromunixtimestamp64micro) function.\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.1.4.15')
+
+RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_fromUnixTimestamp64Nano = Requirement(
+    name='RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.fromUnixTimestamp64Nano',
+    version='1.0',
+    priority=None,
+    group=None,
+    type=None,
+    uid=None,
+    description=(
+        '[ClickHouse] SHALL support correct conversion from the [Int64](https://clickhouse.tech/docs/en/sql-reference/data-types/int-uint/) type\n'
+        'to the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range]\n'
+        'using the [fromUnixTimestamp64Nano](https://clickhouse.tech/docs/en/sql-reference/functions/type-conversion-functions/#fromunixtimestamp64nano) function.\n'
+        '\n'
+        ),
+    link=None,
+    level=5,
+    num='4.2.1.4.16')
+
+QA_SRS010_ClickHouse_DateTime64_Extended_Range = Specification(
+    name='QA-SRS010 ClickHouse DateTime64 Extended Range', 
+    description=None,
+    author=None,
+    date=None, 
+    status=None, 
+    approved_by=None,
+    approved_date=None,
+    approved_version=None,
+    version=None,
+    group=None,
+    type=None,
+    link=None,
+    uid=None,
+    parent=None,
+    children=None,
+    headings=(
+        Heading(name='Revision History', level=1, num='1'),
+        Heading(name='Introduction', level=1, num='2'),
+        Heading(name='Terminology', level=1, num='3'),
+        Heading(name='SRS', level=2, num='3.1'),
+        Heading(name='Normal Date Range', level=2, num='3.2'),
+        Heading(name='Extended Date Range', level=2, num='3.3'),
+        Heading(name='Requirements', level=1, num='4'),
+        Heading(name='Generic', level=2, num='4.1'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange', level=4, num='4.1.0.1'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.NormalRange.Start', level=4, num='4.1.0.2'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.NormalRange.Start.BeforeEpochForTimeZone', level=4, num='4.1.0.3'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.NormalRange.End', level=4, num='4.1.0.4'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.NormalRange.End.AfterEpochForTimeZone', level=4, num='4.1.0.5'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions', level=4, num='4.1.0.6'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions', level=4, num='4.1.0.7'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.TimeZones', level=4, num='4.1.0.8'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.NonExistentTime', level=4, num='4.1.0.9'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.Comparison', level=4, num='4.1.0.10'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.SpecificTimestamps', level=4, num='4.1.0.11'),
+        Heading(name='Specific', level=2, num='4.2'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.Start', level=4, num='4.2.0.1'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.End', level=4, num='4.2.0.2'),
+        Heading(name='Non-Existent Time', level=4, num='4.2.0.3'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.NonExistentTime.InvalidDate', level=5, num='4.2.0.3.1'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.NonExistentTime.InvalidTime', level=5, num='4.2.0.3.2'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.NonExistentTime.TimeZoneSwitch', level=5, num='4.2.0.3.3'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.NonExistentTime.DaylightSavingTime', level=5, num='4.2.0.3.4'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.NonExistentTime.DaylightSavingTime.Disappeared', level=5, num='4.2.0.3.5'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.NonExistentTime.LeapSeconds', level=5, num='4.2.0.3.6'),
+        Heading(name='Dates And Times Functions', level=4, num='4.2.0.4'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toTimeZone', level=5, num='4.2.0.4.1'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toYear', level=5, num='4.2.0.4.2'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toQuarter', level=5, num='4.2.0.4.3'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toMonth', level=5, num='4.2.0.4.4'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toDayOfYear', level=5, num='4.2.0.4.5'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toDayOfMonth', level=5, num='4.2.0.4.6'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toDayOfWeek', level=5, num='4.2.0.4.7'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toHour', level=5, num='4.2.0.4.8'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toMinute', level=5, num='4.2.0.4.9'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toSecond', level=5, num='4.2.0.4.10'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toUnixTimestamp', level=5, num='4.2.0.4.11'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfYear', level=5, num='4.2.0.4.12'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfISOYear', level=5, num='4.2.0.4.13'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfQuarter', level=5, num='4.2.0.4.14'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfMonth', level=5, num='4.2.0.4.15'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toMonday', level=5, num='4.2.0.4.16'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfWeek', level=5, num='4.2.0.4.17'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfDay', level=5, num='4.2.0.4.18'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfHour', level=5, num='4.2.0.4.19'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfMinute', level=5, num='4.2.0.4.20'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfSecond', level=5, num='4.2.0.4.21'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfFiveMinute', level=5, num='4.2.0.4.22'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfTenMinutes', level=5, num='4.2.0.4.23'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfFifteenMinutes', level=5, num='4.2.0.4.24'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfInterval', level=5, num='4.2.0.4.25'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toTime', level=5, num='4.2.0.4.26'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeYearNum', level=5, num='4.2.0.4.27'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeQuarterNum', level=5, num='4.2.0.4.28'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeMonthNum', level=5, num='4.2.0.4.29'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeWeekNum', level=5, num='4.2.0.4.30'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeDayNum', level=5, num='4.2.0.4.31'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeHourNum', level=5, num='4.2.0.4.32'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeMinuteNum', level=5, num='4.2.0.4.33'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeSecondNum', level=5, num='4.2.0.4.34'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toISOYear', level=5, num='4.2.0.4.35'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toISOWeek', level=5, num='4.2.0.4.36'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toWeek', level=5, num='4.2.0.4.37'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toYearWeek', level=5, num='4.2.0.4.38'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.now', level=5, num='4.2.0.4.39'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.today', level=5, num='4.2.0.4.40'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.yesterday', level=5, num='4.2.0.4.41'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.timeSlot', level=5, num='4.2.0.4.42'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toYYYYMM', level=5, num='4.2.0.4.43'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toYYYYMMDD', level=5, num='4.2.0.4.44'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toYYYYMMDDhhmmss', level=5, num='4.2.0.4.45'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addYears', level=5, num='4.2.0.4.46'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addMonths', level=5, num='4.2.0.4.47'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addWeeks', level=5, num='4.2.0.4.48'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addDays', level=5, num='4.2.0.4.49'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addHours', level=5, num='4.2.0.4.50'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addMinutes', level=5, num='4.2.0.4.51'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addSeconds', level=5, num='4.2.0.4.52'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addQuarters', level=5, num='4.2.0.4.53'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractYears', level=5, num='4.2.0.4.54'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractMonths', level=5, num='4.2.0.4.55'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractWeeks', level=5, num='4.2.0.4.56'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractDays', level=5, num='4.2.0.4.57'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractHours', level=5, num='4.2.0.4.58'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractMinutes', level=5, num='4.2.0.4.59'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractSeconds', level=5, num='4.2.0.4.60'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractQuarters', level=5, num='4.2.0.4.61'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.dateDiff', level=5, num='4.2.0.4.62'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.timeSlots', level=5, num='4.2.0.4.63'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.formatDateTime', level=5, num='4.2.0.4.64'),
+        Heading(name='Type Conversion Functions', level=3, num='4.2.1'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toInt(8|16|32|64|128|256)', level=5, num='4.2.1.4.1'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toUInt(8|16|32|64|256)', level=5, num='4.2.1.4.2'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toFloat(32|64)', level=5, num='4.2.1.4.3'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toDate', level=5, num='4.2.1.4.4'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toDateTime', level=5, num='4.2.1.4.5'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toDateTime64', level=5, num='4.2.1.4.6'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toDateTime64.FromString.MissingTime', level=5, num='4.2.1.4.7'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toDecimal(32|64|128|256)', level=5, num='4.2.1.4.8'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toString', level=5, num='4.2.1.4.9'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.CAST(x,T)', level=5, num='4.2.1.4.10'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toUnixTimestamp64Milli', level=5, num='4.2.1.4.11'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toUnixTimestamp64Micro', level=5, num='4.2.1.4.12'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toUnixTimestamp64Nano', level=5, num='4.2.1.4.13'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.fromUnixTimestamp64Milli', level=5, num='4.2.1.4.14'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.fromUnixTimestamp64Micro', level=5, num='4.2.1.4.15'),
+        Heading(name='RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.fromUnixTimestamp64Nano', level=5, num='4.2.1.4.16'),
+        Heading(name='References', level=1, num='5'),
+        ),
+    requirements=(
+        RQ_SRS_010_DateTime64_ExtendedRange,
+        RQ_SRS_010_DateTime64_ExtendedRange_NormalRange_Start,
+        RQ_SRS_010_DateTime64_ExtendedRange_NormalRange_Start_BeforeEpochForTimeZone,
+        RQ_SRS_010_DateTime64_ExtendedRange_NormalRange_End,
+        RQ_SRS_010_DateTime64_ExtendedRange_NormalRange_End_AfterEpochForTimeZone,
+        RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions,
+        RQ_SRS_010_DateTime64_ExtendedRange_TimeZones,
+        RQ_SRS_010_DateTime64_ExtendedRange_NonExistentTime,
+        RQ_SRS_010_DateTime64_ExtendedRange_Comparison,
+        RQ_SRS_010_DateTime64_ExtendedRange_SpecificTimestamps,
+        RQ_SRS_010_DateTime64_ExtendedRange_Start,
+        RQ_SRS_010_DateTime64_ExtendedRange_End,
+        RQ_SRS_010_DateTime64_ExtendedRange_NonExistentTime_InvalidDate,
+        RQ_SRS_010_DateTime64_ExtendedRange_NonExistentTime_InvalidTime,
+        RQ_SRS_010_DateTime64_ExtendedRange_NonExistentTime_TimeZoneSwitch,
+        RQ_SRS_010_DateTime64_ExtendedRange_NonExistentTime_DaylightSavingTime,
+        RQ_SRS_010_DateTime64_ExtendedRange_NonExistentTime_DaylightSavingTime_Disappeared,
+        RQ_SRS_010_DateTime64_ExtendedRange_NonExistentTime_LeapSeconds,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toTimeZone,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toYear,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toQuarter,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toMonth,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toDayOfYear,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toDayOfMonth,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toDayOfWeek,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toHour,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toMinute,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toSecond,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toUnixTimestamp,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toStartOfYear,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toStartOfISOYear,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toStartOfQuarter,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toStartOfMonth,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toMonday,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toStartOfWeek,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toStartOfDay,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toStartOfHour,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toStartOfMinute,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toStartOfSecond,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toStartOfFiveMinute,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toStartOfTenMinutes,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toStartOfFifteenMinutes,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toStartOfInterval,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toTime,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toRelativeYearNum,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toRelativeQuarterNum,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toRelativeMonthNum,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toRelativeWeekNum,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toRelativeDayNum,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toRelativeHourNum,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toRelativeMinuteNum,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toRelativeSecondNum,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toISOYear,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toISOWeek,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toWeek,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toYearWeek,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_now,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_today,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_yesterday,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_timeSlot,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toYYYYMM,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toYYYYMMDD,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toYYYYMMDDhhmmss,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_addYears,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_addMonths,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_addWeeks,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_addDays,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_addHours,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_addMinutes,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_addSeconds,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_addQuarters,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_subtractYears,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_subtractMonths,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_subtractWeeks,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_subtractDays,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_subtractHours,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_subtractMinutes,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_subtractSeconds,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_subtractQuarters,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_dateDiff,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_timeSlots,
+        RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_formatDateTime,
+        RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_toInt_8_16_32_64_128_256_,
+        RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_toUInt_8_16_32_64_256_,
+        RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_toFloat_32_64_,
+        RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_toDate,
+        RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_toDateTime,
+        RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_toDateTime64,
+        RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_toDateTime64_FromString_MissingTime,
+        RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_toDecimal_32_64_128_256_,
+        RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_toString,
+        RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_CAST_x_T_,
+        RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_toUnixTimestamp64Milli,
+        RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_toUnixTimestamp64Micro,
+        RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_toUnixTimestamp64Nano,
+        RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_fromUnixTimestamp64Milli,
+        RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_fromUnixTimestamp64Micro,
+        RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_fromUnixTimestamp64Nano,
+        ),
+    content='''
+# QA-SRS010 ClickHouse DateTime64 Extended Range
+# Software Requirements Specification
+
+## Table of Contents
+
+* 1 [Revision History](#revision-history)
+* 2 [Introduction](#introduction)
+* 3 [Terminology](#terminology)
+  * 3.1 [SRS](#srs)
+  * 3.2 [Normal Date Range](#normal-date-range)
+  * 3.3 [Extended Date Range](#extended-date-range)
+* 4 [Requirements](#requirements)
+  * 4.1 [Generic](#generic)
+      * 4.1.0.1 [RQ.SRS-010.DateTime64.ExtendedRange](#rqsrs-010datetime64extendedrange)
+      * 4.1.0.2 [RQ.SRS-010.DateTime64.ExtendedRange.NormalRange.Start](#rqsrs-010datetime64extendedrangenormalrangestart)
+      * 4.1.0.3 [RQ.SRS-010.DateTime64.ExtendedRange.NormalRange.Start.BeforeEpochForTimeZone](#rqsrs-010datetime64extendedrangenormalrangestartbeforeepochfortimezone)
+      * 4.1.0.4 [RQ.SRS-010.DateTime64.ExtendedRange.NormalRange.End](#rqsrs-010datetime64extendedrangenormalrangeend)
+      * 4.1.0.5 [RQ.SRS-010.DateTime64.ExtendedRange.NormalRange.End.AfterEpochForTimeZone](#rqsrs-010datetime64extendedrangenormalrangeendafterepochfortimezone)
+      * 4.1.0.6 [RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions](#rqsrs-010datetime64extendedrangetypeconversionfunctions)
+      * 4.1.0.7 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions](#rqsrs-010datetime64extendedrangedatesandtimesfunctions)
+      * 4.1.0.8 [RQ.SRS-010.DateTime64.ExtendedRange.TimeZones](#rqsrs-010datetime64extendedrangetimezones)
+      * 4.1.0.9 [RQ.SRS-010.DateTime64.ExtendedRange.NonExistentTime](#rqsrs-010datetime64extendedrangenonexistenttime)
+      * 4.1.0.10 [RQ.SRS-010.DateTime64.ExtendedRange.Comparison](#rqsrs-010datetime64extendedrangecomparison)
+      * 4.1.0.11 [RQ.SRS-010.DateTime64.ExtendedRange.SpecificTimestamps](#rqsrs-010datetime64extendedrangespecifictimestamps)
+  * 4.2 [Specific](#specific)
+      * 4.2.0.1 [RQ.SRS-010.DateTime64.ExtendedRange.Start](#rqsrs-010datetime64extendedrangestart)
+      * 4.2.0.2 [RQ.SRS-010.DateTime64.ExtendedRange.End](#rqsrs-010datetime64extendedrangeend)
+      * 4.2.0.3 [Non-Existent Time](#non-existent-time)
+        * 4.2.0.3.1 [RQ.SRS-010.DateTime64.ExtendedRange.NonExistentTime.InvalidDate](#rqsrs-010datetime64extendedrangenonexistenttimeinvaliddate)
+        * 4.2.0.3.2 [RQ.SRS-010.DateTime64.ExtendedRange.NonExistentTime.InvalidTime](#rqsrs-010datetime64extendedrangenonexistenttimeinvalidtime)
+        * 4.2.0.3.3 [RQ.SRS-010.DateTime64.ExtendedRange.NonExistentTime.TimeZoneSwitch](#rqsrs-010datetime64extendedrangenonexistenttimetimezoneswitch)
+        * 4.2.0.3.4 [RQ.SRS-010.DateTime64.ExtendedRange.NonExistentTime.DaylightSavingTime](#rqsrs-010datetime64extendedrangenonexistenttimedaylightsavingtime)
+        * 4.2.0.3.5 [RQ.SRS-010.DateTime64.ExtendedRange.NonExistentTime.DaylightSavingTime.Disappeared](#rqsrs-010datetime64extendedrangenonexistenttimedaylightsavingtimedisappeared)
+        * 4.2.0.3.6 [RQ.SRS-010.DateTime64.ExtendedRange.NonExistentTime.LeapSeconds](#rqsrs-010datetime64extendedrangenonexistenttimeleapseconds)
+      * 4.2.0.4 [Dates And Times Functions](#dates-and-times-functions)
+        * 4.2.0.4.1 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toTimeZone](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstotimezone)
+        * 4.2.0.4.2 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toYear](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstoyear)
+        * 4.2.0.4.3 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toQuarter](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstoquarter)
+        * 4.2.0.4.4 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toMonth](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstomonth)
+        * 4.2.0.4.5 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toDayOfYear](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstodayofyear)
+        * 4.2.0.4.6 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toDayOfMonth](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstodayofmonth)
+        * 4.2.0.4.7 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toDayOfWeek](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstodayofweek)
+        * 4.2.0.4.8 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toHour](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstohour)
+        * 4.2.0.4.9 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toMinute](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstominute)
+        * 4.2.0.4.10 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toSecond](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstosecond)
+        * 4.2.0.4.11 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toUnixTimestamp](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstounixtimestamp)
+        * 4.2.0.4.12 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfYear](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstostartofyear)
+        * 4.2.0.4.13 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfISOYear](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstostartofisoyear)
+        * 4.2.0.4.14 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfQuarter](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstostartofquarter)
+        * 4.2.0.4.15 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfMonth](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstostartofmonth)
+        * 4.2.0.4.16 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toMonday](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstomonday)
+        * 4.2.0.4.17 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfWeek](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstostartofweek)
+        * 4.2.0.4.18 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfDay](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstostartofday)
+        * 4.2.0.4.19 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfHour](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstostartofhour)
+        * 4.2.0.4.20 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfMinute](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstostartofminute)
+        * 4.2.0.4.21 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfSecond](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstostartofsecond)
+        * 4.2.0.4.22 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfFiveMinute](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstostartoffiveminute)
+        * 4.2.0.4.23 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfTenMinutes](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstostartoftenminutes)
+        * 4.2.0.4.24 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfFifteenMinutes](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstostartoffifteenminutes)
+        * 4.2.0.4.25 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfInterval](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstostartofinterval)
+        * 4.2.0.4.26 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toTime](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstotime)
+        * 4.2.0.4.27 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeYearNum](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstorelativeyearnum)
+        * 4.2.0.4.28 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeQuarterNum](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstorelativequarternum)
+        * 4.2.0.4.29 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeMonthNum](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstorelativemonthnum)
+        * 4.2.0.4.30 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeWeekNum](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstorelativeweeknum)
+        * 4.2.0.4.31 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeDayNum](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstorelativedaynum)
+        * 4.2.0.4.32 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeHourNum](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstorelativehournum)
+        * 4.2.0.4.33 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeMinuteNum](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstorelativeminutenum)
+        * 4.2.0.4.34 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeSecondNum](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstorelativesecondnum)
+        * 4.2.0.4.35 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toISOYear](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstoisoyear)
+        * 4.2.0.4.36 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toISOWeek](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstoisoweek)
+        * 4.2.0.4.37 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toWeek](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstoweek)
+        * 4.2.0.4.38 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toYearWeek](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstoyearweek)
+        * 4.2.0.4.39 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.now](#rqsrs-010datetime64extendedrangedatesandtimesfunctionsnow)
+        * 4.2.0.4.40 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.today](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstoday)
+        * 4.2.0.4.41 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.yesterday](#rqsrs-010datetime64extendedrangedatesandtimesfunctionsyesterday)
+        * 4.2.0.4.42 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.timeSlot](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstimeslot)
+        * 4.2.0.4.43 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toYYYYMM](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstoyyyymm)
+        * 4.2.0.4.44 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toYYYYMMDD](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstoyyyymmdd)
+        * 4.2.0.4.45 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toYYYYMMDDhhmmss](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstoyyyymmddhhmmss)
+        * 4.2.0.4.46 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addYears](#rqsrs-010datetime64extendedrangedatesandtimesfunctionsaddyears)
+        * 4.2.0.4.47 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addMonths](#rqsrs-010datetime64extendedrangedatesandtimesfunctionsaddmonths)
+        * 4.2.0.4.48 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addWeeks](#rqsrs-010datetime64extendedrangedatesandtimesfunctionsaddweeks)
+        * 4.2.0.4.49 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addDays](#rqsrs-010datetime64extendedrangedatesandtimesfunctionsadddays)
+        * 4.2.0.4.50 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addHours](#rqsrs-010datetime64extendedrangedatesandtimesfunctionsaddhours)
+        * 4.2.0.4.51 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addMinutes](#rqsrs-010datetime64extendedrangedatesandtimesfunctionsaddminutes)
+        * 4.2.0.4.52 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addSeconds](#rqsrs-010datetime64extendedrangedatesandtimesfunctionsaddseconds)
+        * 4.2.0.4.53 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addQuarters](#rqsrs-010datetime64extendedrangedatesandtimesfunctionsaddquarters)
+        * 4.2.0.4.54 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractYears](#rqsrs-010datetime64extendedrangedatesandtimesfunctionssubtractyears)
+        * 4.2.0.4.55 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractMonths](#rqsrs-010datetime64extendedrangedatesandtimesfunctionssubtractmonths)
+        * 4.2.0.4.56 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractWeeks](#rqsrs-010datetime64extendedrangedatesandtimesfunctionssubtractweeks)
+        * 4.2.0.4.57 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractDays](#rqsrs-010datetime64extendedrangedatesandtimesfunctionssubtractdays)
+        * 4.2.0.4.58 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractHours](#rqsrs-010datetime64extendedrangedatesandtimesfunctionssubtracthours)
+        * 4.2.0.4.59 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractMinutes](#rqsrs-010datetime64extendedrangedatesandtimesfunctionssubtractminutes)
+        * 4.2.0.4.60 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractSeconds](#rqsrs-010datetime64extendedrangedatesandtimesfunctionssubtractseconds)
+        * 4.2.0.4.61 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractQuarters](#rqsrs-010datetime64extendedrangedatesandtimesfunctionssubtractquarters)
+        * 4.2.0.4.62 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.dateDiff](#rqsrs-010datetime64extendedrangedatesandtimesfunctionsdatediff)
+        * 4.2.0.4.63 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.timeSlots](#rqsrs-010datetime64extendedrangedatesandtimesfunctionstimeslots)
+        * 4.2.0.4.64 [RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.formatDateTime](#rqsrs-010datetime64extendedrangedatesandtimesfunctionsformatdatetime)
+    * 4.2.1 [Type Conversion Functions](#type-conversion-functions)
+        * 4.2.1.4.1 [RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toInt(8|16|32|64|128|256)](#rqsrs-010datetime64extendedrangetypeconversionfunctionstoint8163264128256)
+        * 4.2.1.4.2 [RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toUInt(8|16|32|64|256)](#rqsrs-010datetime64extendedrangetypeconversionfunctionstouint8163264256)
+        * 4.2.1.4.3 [RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toFloat(32|64)](#rqsrs-010datetime64extendedrangetypeconversionfunctionstofloat3264)
+        * 4.2.1.4.4 [RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toDate](#rqsrs-010datetime64extendedrangetypeconversionfunctionstodate)
+        * 4.2.1.4.5 [RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toDateTime](#rqsrs-010datetime64extendedrangetypeconversionfunctionstodatetime)
+        * 4.2.1.4.6 [RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toDateTime64](#rqsrs-010datetime64extendedrangetypeconversionfunctionstodatetime64)
+        * 4.2.1.4.7 [RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toDateTime64.FromString.MissingTime](#rqsrs-010datetime64extendedrangetypeconversionfunctionstodatetime64fromstringmissingtime)
+        * 4.2.1.4.8 [RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toDecimal(32|64|128|256)](#rqsrs-010datetime64extendedrangetypeconversionfunctionstodecimal3264128256)
+        * 4.2.1.4.9 [RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toString](#rqsrs-010datetime64extendedrangetypeconversionfunctionstostring)
+        * 4.2.1.4.10 [RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.CAST(x,T)](#rqsrs-010datetime64extendedrangetypeconversionfunctionscastxt)
+        * 4.2.1.4.11 [RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toUnixTimestamp64Milli](#rqsrs-010datetime64extendedrangetypeconversionfunctionstounixtimestamp64milli)
+        * 4.2.1.4.12 [RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toUnixTimestamp64Micro](#rqsrs-010datetime64extendedrangetypeconversionfunctionstounixtimestamp64micro)
+        * 4.2.1.4.13 [RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toUnixTimestamp64Nano](#rqsrs-010datetime64extendedrangetypeconversionfunctionstounixtimestamp64nano)
+        * 4.2.1.4.14 [RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.fromUnixTimestamp64Milli](#rqsrs-010datetime64extendedrangetypeconversionfunctionsfromunixtimestamp64milli)
+        * 4.2.1.4.15 [RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.fromUnixTimestamp64Micro](#rqsrs-010datetime64extendedrangetypeconversionfunctionsfromunixtimestamp64micro)
+        * 4.2.1.4.16 [RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.fromUnixTimestamp64Nano](#rqsrs-010datetime64extendedrangetypeconversionfunctionsfromunixtimestamp64nano)
+* 5 [References](#references)
+
+## Revision History
+
+This document is stored in an electronic form using [Git] source control management software
+hosted in a [GitHub Repository].
+All the updates are tracked using the [Revision History].
+
+## Introduction
+
+This document will cover requirements to support extended range for the [DateTime64] data type
+that is outside the normal **1970** (1970-01-02 00:00:00 UTC) to **2105** (2105-12-31 23:59:59.99999 UTC) date range.
+
+## Terminology
+
+### SRS
+
+Software Requirements Specification
+
+### Normal Date Range
+
+**1970** `1970-01-02T00:00:00.000000` to **2105** `2105-12-31T23:59:59.99999`
+
+### Extended Date Range
+
+**1925** `1925-01-01T00:00:00.000000` to **2238** `2238-12-31 23:59:59.99999`
+
+## Requirements
+
+### Generic
+
+##### RQ.SRS-010.DateTime64.ExtendedRange
+version: 1.0
+
+[ClickHouse] SHALL support extended range for the [DateTime64] data type that includes dates from the year **1925** to **2238**.
+
+##### RQ.SRS-010.DateTime64.ExtendedRange.NormalRange.Start
+version: 1.0
+
+[ClickHouse] SHALL support proper time handling around the normal date range that starts at `1970-01-01 00:00:00.000`
+expressed using the [ISO 8601 format].
+
+##### RQ.SRS-010.DateTime64.ExtendedRange.NormalRange.Start.BeforeEpochForTimeZone
+version: 1.0
+
+[ClickHouse] SHALL support proper time handling around the start of the [normal date range]
+when this time for the time zone is before the start of the [normal date range].
+
+##### RQ.SRS-010.DateTime64.ExtendedRange.NormalRange.End
+version: 1.0
+
+[ClickHouse] SHALL support proper time handling around the normal date range that ends at `2105-12-31T23:59:59.99999`
+expressed using the [ISO 8601 format].
+
+##### RQ.SRS-010.DateTime64.ExtendedRange.NormalRange.End.AfterEpochForTimeZone
+version: 1.0
+
+[ClickHouse] SHALL support proper time handling around the end of the [normal date range]
+when this time for the time zone is after the end of the [normal date range].
+
+##### RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions
+version: 1.0
+
+[ClickHouse] SHALL support proper conversion to and from [DateTime64] data type from other data types.
+
+##### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [Dates and Times Functions] with the [DateTime64] data type
+when it stores dates within the [normal date range] and the [extended date range].
+
+##### RQ.SRS-010.DateTime64.ExtendedRange.TimeZones
+version: 1.0
+
+[ClickHouse] SHALL support correct operation with the [DateTime64] extended range data type
+when combined with a supported time zone.
+
+##### RQ.SRS-010.DateTime64.ExtendedRange.NonExistentTime
+version: 1.0
+
+[ClickHouse] SHALL support proper handling of non-existent times when using [DateTime64] extended range data type.
+
+##### RQ.SRS-010.DateTime64.ExtendedRange.Comparison
+version: 1.0
+
+[ClickHouse] SHALL support proper handling of time comparison when using [DateTime64] extended range data type.
+For example, `SELECT toDateTime64('2019-05-05 20:20:12.050', 3) < now()`.
+
+##### RQ.SRS-010.DateTime64.ExtendedRange.SpecificTimestamps
+version: 1.0
+
+[ClickHouse] SHALL properly work with the following timestamps in all supported timezones:
+```
+[9961200,73476000,325666800,354675600,370400400,386125200,388566010,401850000,417574811,496803600,528253200,624423614,636516015,671011200,717555600,752047218,859683600,922582800,1018173600,1035705600,1143334800,1162105223,1174784400,1194156000,1206838823,1224982823,1236495624,1319936400,1319936424,1425798025,1459040400,1509872400,2090451627,2140668000]
+```
+
+
+### Specific
+
+##### RQ.SRS-010.DateTime64.ExtendedRange.Start
+version: 1.0
+
+[ClickHouse] SHALL support extended range for the [DateTime64] data type that starts at `1925-01-01T00:00:00.000000`
+expressed using the [ISO 8601 format].
+
+##### RQ.SRS-010.DateTime64.ExtendedRange.End
+version: 1.0
+
+[ClickHouse] SHALL support extended range for the [DateTime64] data type that ends at `2238-12-31T23:59:59.999999`
+expressed using the [ISO 8601 format].
+
+##### Non-Existent Time
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.NonExistentTime.InvalidDate
+version: 1.0
+
+[ClickHouse] SHALL support proper handling of invalid dates when using [DateTime64] extended range data type,
+such as:
+
+* `YYYY-04-31, YYYY-06-31, YYYY-09-31, YYYY-11-31`
+* `1990-02-30 00:00:02`
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.NonExistentTime.InvalidTime
+version: 1.0
+
+[ClickHouse] SHALL support proper handling of invalid time for a timezone
+when using [DateTime64] extended range data type, for example,
+
+* `2002-04-07 02:30:00` never happened at all in the US/Eastern timezone ([Stuart Bishop: pytz library](http://pytz.sourceforge.net/#problems-with-localtime))
+
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.NonExistentTime.TimeZoneSwitch
+version: 1.0
+
+[ClickHouse] SHALL support proper handling of invalid time when using [DateTime64] extended range data type
+when the invalid time is caused when *countries switch timezone definitions with no
+daylight savings time switch* [Stuart Bishop: pytz library](http://pytz.sourceforge.net/#problems-with-localtime).
+
+>
+> For example, in 1915 Warsaw switched from Warsaw time to Central European time with
+> no daylight savings transition. So at the stroke of midnight on August 5th 1915 the clocks
+> were wound back 24 minutes creating an ambiguous time period that cannot be specified without
+> referring to the timezone abbreviation or the actual UTC offset. In this case midnight happened twice,
+> neither time during a daylight saving time period. pytz handles this transition by treating the ambiguous
+> period before the switch as daylight savings time, and the ambiguous period after as standard time.
+>
+> [Stuart Bishop: pytz library](http://pytz.sourceforge.net/#problems-with-localtime)
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.NonExistentTime.DaylightSavingTime
+version: 1.0
+
+[ClickHouse] SHALL support proper handling of invalid time when using [DateTime64] extended range data type
+when for a given timezone time switches from standard to daylight saving.
+
+> For example, in the US/Eastern timezone on the last Sunday morning in October, the following sequence happens:
+>
+> 01:00 EDT occurs
+> 1 hour later, instead of 2:00am the clock is turned back 1 hour and 01:00 happens again (this time 01:00 EST)
+> In fact, every instant between 01:00 and 02:00 occurs twice.
+> [Stuart Bishop: pytz library](http://pytz.sourceforge.net/#problems-with-localtime)
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.NonExistentTime.DaylightSavingTime.Disappeared
+version: 1.0
+
+[ClickHouse] SHALL support proper handling of invalid time when using [DateTime64] extended range data type
+for a given timezone when transition from the standard to daylight saving time causes an hour to disappear.
+
+Expected behavior: if DateTime64 initialized by a skipped time value, it is being treated as DST and resulting value will be an hour earlier, e.g. `SELECT toDateTime64('2020-03-08 02:34:00', 0, 'America/Denver')` returns `2020-03-08 01:34:00`.
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.NonExistentTime.LeapSeconds
+version: 1.0
+
+[ClickHouse] SHALL support proper handling of leap seconds adjustments when using [DateTime64] extended range data type.
+
+##### Dates And Times Functions
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toTimeZone
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toTimeZone](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#totimezone)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toYear
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toYear](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#toyear)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toQuarter
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toQuarter](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#toquarter)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toMonth
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toMonth](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tomonth)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toDayOfYear
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toDayOfYear](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#todayofyear)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toDayOfMonth
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toDayOfMonth](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#todayofmonth)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toDayOfWeek
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toDayOfWeek](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#todayofweek)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toHour
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toHour](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tohour)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toMinute
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toMinute](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tominute)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toSecond
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toSecond](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tosecond)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toUnixTimestamp
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toUnitTimestamp](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#to-unix-timestamp)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+Timestamp value expected to be negative when DateTime64 value is prior to `1970-01-01` and positine otherwise.
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfYear
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toStartOfYear](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tostartofyear)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfISOYear
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toStartOfISOYear](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tostartofisoyear)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfQuarter
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toStartOfQuarter](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tostartofquarter)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfMonth
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toStartOfMonth](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tostartofmonth)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toMonday
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toMonday](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tomonday)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfWeek
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toStartOfWeek](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tostartofweektmode)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfDay
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toStartOfDay](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tostartofday)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfHour
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toStartOfHour](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tostartofhour)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfMinute
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toStartOfMinute](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tostartofminute)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfSecond
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toStartOfSecond](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tostartofsecond)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfFiveMinute
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toStartOfFiveMinute](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tostartoffiveminute)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfTenMinutes
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toStartOfTenMinutes](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tostartoftenminutes)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfFifteenMinutes
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toStartOfFifteenMinutes](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tostartoffifteenminutes)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toStartOfInterval
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toStartOfInterval](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#tostartofintervaltime-or-data-interval-x-unit-time-zone)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+More detailed description can be found [here](https://github.com/ClickHouse/ClickHouse/issues/1201).
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toTime
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toTime](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#totime)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeYearNum
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toRelativeYearNum](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#torelativeyearnum)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeQuarterNum
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toRelativeQuarterNum](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#torelativequarternum)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeMonthNum
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toRelativeMonthNum](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#torelativemonthnum)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeWeekNum
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toRelativeWeekNum](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#torelativeweeknum)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeDayNum
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toRelativeDayNum](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#torelativedaynum)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeHourNum
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toRelativeHourNum](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#torelativehournum)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeMinuteNum
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toRelativeMinuteNum](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#torelativeminutenum)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toRelativeSecondNum
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toRelativeSecondNum](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#torelativesecondnum)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toISOYear
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toISOYear](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#toisoyear)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toISOWeek
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toISOWeek](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#toisoweek)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toWeek
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toWeek](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#toweekdatemode)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toYearWeek
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toYearWeek](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#toyearweekdatemode)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.now
+version: 1.0
+
+[ClickHouse] SHALL support conversion of output from the [now](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#now)
+function to the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.today
+version: 1.0
+
+[ClickHouse] SHALL support conversion of output from the [today](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#today)
+function to the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.yesterday
+version: 1.0
+
+[ClickHouse] SHALL support conversion of output from the [yesterday](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#yesterday)
+function to the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.timeSlot
+version: 1.0
+
+[ClickHouse] SHALL support conversion of output from the [timeSlot](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#timeslot)
+function to the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toYYYYMM
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toYYYYMM](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#toyyyymm)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toYYYYMMDD
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toYYYYMMDD](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#toyyyymmdd)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.toYYYYMMDDhhmmss
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [toYYYYMMDDhhmmss](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#toyyyymmddhhmmss)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addYears
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [addYears](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#addyears-addmonths-addweeks-adddays-addhours-addminutes-addseconds-addquarters)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addMonths
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [addMonths](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#addyears-addmonths-addweeks-adddays-addhours-addminutes-addseconds-addquarters)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addWeeks
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [addWeeks](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#addyears-addmonths-addweeks-adddays-addhours-addminutes-addseconds-addquarters)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addDays
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [addDays](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#addyears-addmonths-addweeks-adddays-addhours-addminutes-addseconds-addquarters)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addHours
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [addHours](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#addyears-addmonths-addweeks-adddays-addhours-addminutes-addseconds-addquarters)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addMinutes
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [addMinutes](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#addyears-addmonths-addweeks-adddays-addhours-addminutes-addseconds-addquarters)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addSeconds
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [addSeconds](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#addyears-addmonths-addweeks-adddays-addhours-addminutes-addseconds-addquarters)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.addQuarters
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [addQuarters](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#addyears-addmonths-addweeks-adddays-addhours-addminutes-addseconds-addquarters)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractYears
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [subtractYears](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#subtractyears-subtractmonths-subtractweeks-subtractdays-subtracthours-subtractminutes-subtractseconds-subtractquarters)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractMonths
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [subtractMonths](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#subtractyears-subtractmonths-subtractweeks-subtractdays-subtracthours-subtractminutes-subtractseconds-subtractquarters)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractWeeks
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [subtractWeeks](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#subtractyears-subtractmonths-subtractweeks-subtractdays-subtracthours-subtractminutes-subtractseconds-subtractquarters)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractDays
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [subtractDays](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#subtractyears-subtractmonths-subtractweeks-subtractdays-subtracthours-subtractminutes-subtractseconds-subtractquarters)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractHours
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [subtractHours](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#subtractyears-subtractmonths-subtractweeks-subtractdays-subtracthours-subtractminutes-subtractseconds-subtractquarters)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractMinutes
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [subtractMinutes](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#subtractyears-subtractmonths-subtractweeks-subtractdays-subtracthours-subtractminutes-subtractseconds-subtractquarters)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractSeconds
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [subtractSeconds](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#subtractyears-subtractmonths-subtractweeks-subtractdays-subtracthours-subtractminutes-subtractseconds-subtractquarters)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.subtractQuarters
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [subtractQuarters](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#subtractyears-subtractmonths-subtractweeks-subtractdays-subtracthours-subtractminutes-subtractseconds-subtractquarters)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.dateDiff
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [dateDiff](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#datediff)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.timeSlots
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [timeSlots](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#timeslotsstarttime-duration-size)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.DatesAndTimesFunctions.formatDateTime
+version: 1.0
+
+[ClickHouse] SHALL support correct operation of the [formatDateTime](https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#formatdatetime)
+function used with the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+
+#### Type Conversion Functions
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toInt(8|16|32|64|128|256)
+version: 1.0
+
+[ClickHouse] SHALL support correct conversion of the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range]
+to integer types using [toInt(8|16|32|64|128|256)](https://clickhouse.tech/docs/en/sql-reference/functions/type-conversion-functions/#toint8163264128256) functions.
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toUInt(8|16|32|64|256)
+version: 1.0
+
+[ClickHouse] SHALL support correct conversion of the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range]
+to unsigned integer types using [toUInt(8|16|32|64|256)](https://clickhouse.tech/docs/en/sql-reference/functions/type-conversion-functions/#touint8163264256) functions.
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toFloat(32|64)
+version: 1.0
+
+[ClickHouse] SHALL support correct conversion of the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range]
+to float types using [toFloat(32|64)](https://clickhouse.tech/docs/en/sql-reference/functions/type-conversion-functions/#tofloat3264) functions.
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toDate
+version: 1.0
+
+[ClickHouse] SHALL support correct conversion of the [DateTime64] data type when it stores dates within the [normal date range]
+to the [Date](https://clickhouse.tech/docs/en/sql-reference/data-types/date/) type using the [toDate](https://clickhouse.tech/docs/en/sql-reference/functions/type-conversion-functions/#todate) function.
+This function is ONLY supposed to work in NORMAL RANGE.
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toDateTime
+version: 1.0
+
+[ClickHouse] SHALL support correct conversion of the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range]
+to the [DateTime](https://clickhouse.tech/docs/en/sql-reference/data-types/datetime/) type using the [toDateTime](https://clickhouse.tech/docs/en/sql-reference/functions/type-conversion-functions/#todatetime) function.
+This function is ONLY supposed to work in NORMAL RANGE.
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toDateTime64
+version: 1.0
+
+[ClickHouse] SHALL support correct conversion from the data types supported by the [toDateTime64](https://clickhouse.tech/docs/en/sql-reference/data-types/datetime64/) function
+to the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range].
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toDateTime64.FromString.MissingTime
+version: 1.0
+
+[ClickHouse] SHALL support correct conversion from the [String](https://clickhouse.tech/docs/en/sql-reference/data-types/string/)
+data type to the [DateTime64](https://clickhouse.tech/docs/en/sql-reference/data-types/datetime64/) data type
+when value of the string is missing the `hh:mm-ss.sss` part.
+For example, `toDateTime64('2020-01-01', 3)`.
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toDecimal(32|64|128|256)
+version: 1.0
+
+[ClickHouse] SHALL support correct conversion of the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range]
+to [Decimal](https://clickhouse.tech/docs/en/sql-reference/data-types/decimal/) types using [toDecimal(32|64|128|256)](https://clickhouse.tech/docs/en/sql-reference/functions/type-conversion-functions/#todecimal3264128256) functions.
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toString
+version: 1.0
+
+[ClickHouse] SHALL support correct conversion of the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range]
+to the [String](https://clickhouse.tech/docs/en/sql-reference/data-types/string/) type using the [toString](https://clickhouse.tech/docs/en/sql-reference/functions/type-conversion-functions/#tostring) function.
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.CAST(x,T)
+version: 1.0
+
+[ClickHouse] SHALL support correct conversion of the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range]
+to one of the supported data type using the [CAST(x,T)](https://clickhouse.tech/docs/en/sql-reference/functions/type-conversion-functions/#type_conversion_function-cast) function.
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toUnixTimestamp64Milli
+version: 1.0
+
+[ClickHouse] SHALL support correct conversion of the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range]
+to the [Int64](https://clickhouse.tech/docs/en/sql-reference/data-types/int-uint/) type using the [toUnixTimestamp64Milli](https://clickhouse.tech/docs/en/sql-reference/functions/type-conversion-functions/#tounixtimestamp64milli) function.
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toUnixTimestamp64Micro
+version: 1.0
+
+[ClickHouse] SHALL support correct conversion of the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range]
+to the [Int64](https://clickhouse.tech/docs/en/sql-reference/data-types/int-uint/) type using the [toUnixTimestamp64Micro](https://clickhouse.tech/docs/en/sql-reference/functions/type-conversion-functions/#tounixtimestamp64micro) function.
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.toUnixTimestamp64Nano
+version: 1.0
+
+[ClickHouse] SHALL support correct conversion of the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range]
+to the [Int64](https://clickhouse.tech/docs/en/sql-reference/data-types/int-uint/) type using the [toUnixTimestamp64Nano](https://clickhouse.tech/docs/en/sql-reference/functions/type-conversion-functions/#tounixtimestamp64nano) function.
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.fromUnixTimestamp64Milli
+version: 1.0
+
+[ClickHouse] SHALL support correct conversion from the [Int64](https://clickhouse.tech/docs/en/sql-reference/data-types/int-uint/) type
+to the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range]
+using the [fromUnixTimestamp64Milli](https://clickhouse.tech/docs/en/sql-reference/functions/type-conversion-functions/#fromunixtimestamp64milli) function.
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.fromUnixTimestamp64Micro
+version: 1.0
+
+[ClickHouse] SHALL support correct conversion from the [Int64](https://clickhouse.tech/docs/en/sql-reference/data-types/int-uint/) type
+to the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range]
+using the [fromUnixTimestamp64Micro](https://clickhouse.tech/docs/en/sql-reference/functions/type-conversion-functions/#fromunixtimestamp64micro) function.
+
+###### RQ.SRS-010.DateTime64.ExtendedRange.TypeConversionFunctions.fromUnixTimestamp64Nano
+version: 1.0
+
+[ClickHouse] SHALL support correct conversion from the [Int64](https://clickhouse.tech/docs/en/sql-reference/data-types/int-uint/) type
+to the [DateTime64] data type when it stores dates within the [normal date range] and the [extended date range]
+using the [fromUnixTimestamp64Nano](https://clickhouse.tech/docs/en/sql-reference/functions/type-conversion-functions/#fromunixtimestamp64nano) function.
+
+## References
+
+* **DateTime64**: https://clickhouse.tech/docs/en/sql-reference/data-types/datetime64/
+* **ISO 8601 format**: https://en.wikipedia.org/wiki/ISO_8601
+* **ClickHouse:** https://clickhouse.tech
+* **GitHub Repository:** https://github.com/ClickHouse/ClickHouse/blob/master/tests/testflows/datetime64_extended_range/requirements/requirements.md
+* **Revision History:** https://github.com/ClickHouse/ClickHouse/commits/master/tests/testflows/datetime64_extended_range/requirements/requirements.md
+* **Git:** https://git-scm.com/
+
+[SRS]: #srs
+[normal date range]: #normal-date-range
+[extended date range]: #extended-date-range
+[Dates and Times Functions]: https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/
+[DateTime64]: https://clickhouse.tech/docs/en/sql-reference/data-types/datetime64/
+[ISO 8601 format]: https://en.wikipedia.org/wiki/ISO_8601
+[ClickHouse]: https://clickhouse.tech
+[GitHub Repository]: https://github.com/ClickHouse/ClickHouse/blob/master/tests/testflows/datetime64_extended_range/requirements/requirements.md
+[Revision History]: https://github.com/ClickHouse/ClickHouse/commits/master/tests/testflows/datetime64_extended_range/requirements/requirements.md
+[Git]: https://git-scm.com/
+[GitHub]: https://github.com
+''')
diff --git a/tests/testflows/datetime64_extended_range/tests/common.py b/tests/testflows/datetime64_extended_range/tests/common.py
new file mode 100644
index 00000000000..31051f38eb8
--- /dev/null
+++ b/tests/testflows/datetime64_extended_range/tests/common.py
@@ -0,0 +1,179 @@
+import pytz
+import datetime
+
+from testflows.core import *
+from testflows.asserts import error
+from contextlib import contextmanager
+from datetime64_extended_range.common import *
+
+
+def in_normal_range(dt: datetime.datetime):
+    """Check if DateTime is in normal range
+    """
+    return dt <= datetime.datetime(2105, 12, 31, 23, 59, 59, 999999) and dt >= datetime.datetime(1970, 1, 1, 0, 0, 0)
+
+
+def years_range(stress=False, padding=(0, 0)):
+    """Returns a set of year values used for testing.
+    """
+    return range(1925+padding[0], 2283-padding[1]) if stress else (1927, 2000, 2281)
+
+
+def timezones_range(stress=False):
+    """Returns a set of timezone values used for testing.
+    """
+    if stress:
+        return pytz.all_timezones
+    else:
+        return ['UTC', 'Asia/Novosibirsk', 'America/Denver']
+
+
+@contextmanager
+def create_table(timezone, node):
+    try:
+        node.query(f"CREATE TABLE dt(timestamp DateTime64(3, {timezone})) Engine = TinyLog")
+        yield
+    finally:
+        node.query("DROP TABLE dt")
+
+
+@TestOutline
+def insert_check_datetime(self, datetime, expected, precision=0, timezone="UTC"):
+    """Check how a particular datetime value works with different
+    functions that accept DateTime64 data type.
+
+    :param datetime: datetime string
+    :param expected: expected result
+    :param precision: time precision, default: 0
+    :param timezone: timezone, default: UTC
+    """
+    with create_table(timezone, self.context.node):
+        with When("I use toDateTime64"):
+            r = self.context.node.query(f"SELECT toDateTime64('{datetime}', {precision}, '{timezone}')")
+
+    with Then(f"I expect {expected}"):
+        assert r.output == expected, error()
+
+
+def datetime_generator(year, microseconds=False):
+    """Helper generator
+    """
+    date = datetime.datetime(year, 1, 1, 0, 0, 0)
+    if microseconds:
+        date = datetime.datetime(year, 1, 1, 0, 0, 0, 123000)
+    while not (date.month == 12 and date.day == 31):
+        yield date
+        date = date + datetime.timedelta(days=1, hours=1, minutes=1, seconds=1)
+
+
+def select_dates_in_year(year, stress=False, microseconds=False):
+    """Returns various datetimes in a year that are to be checked
+    """
+    if not stress:
+        dates = [datetime.datetime(year, 1, 1, 0, 0, 0), datetime.datetime(year, 12, 31, 23, 59, 59)]
+        if microseconds:
+            dates = [datetime.datetime(year, 1, 1, 0, 0, 0, 123000), datetime.datetime(year, 12, 31, 23, 59, 59, 123000)]
+        if year % 4 == 0 and (year % 100 != 0 or year % 400 == 0):
+            dates.append(datetime.datetime(year, 2, 29, 11, 11, 11, 123000))
+        return dates
+    else:
+        return datetime_generator(year)
+
+
+@TestOutline
+def select_check_datetime(self, datetime, expected, precision=0, timezone="UTC"):
+    """Check how a particular datetime value works with different
+    functions that accept DateTime64 data type.
+
+    :param datetime: datetime string
+    :param expected: expected result
+    :param precision: time precision, default: 0
+    :param timezone: timezone, default: UTC
+    """
+    with When("I use toDateTime64"):
+        r = self.context.node.query(f"SELECT toDateTime64('{datetime}', {precision}, '{timezone}')")
+
+    with Then(f"I expect {expected}"):
+        assert r.output == expected, error()
+
+
+@TestStep(When)
+def exec_query(self, request, expected=None, exitcode=None):
+    """Execute a query and check expected result.
+    :param request: query string
+    :param expected: result string
+    :param exitcode: exitcode
+    """
+    r = self.context.node.query(request)
+
+    if expected is not None:
+        with Then(f"output should match the expected", description=f"{expected}"):
+            assert r.output == expected, error()
+
+    elif exitcode is not None:
+        with Then(f"output exitcode should match expected", description=f"{exitcode}"):
+            assert r.exitcode == exitcode, error()
+
+
+@TestStep
+def walk_datetime_in_incrementing_steps(self, date, hrs_range=(0, 24), step=1, timezone="UTC", precision=0):
+    """Sweep time starting from some start date. The time is incremented
+    in steps specified by the `step` parameter
+    (default: 1 min).
+
+    :param hrs_range: range in hours
+    :param step: step in minutes
+    """
+
+    stress = self.context.stress
+
+    tasks = []
+    pool = Pool(4)
+    secs = f"00{'.' * (precision > 0)}{'0' * precision}"
+
+    try:
+        with When(f"I loop through datetime range {hrs_range} starting from {date} in {step}min increments"):
+            for hrs in range(*hrs_range) if stress else (hrs_range[0], hrs_range[1]-1):
+                for mins in range(0, 60, step) if stress else (0, 59):
+                    datetime = f"{date} {str(hrs).zfill(2)}:{str(mins).zfill(2)}:{secs}"
+                    expected = datetime
+
+                    with When(f"time is {datetime}"):
+                        run_scenario(pool, tasks, Test(name=f"{hrs}:{mins}:{secs}", test=select_check_datetime),
+                                     kwargs=dict(datetime=datetime, precision=precision, timezone=timezone,
+                                                 expected=expected))
+    finally:
+        join(tasks)
+
+
+@TestStep
+def walk_datetime_in_decrementing_steps(self, date, hrs_range=(23, 0), step=1, timezone="UTC", precision=0):
+    """Sweep time starting from some start date. The time is decremented
+    in steps specified by the `step` parameter
+    (default: 1 min).
+
+    :param date: string
+    :param hrs_range: range in hours
+    :param step: step in minutes
+    :param timezone: String
+    """
+
+    stress = self.context.stress
+
+    tasks = []
+    pool = Pool(4)
+    secs = f"00{'.' * (precision > 0)}{'0' * precision}"
+
+    try:
+        with When(f"I loop through datetime range {hrs_range} starting from {date} in {step}min decrements"):
+            for hrs in range(*hrs_range, -1) if stress else (hrs_range[1], hrs_range[0]):
+                for mins in range(59, 0, -step) if stress else (59, 0):
+                    datetime = f"{date} {str(hrs).zfill(2)}:{str(mins).zfill(2)}:{secs}"
+                    expected = datetime
+
+                    with When(f"time is {datetime}"):
+                        run_scenario(pool, tasks, Test(name=f"{hrs}:{mins}:{secs}", test=select_check_datetime),
+                                     kwargs=dict(datetime=datetime, precision=precision, timezone=timezone,
+                                                 expected=expected))
+    finally:
+        join(tasks)
diff --git a/tests/testflows/datetime64_extended_range/tests/date_time_functions.py b/tests/testflows/datetime64_extended_range/tests/date_time_functions.py
new file mode 100644
index 00000000000..0bf756d3660
--- /dev/null
+++ b/tests/testflows/datetime64_extended_range/tests/date_time_functions.py
@@ -0,0 +1,1533 @@
+import time
+import pytz
+import itertools
+from testflows.core import *
+import dateutil.relativedelta as rd
+from datetime import datetime, timedelta
+
+from datetime64_extended_range.requirements.requirements import *
+from datetime64_extended_range.common import *
+from datetime64_extended_range.tests.common import *
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toTimeZone("1.0")
+)
+def to_time_zone(self):
+    """Check the toTimeZone() function with DateTime64 extended range.
+    """
+    stress = self.context.stress
+    timezones = timezones_range(stress)
+
+    for year in years_range(stress):
+        with Given("I select datetimes in a year"):
+            datetimes = select_dates_in_year(year=year, stress=stress)
+
+        for dt in datetimes:
+            for tz1, tz2 in itertools.product(timezones, timezones):
+                with Step(f"{dt} {tz1} -> {tz2}"):
+                    with By("Computing expected output using pytz"):
+                        dt_local = pytz.timezone(tz1).localize(dt)
+                        dt_transformed = dt_local.astimezone(pytz.timezone(tz2))
+                        tz2_expected = dt_transformed.strftime("%Y-%m-%d %H:%M:%S")
+                    with And("Forming a toTimeZone ClickHouse query"):
+                        tz1_query = dt_local.strftime("%Y-%m-%d %H:%M:%S")
+                        query = f"SELECT toTimeZone(toDateTime64('{tz1_query}', 0, '{tz1}'), '{tz2}')"
+                    with Then(f"I execute query", flags=TE):
+                        exec_query(request=query, expected=f"{tz2_expected}")
+
+
+@TestOutline
+def to_date_part(self, py_func, ch_func):
+    """Check the toYear/toMonth/toQuarter functions with DateTime64 extended range.
+    """
+    stress = self.context.stress
+
+    for year in years_range(stress):
+        with Given(f"I choose datetimes in {year}"):
+            datetimes = select_dates_in_year(year=year, stress=stress)
+            timezones = timezones_range(stress)
+
+        with When("I check each of the datetimes"):
+            for dt in datetimes:
+                for tz1, tz2 in itertools.product(timezones, timezones):
+                    with Step(f"{dt} {tz1}, {tz2}"):
+                        with Given("I compute expected output using pytz"):
+                            with By(f"localizing {dt} using {tz1} timezone"):
+                                time_tz1 = pytz.timezone(tz1).localize(dt)
+                            with And(f"converting {tz1} local datetime {dt} to {tz2} timezone"):
+                                time_tz2 = time_tz1.astimezone(pytz.timezone(tz2))
+                            with And(f"calling the '{py_func}' method of the datetime object to get expected result"):
+                                result = eval(f"(time_tz2.{py_func}")
+                            expected = f"{result}"
+                        with And(f"Forming a {ch_func} ClickHouse query"):
+                            dt_str = dt.strftime("%Y-%m-%d %H:%M:%S")
+                            query = f"SELECT {ch_func}(toDateTime64('{dt_str}', 0, '{tz1}'), '{tz2}')"
+                        with Then(f"I execute query that uses '{ch_func}' function"):
+                            exec_query(request=query, expected=f"{expected}")
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toYear("1.0"),
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toRelativeYearNum("1.0")
+)
+def to_year(self):
+    """Check the toYear() and toRelativeYearNum() [which is just an alias for toYear]
+    function with DateTime64 extended range.
+    """
+    to_date_part(py_func="year)", ch_func="toYear")
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toMonth("1.0")
+)
+def to_month(self):
+    """Check the toMonth() function with DateTime64 extended range.
+    """
+    to_date_part(py_func="month)", ch_func="toMonth")
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toQuarter("1.0")
+)
+def to_quarter(self):
+    """Check the toQuarter() function with DateTime64 extended range
+    by comparing the output of the toQuarter() function with
+    the value of the 'month' attribute of the datetime object
+    divided by 3 (because each quarter has 3 month) plus 1
+    (because we starting the count from 1).
+    """
+    to_date_part(py_func="month - 1)//3 + 1", ch_func="toQuarter")
+
+
+@TestOutline
+def to_day_of(self, py_func, ch_func):
+    """Check the toDayOf....() functions with DateTime64 extended range.
+    """
+    stress = self.context.stress
+
+    for year in years_range(stress):
+        with Given(f"I choose datetimes in {year}"):
+            datetimes = select_dates_in_year(year=year, stress=stress)
+            timezones = timezones_range(stress)
+
+        with When("I check each of the datetimes"):
+            for dt in datetimes:
+                for tz1, tz2 in itertools.product(timezones, timezones):
+                    with When(f"{dt} {tz1} -> {tz2}"):
+                        with By("Computing expected result using pytz"):
+                            time_tz1 = pytz.timezone(tz1).localize(dt)
+                            time_tz2 = time_tz1.astimezone(pytz.timezone(tz2))
+                            result = eval(f"time_tz2.timetuple().{py_func}")
+                            if py_func == "tm_wday":
+                                result += 1
+                            expected = f"{result}"
+                        with And(f"Forming a {ch_func} ClickHouse query"):
+                            dt_str = dt.strftime("%Y-%m-%d %H:%M:%S")
+                            query = f"SELECT {ch_func}(toDateTime64('{dt_str}', 0, '{tz1}'), '{tz2}')"
+                        with Then(f"I execute {ch_func} query"):
+                            exec_query(request=query, expected=f"{expected}")
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toDayOfYear("1.0")
+)
+def to_day_of_year(self):
+    """Check toDayOfYear() function with DateTime64 extended range date time.
+    """
+    to_day_of(py_func="tm_yday", ch_func="toDayOfYear")
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toDayOfMonth("1.0")
+)
+def to_day_of_month(self):
+    """Check toDayOfMonth() function with DateTime64 extended range date time.
+    """
+    to_day_of(py_func="tm_mday", ch_func="toDayOfMonth")
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toDayOfWeek("1.0")
+)
+def to_day_of_week(self):
+    """Check toDayOfWeek() function with DateTime64 extended range date time.
+    """
+    to_day_of(py_func="tm_wday", ch_func="toDayOfWeek")
+
+
+@TestOutline
+def to_time_part(self, py_func, ch_func):
+    """Check the functions like toHour/toMinute/toSecond with DateTime64 extended range.
+    """
+    stress = self.context.stress
+
+    for year in years_range(stress):
+        with Given(f"I choose datetimes in {year}"):
+            datetimes = select_dates_in_year(year=year, stress=stress)
+            timezones = timezones_range(stress)
+
+        with When("I check each of the datetimes"):
+            for dt in datetimes:
+                for tz1, tz2 in itertools.product(timezones, timezones):
+                    with Step(f"{dt} {tz1} -> {tz2}"):
+                        with By("computing expected result using pytz"):
+                            time_tz1 = pytz.timezone(tz1).localize(dt)
+                            time_tz2 = time_tz1.astimezone(pytz.timezone(tz2))
+                            result = eval(f"time_tz2.{py_func}")
+                            expected = f"{result}"
+                        with And("forming a ClickHouse query"):
+                            dt_str = dt.strftime("%Y-%m-%d %H:%M:%S")
+                            query = f"SELECT {ch_func}(toDateTime64('{dt_str}', 0, '{tz1}'), '{tz2}')"
+                        with Then("I execute query"):
+                            exec_query(request=query, expected=f"{expected}")
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toHour("1.0")
+)
+def to_hour(self):
+    """Check toHour() function with DateTime64 extended range date time.
+    """
+    to_time_part(py_func="hour", ch_func="toHour")
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toMinute("1.0")
+)
+def to_minute(self):
+    """Check toMinute() function with DateTime64 extended range date time.
+    """
+    to_time_part(py_func="minute", ch_func="toMinute")
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toSecond("1.0")
+)
+def to_second(self):
+    """Check toSecond() function with DateTime64 extended range date time.
+    """
+    to_time_part(py_func="second", ch_func="toSecond")
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toUnixTimestamp("1.0")
+)
+def to_unix_timestamp(self):
+    """Check the toUnixTimestamp() function with DateTime64 extended range
+    """
+    stress = self.context.stress
+
+    for year in years_range(stress):
+        with Given(f"I choose datetimes in {year}"):
+            datetimes = select_dates_in_year(year=year, stress=stress)
+            timezones = timezones_range(stress)
+
+        with When("I check each of the datetimes"):
+            for dt in datetimes:
+                for tz in timezones:
+                    with Step(f"{dt} {tz}"):
+                        with By("computing expected result using python"):
+                            dt_str = dt.strftime("%Y-%m-%d %H:%M:%S")
+                            expected = f"{int(time.mktime(datetime.datetime.now().timetuple()))}"
+                        with And("forming a ClickHouse query"):
+                            query = f"SELECT toUnixTimestamp(toDateTime64('{dt_str}', 0, '{tz}'))"
+                        with Then("I execute query"):
+                            exec_query(request=query, expected=expected)
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toStartOfYear("1.0")
+)
+def to_start_of_year(self):
+    """Check the functions toStartOfYear with DateTime64 extended range."""
+    stress = self.context.stress
+    timezones = timezones_range(stress)
+
+    for year in years_range(stress):
+        with Given(f"I choose datetimes in {year}"):
+            datetimes = select_dates_in_year(year=year, stress=stress)
+
+        with When("I check each of the datetimes"):
+            for dt in datetimes:
+                for tz1, tz2 in itertools.product(timezones, timezones):
+                    with Step(f"{dt} {tz1} -> {tz2}"):
+                        with By("computing expected time using python"):
+                            time_tz1 = pytz.timezone(tz1).localize(dt)
+                            time_tz2 = time_tz1.astimezone(pytz.timezone(tz2))
+                            expected = f"{time_tz2.year}-01-01"
+                        with And("forming ClickHouse query"):
+                            dt_str = dt.strftime("%Y-%m-%d %H:%M:%S")
+                            query = f"SELECT toStartOfYear(toDateTime64('{dt_str}', 0, '{tz1}'), '{tz2}')"
+                        with Then("I execute query"):
+                            exec_query(request=query, expected=f"{expected}")
+
+
+def iso_year_start(dt):
+    """Helper to find the beginning of iso year."""
+    dt_s = datetime.datetime(dt.year-1, 12, 23, 0, 0, 0)
+    while dt_s.isocalendar()[0] != dt.year:
+        dt_s += datetime.timedelta(days=1)
+    return dt_s
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toStartOfISOYear("1.0")
+)
+def to_start_of_iso_year(self):
+    """Check the functions toStartOfISOYear with DateTime64 extended range."""
+    stress = self.context.stress
+    timezones = timezones_range(stress)
+
+    for year in years_range(stress):
+        with Given(f"I choose datetimes in {year}"):
+            datetimes = select_dates_in_year(year=year, stress=stress)
+
+        with When("I check each of the datetimes"):
+            for dt in datetimes:
+                for tz in timezones:
+                    with Step(f"{dt} {tz}"):
+                        with By("Computing expected result using Python"):
+                            expected = iso_year_start(dt)
+                        with And("Forming a toStartOfISOYear ClickHouse query"):
+                            dt_str = dt.strftime("%Y-%m-%d %H:%M:%S")
+                            query = f"SELECT toStartOfISOYear(toDateTime64('{dt_str}', 0, '{tz}'))"
+                        with Then("I execute toStartOfISOYear query"):
+                            exec_query(request=query, expected=f"{expected.strftime('%Y-%m-%d')}")
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toStartOfQuarter("1.0")
+)
+def to_start_of_quarter(self):
+    """Check the functions toStartOfQuarter with
+    DateTime64 extended range.
+    """
+    stress = self.context.stress
+    timezones = timezones_range(stress)
+
+    for year in years_range(stress):
+        with Given(f"I choose datetimes in {year}"):
+            datetimes = select_dates_in_year(year=year, stress=stress)
+        with When("I check each of the datetimes"):
+            for dt in datetimes:
+                for tz1, tz2 in itertools.product(timezones, timezones):
+                    with Step(f"{dt} {tz1} -> {tz2}"):
+                        with By("computing expected result with python"):
+                            time_tz1 = pytz.timezone(tz1).localize(dt)
+                            time_tz2 = time_tz1.astimezone(pytz.timezone(tz2))
+                            expected = f"{year}-{str(time_tz2.month//3 * 3 + 1).zfill(2)}-01"
+                        with And("forming ClickHouse query"):
+                            dt_str = dt.strftime("%Y-%m-%d %H:%M:%S")
+                            query = f"SELECT toStartOfQuarter(toDateTime64('{dt_str}', 0, '{tz1}'), '{tz2}')"
+                        with Then("I execute query"):
+                            exec_query(request=query, expected=f"{expected}")
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toStartOfMonth("1.0")
+)
+def to_start_of_month(self):
+    """Check the functions toStartOfMonth with
+    DateTime64 extended range.
+    """
+    stress = self.context.stress
+    timezones = timezones_range(stress)
+
+    for year in years_range(stress=stress):
+        with Given(f"I choose datetimes in {year}"):
+            datetimes = select_dates_in_year(year=year, stress=stress)
+        with When("I check each of the datetimes"):
+            for dt in datetimes:
+                for tz1, tz2 in itertools.product(timezones, timezones):
+                    with Step(f"{dt} {tz1} -> {tz2}"):
+                        with By("computing expected result with python"):
+                            time_tz1 = pytz.timezone(tz1).localize(dt)
+                            time_tz2 = time_tz1.astimezone(pytz.timezone(tz2))
+                            expected = f"{time_tz2.strftime('%Y-%m')}-01"
+                        with And("forming ClickHouse query"):
+                            dt_str = dt.strftime("%Y-%m-%d %H:%M:%S")
+                            query = f"SELECT toStartOfQuarter(toDateTime64('{dt_str}', 0, '{tz1}'), '{tz2}')"
+                        with Then("I execute query"):
+                            exec_query(request=query, expected=f"{expected}")
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toMonday("1.0")
+)
+def to_monday(self):
+    """Check the functions toMonday with
+    DateTime64 extended range.
+    """
+    stress = self.context.stress
+    timezones = timezones_range(stress)
+
+    for year in years_range(stress):
+        with Given(f"I choose datetimes in {year}"):
+            datetimes = select_dates_in_year(year=year, stress=stress)
+        with When("I check each of the datetimes"):
+            for dt in datetimes:
+                for tz1, tz2 in itertools.product(timezones, timezones):
+                    with Step(f"{dt} {tz1} -> {tz2}"):
+                        with By("computing expected result with python"):
+                            time_tz1 = pytz.timezone(tz1).localize(dt)
+                            time_tz2 = time_tz1.astimezone(pytz.timezone(tz2))
+                            expected_date = time_tz2 + datetime.timedelta(days=(-dt.weekday() if dt.weekday() <= 3 else 7 - dt.weekday()))
+                            expected = f"{expected_date.strftime('%Y-%m-%d')}"
+                        with And("forming ClickHouse query"):
+                            dt_str = dt.strftime("%Y-%m-%d %H:%M:%S")
+                            query = f"SELECT toMonday(toDateTime64('{dt_str}', 0, '{tz1}'), '{tz2}')"
+                        with Then("I execute query"):
+                            exec_query(request=query, expected=f"{expected}")
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toStartOfWeek("1.0")
+)
+def to_start_of_week(self):
+    """Check the functions toStartOfWeek with DateTime64 extended range."""
+    stress = self.context.stress
+    timezones = timezones_range(stress)
+
+    for year in years_range(stress):
+        with Given(f"I choose datetimes in {year}"):
+            datetimes = select_dates_in_year(year=year, stress=stress)
+        with When("I check each of the datetimes"):
+            for dt in datetimes:
+                for tz1, tz2 in itertools.product(timezones, timezones):
+                    for mode in (0, 1):   # mode - week beginning, either 0 (Sunday) or 1 (Monday)
+                        with Step(f"{dt} {tz1} -> {tz2}"):
+                            with By("computing expected result with python"):
+                                time_tz1 = pytz.timezone(tz1).localize(dt)
+                                time_tz2 = time_tz1.astimezone(pytz.timezone(tz2))
+                                expected_date = time_tz2 + datetime.timedelta(
+                                        days=(mode - dt.weekday() if dt.weekday() <= (3+mode) else (mode + 7) - dt.weekday()))
+                                expected = f"{expected_date.strftime('%Y-%m-%d')}"
+                            with And("forming ClickHouse query"):
+                                dt_str = dt.strftime("%Y-%m-%d %H:%M:%S")
+                                query = f"SELECT toStartOfWeek(toDateTime64('{dt_str}', 0, '{tz1}'), {mode}, '{tz2}')"
+                            with Then("I execute query"):
+                                exec_query(request=query, expected=f"{expected}")
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toStartOfDay("1.0")
+)
+def to_start_of_day(self):
+    """Check the functions toStartOfDay with DateTime64 extended range."""
+    stress = self.context.stress
+    timezones = timezones_range(stress)
+
+    for year in years_range(stress):
+        with Given(f"I choose datetimes in {year}"):
+            datetimes = select_dates_in_year(year=year, stress=stress)
+        with When("I check each of the datetimes"):
+            for dt in datetimes:
+                for tz in timezones:
+                    with Step(f"{dt} {tz}"):
+                        with By("computing expected result with python"):
+                            expected = f"{dt.strftime('%Y-%m-%d')} 00:00:00"
+                        with And("forming ClickHouse query"):
+                            dt_str = dt.strftime("%Y-%m-%d %H:%M:%S")
+                            query = f"SELECT toStartOfDay(toDateTime64('{dt_str}', 0, '{tz}'))"
+                        with Then("I execute query"):
+                            exec_query(request=query, expected=f"{expected}")
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toStartOfHour("1.0")
+)
+def to_start_of_hour(self):
+    """Check the functions toStartOfHour with DateTime64 extended range."""
+    stress = self.context.stress
+    timezones = timezones_range(stress)
+
+    for year in years_range(stress):
+        with Given(f"I choose datetimes in {year}"):
+            datetimes = select_dates_in_year(year=year, stress=stress)
+
+        with When("I check each of the datetimes"):
+            for dt in datetimes:
+                for tz in timezones:
+                    with Step(f"{dt} {tz}"):
+                        with By("computing expected result with python"):
+                            expected = f"{dt.strftime('%Y-%m-%d %H')}:00:00"
+                        with And("forming ClickHouse query"):
+                            dt_str = dt.strftime("%Y-%m-%d %H:%M:%S")
+                            query = f"SELECT toStartOfHour(toDateTime64('{dt_str}', 0, '{tz}'))"
+                        with Then("I execute query"):
+                            exec_query(request=query, expected=f"{expected}")
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toStartOfMinute("1.0")
+)
+def to_start_of_minute(self):
+    """Check the functions toStartOfMinute with DateTime64 extended range."""
+    stress = self.context.stress
+    timezones = timezones_range(stress)
+
+    for year in years_range(stress):
+        with Given(f"I choose datetimes in {year}"):
+            datetimes = select_dates_in_year(year=year, stress=stress)
+
+        with When("I check each of the datetimes"):
+            for dt in datetimes:
+                for tz in timezones:
+                    with Step(f"{dt} {tz}"):
+                        with By("computing expected result with python"):
+                            expected = f"{dt.strftime('%Y-%m-%d %H:%M')}:00"
+                        with And("forming ClickHouse query"):
+                            dt_str = dt.strftime("%Y-%m-%d %H:%M:%S")
+                            query = f"SELECT toStartOfMinute(toDateTime64('{dt_str}', 0, '{tz}'))"
+                        with Then("I execute query"):
+                            exec_query(request=query, expected=f"{expected}")
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toStartOfSecond("1.0")
+)
+def to_start_of_second(self):
+    """Check the functions toStartOfSecond with DateTime64 extended range."""
+    stress = self.context.stress
+    timezones = timezones_range(stress)
+
+    for year in years_range(stress=stress):
+        with Given(f"I choose datetimes in {year}"):
+            datetimes = select_dates_in_year(year=year, stress=stress, microseconds=True)
+
+        with When("I check each of the datetimes"):
+            for dt in datetimes:
+                for tz in timezones:
+                    with Step(f"{dt} {tz}"):
+                        with By("computing expected result with python"):
+                            expected = f"{dt.strftime('%Y-%m-%d %H:%M:%S')}.000000"
+                        with And("forming ClickHouse query"):
+                            dt_str = dt.strftime("%Y-%m-%d %H:%M:%S.%f")
+                            query = f"SELECT toStartOfSecond(toDateTime64('{dt_str}', 6, '{tz}'))"
+                        with Then("I execute query"):
+                            exec_query(request=query, expected=f"{expected}")
+
+
+@TestOutline
+def to_start_of_minutes_interval(self, interval, func):
+    """Check the functions like toStartOf....Minute with DateTime64 extended range."""
+    stress = self.context.stress
+    timezones = timezones_range(stress)
+
+    for year in years_range(stress=stress):
+        with Given(f"I choose datetimes in {year}"):
+            datetimes = select_dates_in_year(year=year, stress=stress, microseconds=True)
+
+        with When("I check each of the datetimes"):
+            for dt in datetimes:
+                for tz in timezones:
+                    with Step(f"{dt} {tz}"):
+                        with By("Computing expected result using python"):
+                            mins = dt.minute // interval * interval
+                            expected = f"{dt.strftime('%Y-%m-%d %H:')}{str(mins).zfill(2)}:00"
+                        with And(f"Forming a {func} query to ClickHouse"):
+                            dt_str = dt.strftime("%Y-%m-%d %H:%M:%S")
+                            query = f"SELECT {func}(toDateTime64('{dt_str}', 0, '{tz}'))"
+                        with Then(f"I execute {func} query"):
+                            exec_query(request=query, expected=f"{expected}")
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toStartOfFiveMinute("1.0")
+)
+def to_start_of_five_minute(self):
+    """Check the toStartOfFiveMinute with DateTime64 extended range."""
+    to_start_of_minutes_interval(interval=5, func="toStartOfFiveMinute")
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toStartOfTenMinutes("1.0")
+)
+def to_start_of_ten_minutes(self):
+    """Check the toStartOfTenMinutes with DateTime64 extended range."""
+    to_start_of_minutes_interval(interval=10, func="toStartOfTenMinutes")
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toStartOfFifteenMinutes("1.0")
+)
+def to_start_of_fifteen_minutes(self):
+    """Check the toStartOfFifteenMinutes with DateTime64 extended range."""
+    to_start_of_minutes_interval(interval=15, func="toStartOfFifteenMinutes")
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_timeSlot("1.0")
+)
+def time_slot(self):
+    """Check the timeSlot with DateTime64 extended range."""
+    to_start_of_minutes_interval(interval=30, func="timeSlot")
+
+
+def to_start_of_interval_helper(dt: datetime.datetime, interval_type, interval_value):
+    """A helper to switch through all possible intervals. Computes the interval beginning depending on
+    interval_type and interval_value, returns string expected to be returned by ClickHouse.
+    :param dt: datetime to be checked, datetime.datetime
+    :param interval_type: interval type selector, String
+    :param interval_value: interval size, int
+    """
+    intervals_in_seconds = {"SECOND": 1, "MINUTE": 60, "HOUR": 3600, "DAY": 68400, "WEEK": 604800}
+    zero_datetime = datetime.datetime(1970, 1, 1, 0, 0, 0)
+    delta = dt - zero_datetime
+
+    if interval_type in intervals_in_seconds.keys():
+        divisor = interval_value * intervals_in_seconds[interval_type]
+        retval = (zero_datetime + datetime.timedelta(seconds=(delta.seconds // divisor * divisor)))
+        if interval_type == "WEEK":
+            return retval.strftime("%Y-%m-%d")
+        return retval.strftime("%Y-%m-%d %H:%M:%S")
+
+    elif interval_type == "MONTH":
+        diff = (dt.year - zero_datetime.year) * 12 + (dt.month - zero_datetime.month)
+        result_diff = diff // interval_value * interval_value
+        return (zero_datetime + rd.relativedelta(months=result_diff)).strftime("%Y-%m-%d")
+
+    elif interval_type == "QUARTER":
+        diff = (dt.year - zero_datetime.year) * 4 + (dt.month // 4 - zero_datetime.month // 4)
+        result_diff = diff // interval_value * interval_value
+        return (zero_datetime + rd.relativedelta(months=result_diff*4)).strftime("%Y-%m-%d")
+
+    elif interval_type == "YEAR":
+        result_diff = (dt.year - zero_datetime.year) // interval_value * interval_value
+        return (zero_datetime + rd.relativedelta(years=result_diff)).strftime("%Y-%m-%d")
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toStartOfInterval("1.0")
+)
+def to_start_of_interval(self):
+    """Check the toStartOfInterval with DateTime64 extended range.
+    """
+    stress = self.context.stress
+    timezones = timezones_range(stress)
+
+    intervals_testing_ranges = {"SECOND": range(1, 15), "MINUTE": range(1, 15), "HOUR": range(1, 10), "DAY": (1, 5, 10),
+                                "WEEK": range(1, 5), "MONTH": range(1, 6), "QUARTER": range(1, 4), "YEAR": range(1, 5)}
+
+    for year in years_range(stress=stress):
+        with Given(f"I choose datetimes in {year}"):
+            datetimes = select_dates_in_year(year=year, stress=stress)
+
+        with When("I check each of the datetimes"):
+            for dt in datetimes:
+                for tz in timezones:
+                    for interval in intervals_testing_ranges.keys():
+                        for value in intervals_testing_ranges[interval]:
+                            with Step(f"{dt} {tz} {interval}: {value}"):
+                                with By("Computing expected result using python"):
+                                    expected = to_start_of_interval_helper(dt, interval, value)
+                                with And(f"Forming a toStartOfInterval() query to ClickHouse"):
+                                    dt_str = dt.strftime("%Y-%m-%d %H:%M:%S")
+                                    query = f"SELECT toStartOfInterval(toDateTime64('{dt_str}', 0, '{tz}'), INTERVAL {value} {interval})"
+                                with Then(f"I execute toStartOfInterval() query"):
+                                    exec_query(request=query, expected=f"{expected}")
+
+
+@TestOutline
+def to_iso(self, func, isocalendar_pos):
+    """Check the toISOYear/Week functions with DateTime64 extended range."""
+    stress = self.context.stress
+    timezones = timezones_range(stress)
+
+    for year in years_range(stress=stress):
+        with Given(f"I choose datetimes in {year}"):
+            datetimes = select_dates_in_year(year=year, stress=stress, microseconds=True)
+
+        with When("I check each of the datetimes"):
+            for dt in datetimes:
+                for tz in timezones:
+                    with Step(f"{dt} {tz}"):
+                        with By("computimg expected result uning python"):
+                            expected = f"{dt.isocalendar()[isocalendar_pos]}"
+                        with And("forming ClickHouse query"):
+                            dt_str = dt.strftime("%Y-%m-%d %H:%M:%S")
+                            query = f"SELECT {func}(toDateTime64('{dt_str}', 0, '{tz}'))"
+                        with Then("I execute query"):
+                            exec_query(request=query, expected=f"{expected}")
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toISOYear("1.0")
+)
+def to_iso_year(self):
+    """Check the toISOYear function with DateTime64 extended range."""
+    to_iso(func="toISOYear", isocalendar_pos=0)
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toISOWeek("1.0")
+)
+def to_iso_week(self):
+    """Check the toISOWeek function with DateTime64 extended range."""
+    to_iso(func="toISOWeek", isocalendar_pos=1)
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toTime("1.0")
+)
+def to_time(self):
+    """Check the toTime function with DateTime64 extended range."""
+    stress = self.context.stress
+    timezones = timezones_range(stress)
+
+    for year in years_range(stress=stress):
+        with Given(f"I choose datetimes in {year}"):
+            datetimes = select_dates_in_year(year=year, stress=stress, microseconds=True)
+
+        with When("I check each of the datetimes"):
+            for dt in datetimes:
+                for tz in timezones:
+                    with When(f"{dt} {tz}"):
+                        with By("computing expected result using python"):
+                            expected = f"1970-01-02 {dt.strftime('%H:%M:%S')}"
+                        with And("forming ClickHouse query"):
+                            dt_str = dt.strftime("%Y-%m-%d %H:%M:%S")
+                            query = f"SELECT toTime(toDateTime64('{dt_str}', 0, '{tz}'))"
+                        with Then("I execute query"):
+                            exec_query(request=query, expected=f"{expected}")
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toRelativeQuarterNum("1.0")
+)
+def to_relative_quarter_num(self):
+    """Check the toRelativeQuarterNum function with DateTime64 extended range."""
+    stress = self.context.stress
+    timezones = timezones_range(stress)
+
+    for year in years_range(stress=stress):
+        with Given(f"I choose datetimes in {year}"):
+            datetimes = select_dates_in_year(year=year, stress=stress, microseconds=True)
+
+        with When("I check each of the datetimes"):
+            for dt in datetimes:
+                for tz in timezones:
+                    with When(f"{dt} {tz}"):
+                        with By("computing expected result using python"):
+                            expected = f"{(year-1970)*4 + (dt.month - 1) // 3}"
+                        with And("forming ClickHouse query"):
+                            dt_str = dt.strftime("%Y-%m-%d %H:%M:%S")
+                            query = f"SELECT toRelativeQuarterNum(toDateTime64('{dt_str}', 0, '{tz}'))"
+                        with Then("I execute query"):
+                            exec_query(request=query, expected=f"{expected}")
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toRelativeWeekNum("1.0")
+)
+def to_relative_week_num(self):
+    """Check the toRelativeWeekNum function with DateTime64 extended range."""
+    stress = self.context.stress
+    timezones = timezones_range(stress)
+
+    for year in years_range(stress=stress):
+        with Given(f"I choose datetimes in {year}"):
+            datetimes = select_dates_in_year(year=year, stress=stress, microseconds=True)
+        with When("I check each of the datetimes"):
+            for dt in datetimes:
+                for tz in timezones:
+                    with When(f"{dt} {tz}"):
+                        with By("computing expected result using python"):
+                            week_num = ((dt + datetime.timedelta(days=8) - datetime.timedelta(days=dt.weekday())) - datetime.datetime(1970, 1, 1, 0, 0, 0)).days // 7
+                            expected = f"{week_num}"
+                        with And("forming ClickHouse query"):
+                            dt_str = dt.strftime("%Y-%m-%d %H:%M:%S")
+                            query = f"SELECT toRelativeWeekNum(toDateTime64('{dt_str}', 0, '{tz}'))"
+                        with Then("I execute query"):
+                            exec_query(request=query, expected=f"{expected}")
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toRelativeMonthNum("1.0")
+)
+def to_relative_month_num(self):
+    """Check the toRelativeMonthNum function with DateTime64 extended range."""
+    stress = self.context.stress
+    timezones = timezones_range(stress)
+
+    for year in years_range(stress=stress):
+        with Given(f"I choose datetimes in {year}"):
+            datetimes = select_dates_in_year(year=year, stress=stress, microseconds=True)
+
+        with When("I check each of the datetimes"):
+            for dt in datetimes:
+                for tz in timezones:
+                    with When(f"{dt} {tz}"):
+                        with By("computing expected result using python"):
+                            month_num = (year - 1970) * 12 + dt.month
+                            expected = f"{month_num}"
+                        with And("forming ClickHouse query"):
+                            dt_str = dt.strftime("%Y-%m-%d %H:%M:%S")
+                            query = f"SELECT toRelativeMonthNum(toDateTime64('{dt_str}', 0, '{tz}'))"
+                        with Then("I execute query"):
+                            exec_query(request=query, expected=f"{expected}")
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toRelativeDayNum("1.0")
+)
+def to_relative_day_num(self):
+    """Check the toRelativeDayNum function with DateTime64 extended range."""
+    stress = self.context.stress
+    timezones = timezones_range(stress)
+
+    for year in years_range(stress=stress):
+        with Given(f"I choose datetimes in {year}"):
+            datetimes = select_dates_in_year(year=year, stress=stress, microseconds=True)
+
+        with When("I check each of the datetimes"):
+            for dt in datetimes:
+                for tz in timezones:
+                    with When(f"{dt} {tz}"):
+                        with By("Computing the expected result using python"):
+                            day_num = (dt - datetime.datetime(1970, 1, 1, 0, 0, 0)).days
+                            expected = f"{day_num}"
+                        with And(f"Forming a toRelativeDayNum query to ClickHouse"):
+                            dt_str = dt.strftime("%Y-%m-%d %H:%M:%S")
+                            query = f"SELECT toRelativeDayNum(toDateTime64('{dt_str}', 0, '{tz}'))"
+                        with Then("I execute toRelativeDayNum query"):
+                            exec_query(request=query, expected=f"{expected}")
+
+
+@TestOutline
+def to_relative_time(self, divisor, func):
+    """Check the toRelative[Hour/Minute/Second]Num functions
+    with DateTime64 extended range.
+    """
+    stress = self.context.stress
+    timezones = timezones_range(stress)
+
+    for year in years_range(stress=stress):
+        with Given(f"I choose datetimes in {year}"):
+            datetimes = select_dates_in_year(year=year, stress=stress, microseconds=True)
+
+        with When("I check each of the datetimes"):
+            for dt in datetimes:
+                for tz in timezones:
+                    with When(f"{dt} {tz}"):
+                        with By("Computing the expected result using python"):
+                            result = (dt - datetime.datetime(1970, 1, 1, 0, 0, 0)).total_seconds() // divisor
+                            expected = f"{result}"
+                        with And(f"Forming a {func} query to ClickHouse"):
+                            dt_str = dt.strftime("%Y-%m-%d %H:%M:%S")
+                            query = f"SELECT {func}(toDateTime64('{dt_str}', 0, '{tz}'))"
+                        with Then(f"I execute {func} query"):
+                            exec_query(request=query, expected=f"{expected}")
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toRelativeHourNum("1.0")
+)
+def to_relative_hour_num(self):
+    """Check the toRelativeHourNum function
+    with DateTime64 extended range.
+    """
+    to_relative_time(func="toRelativeHourNum", divisor=3600)
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toRelativeMinuteNum("1.0")
+)
+def to_relative_minute_num(self):
+    """Check the toRelativeMinuteNum function
+    with DateTime64 extended range.
+    """
+    to_relative_time(func="toRelativeMinuteNum", divisor=60)
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toRelativeSecondNum("1.0")
+)
+def to_relative_second_num(self):
+    """Check the toRelativeSecondNum function
+    with DateTime64 extended range.
+    """
+    to_relative_time(func="toRelativeSecondNum", divisor=1)
+
+
+def to_week_compute_expected(dt: datetime.datetime, mode: int, ret_year=False):
+    """Helper to get the expected value for testing toWeek().
+    Due to necessity to manually check 10 workmodes, the subroutine was removed from to_week()
+    """
+    year = dt.year
+
+    ex = datetime.datetime(year, 1, 1)
+    j1_weekday = ex.weekday()
+
+    while ex.weekday() != 0:
+        ex += datetime.timedelta(days=1)
+    first_monday = ex.day-1
+
+    ex = datetime.datetime(year, 1, 1)
+    while ex.weekday() != 6:
+        ex += datetime.timedelta(days=1)
+    first_sunday = ex.day-1
+
+    if mode == 0:
+        # First day of week: Sunday, Week 1 is the first week with Sunday, range 0-53
+        expected = (dt - datetime.datetime(year, 1, 1) - datetime.timedelta(days=first_sunday)).days // 7 + 1
+
+    elif mode == 1:
+        # First day of week: Monday, Week 1 is the first week containing 4 or more days, range 0-53
+        if j1_weekday <= 3:
+            expected = (dt - datetime.datetime(year, 1, 1) + datetime.timedelta(days=7+j1_weekday)).days // 7
+        else:
+            expected = (dt - datetime.datetime(year, 1, 1) + datetime.timedelta(days=j1_weekday)).days // 7
+
+    elif mode == 2:
+        # First day of week: Sunday, Week 1 is the first week with Sunday, range 1-53
+        expected = (dt - datetime.datetime(year, 1, 1) - datetime.timedelta(days=first_sunday)).days // 7 + 1
+        if expected == 0:
+            return to_week_compute_expected(datetime.datetime(dt.year-1, 12, 31), 2)
+
+    elif mode == 3:
+        # First day of week: Monday, Week 1 is the first week containing 4 or more days, range 1-53
+        if j1_weekday <= 3:
+            expected = (dt - datetime.datetime(year, 1, 1) + datetime.timedelta(days=7+j1_weekday)).days // 7
+        else:
+            expected = (dt - datetime.datetime(year, 1, 1) + datetime.timedelta(days=j1_weekday)).days // 7
+        if expected == 0:
+            return to_week_compute_expected(datetime.datetime(dt.year-1, 12, 31), 3)
+
+    elif mode == 4:
+        # First day of week: Sunday, Week 1 is the first week containing 4 or more days, range 0-53
+        if j1_weekday <= 3:
+            expected = (dt - datetime.datetime(year, 1, 1) + datetime.timedelta(days=8+j1_weekday)).days // 7
+        else:
+            expected = (dt - datetime.datetime(year, 1, 1) + datetime.timedelta(days=j1_weekday+1)).days // 7
+
+    elif mode == 5:
+        # First day of week: Monday, Week 1 is the first week with a Monday, range 0-53
+        expected = (dt - datetime.datetime(year, 1, 1) - datetime.timedelta(days=first_monday)).days // 7 + 1
+
+    elif mode == 6:
+        # First day of week: Sunday, Week 1 is the first week containing 4 or more days, range 1-53
+        if j1_weekday <= 3:
+            expected = (dt - datetime.datetime(year, 1, 1) + datetime.timedelta(days=8+j1_weekday)).days // 7
+        else:
+            expected = (dt - datetime.datetime(year, 1, 1) + datetime.timedelta(days=j1_weekday+1)).days // 7
+        if expected == 0:
+            return to_week_compute_expected(datetime.datetime(dt.year-1, 12, 31), 6)
+
+    elif mode == 7:
+        # First day of week: Monday, Week 1 is the first week with a Monday, range 1-53
+        expected = (dt - datetime.datetime(year, 1, 1) - datetime.timedelta(days=first_monday)).days // 7 + 1
+        if expected == 0:
+            return to_week_compute_expected(datetime.datetime(dt.year-1, 12, 31), 7)
+
+    elif mode == 8:
+        # First day of week: Sunday, Week 1 is the week containing January 1, range 1-53
+        expected = (dt - datetime.datetime(year, 1, 1) + datetime.timedelta(days=(j1_weekday+1)%7)).days // 7 + 1
+
+    elif mode == 9:
+        # First day of week: Monday, Week 1 is the week containing January 1, range 1-53
+        expected = (dt - datetime.datetime(year, 1, 1) + datetime.timedelta(days=j1_weekday%7)).days // 7 + 1
+
+    return f"{dt.year}{str(expected).zfill(2)}" if ret_year else f"{expected}"
+
+
+@TestOutline
+def to_week_year_week(self, clh_func, ret_year):
+    """Check the toWeek/toYearWeek function with DateTime64 extended range.
+    For detailed info on work modes and description, see
+    https://clickhouse.tech/docs/en/sql-reference/functions/date-time-functions/#toweekdatemode
+    :param self: current test
+    :param clh_func: ClickHouse function to be called, string
+    :param ret_year: toWeek/toYearWeek selector, Boolean
+    """
+    stress = self.context.stress
+    timezones = timezones_range(stress)
+
+    for year in years_range(stress):
+        with Given(f"I choose datetimes in {year}"):
+            datetimes = select_dates_in_year(year=year, stress=stress)
+
+        with When("I check each of the datetimes"):
+            for dt in datetimes:
+                for tz in timezones:
+                    for mode in range(0, 10):
+                        with When(f"{dt} {tz}, mode={mode}"):
+                            with By("Computing expected output using python"):
+                                expected = to_week_compute_expected(dt=dt, mode=mode, ret_year=ret_year)
+                            with And(f"Forming a {clh_func} query"):
+                                dt_str = dt.strftime("%Y-%m-%d %H:%M:%S")
+                                query = f"SELECT {clh_func}(toDateTime64('{dt_str}', 0, '{tz}'), {mode})"
+                            with When(f"I execute the {clh_func} query"):
+                                exec_query(request=query, expected=f"{expected}")
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toWeek("1.0")
+)
+def to_week(self):
+    """Check the toWeek function with DateTime64 extended range."""
+    to_week_year_week(clh_func="toWeek", ret_year=False)
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toYearWeek("1.0")
+)
+def to_year_week(self):
+    """Check the toYearWeek function with DateTime64 extended range."""
+    to_week_year_week(clh_func="toYearWeek", ret_year=True)
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toYYYYMM("1.0")
+)
+def to_yyyymm(self):
+    """Check the toYYYYMM() function with
+    DateTime64 extended range.
+    """
+    stress = self.context.stress
+    timezones = timezones_range(stress)
+
+    for year in years_range(stress):
+        with Given(f"I choose datetimes in {year}"):
+            datetimes = select_dates_in_year(year=year, stress=stress)
+
+        with When("I check each of the datetimes"):
+            for dt in datetimes:
+                for tz in timezones:
+                    with Step(f"{dt} {tz}"):
+                        with By("computing expected result in python"):
+                            expected = f"{dt.strftime('%Y%m')}"
+                        with And("forming ClickHouse query"):
+                            dt_str = dt.strftime("%Y-%m-%d %H:%M:%S")
+                            query = f"SELECT toYYYYMM(toDateTime64('{dt_str}', 0, '{tz}'))"
+                        with Then("I execute query"):
+                            exec_query(request=query, expected=f"{expected}")
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toYYYYMMDD("1.0")
+)
+def to_yyyymmdd(self):
+    """Check the toYYYYMMDD() function with
+    DateTime64 extended range.
+    """
+    stress = self.context.stress
+    timezones = timezones_range(stress)
+
+    for year in years_range(stress):
+        with Given(f"I choose datetimes in {year}"):
+            datetimes = select_dates_in_year(year=year, stress=stress)
+
+        with When("I check each of the datetimes"):
+            for dt in datetimes:
+                for tz in timezones:
+                    with Step(f"{dt} {tz}"):
+                        with By("computing expected result in python"):
+                            expected = f"{dt.strftime('%Y%m%d')}"
+                        with And("forming ClickHouse query"):
+                            dt_str = dt.strftime("%Y-%m-%d %H:%M:%S")
+                            query = f"SELECT toYYYYMMDD(toDateTime64('{dt_str}', 0, '{tz}'))"
+                        with Then("I execute query", description=f"expected {expected}", flags=TE):
+                            exec_query(request=query, expected=f"{expected}")
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_toYYYYMMDDhhmmss("1.0")
+)
+def to_yyyymmddhhmmss(self):
+    """Check the toYYYYMMDDhhmmss() function with
+    DateTime64 extended range.
+    """
+    stress = self.context.stress
+    timezones = timezones_range(stress)
+
+    for year in years_range(stress):
+        with Given(f"I choose datetimes in {year}"):
+            datetimes = select_dates_in_year(year=year, stress=stress)
+
+        with When("I check each of the datetimes"):
+            for dt in datetimes:
+                for tz in timezones:
+                    with Step(f"{dt} {tz}"):
+                        with By("computing expected result in python"):
+                            expected = f"{dt.strftime('%Y%m%d%H%M%S')}"
+                        with And("forming ClickHouse query"):
+                            dt_str = dt.strftime("%Y-%m-%d %H:%M:%S")
+                            query = f"SELECT toYYYYMMDDhhmmss(toDateTime64('{dt_str}', 0, '{tz}'))"
+                        with Then("I execute query"):
+                            exec_query(request=query, expected=f"{expected}")
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_now("1.0")
+)
+def now(self):
+    """Check the now() conversion to DateTime64 extended range.
+    In this test, we cannot assure that pytz now() and ClickHouse now() will be executed at the same time, so we need
+    a 30-second error tolerance to test this functionality
+    """
+    stress = self.context.stress
+    timezones = timezones_range(stress)
+
+    for tz in timezones:
+        with Given("I record current time and localize it"):
+            dt = datetime.datetime.now()
+            dt = dt.astimezone(pytz.timezone(tz))
+
+        with Step(f"{dt} {tz}"):
+            with When("I execute query and format its result to string"):
+                r = self.context.node.query(f"SELECT toDateTime64(now(), 0, '{tz}')")
+                query_result = r.output
+                received_dt = datetime.datetime.strptime(query_result, '%Y-%m-%d %H:%M:%S')
+
+            with Then("I compute the difference between ClickHouse query result and pytz result"):
+                dt = dt.replace(tzinfo=None)
+                if dt < received_dt:
+                    diff = (received_dt - dt).total_seconds()
+                else:
+                    diff = (dt - received_dt).total_seconds()
+
+            with Finally(f"I expect {diff} < 30 seconds"):
+                assert diff < 30, error()
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_today("1.0")
+)
+def today(self):
+    """Check the today() conversion to DateTime64 extended range.
+    """
+    stress = self.context.stress
+    timezones = timezones_range(stress)
+
+    for tz in timezones:
+        with Given("I record current time and localize it"):
+            dt = datetime.datetime.now()
+            dt = dt.astimezone(pytz.timezone(tz))
+
+        with Step(f"{dt} {tz}"):
+            with When("I execute query and format its result to string"):
+                r = self.context.node.query(f"SELECT toDateTime64(today(), 0, '{tz}')")
+                query_result = r.output
+                received_dt = datetime.datetime.strptime(query_result, '%Y-%m-%d %H:%M:%S')
+
+            with Then("I compute the difference between ClickHouse query result and pytz result"):
+                dt = dt.replace(tzinfo=None)
+                if dt < received_dt:
+                    diff = (received_dt - dt).total_seconds()
+                else:
+                    diff = (dt - received_dt).total_seconds()
+
+            with Finally(f"I expect {diff} < 24 hours"):
+                assert diff < 86400, error()
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_yesterday("1.0")
+)
+def yesterday(self):
+    """Check the yesterday() conversion to DateTime64 extended range.
+    """
+
+    stress = self.context.stress
+    timezones = timezones_range(stress)
+
+    for tz in timezones:
+        with Given("I record current time and localize it"):
+            dt = datetime.datetime.now()
+            dt = dt.astimezone(pytz.timezone(tz))
+
+        with Step(f"{dt} {tz}"):
+            with When("I execute query and format its result to string"):
+                r = self.context.node.query(f"SELECT toDateTime64(yesterday(), 0, '{tz}')")
+                query_result = r.output
+                received_dt = datetime.datetime.strptime(query_result, '%Y-%m-%d %H:%M:%S')
+
+            with Then("I compute the difference between ClickHouse query result and pytz result"):
+                dt = dt.replace(tzinfo=None)
+                dt -= datetime.timedelta(days=1)
+                if dt < received_dt:
+                    diff = (received_dt - dt).total_seconds()
+                else:
+                    diff = (dt - received_dt).total_seconds()
+
+            with Finally(f"I expect {diff} < 48 hours (172800 seconds)"):
+                assert diff < 172800, error()
+
+
+@TestOutline
+def add_subtract_functions(self, clh_func, py_key, test_range, years_padding=(1, 1), modifier=1, mult=1):
+    """Check the addYears/addMonths/addWeeks/addDays/addHours/addMinutes/addSeconds with DateTime64 extended range.
+    Calculating expected result using eval() to avoid writing 9000+ comparisons and just parse string as object field name.
+    :param self: self
+    :param clh_func: ClickHouse function to be called, string
+    :param py_key: relativedelta parameter used to modify datetime, string
+    :param test_range: range of increments to be used, any iterable ints structure
+    :param years_padding: a number of years to be padded from the border, tuple[int, int]
+    :param modifier: a modifier to calculate [add/subtract]Quarters(), [add/subtract]Weeks()
+    :param mult: +/- selector
+    """
+    stress = self.context.stress
+    timezones = timezones_range(stress)
+
+    for year in years_range(stress=stress, padding=years_padding):
+        with Given(f"I choose datetimes in {year}"):
+            datetimes = select_dates_in_year(year=year, stress=stress)
+
+        with When("I check each of the datetimes"):
+            for dt in datetimes:
+                for tz in timezones:
+                    for incr in test_range:
+                        with Step(f"{dt} {tz}"):
+                            with By("converting datetime to string"):
+                                dt_str = dt.strftime("%Y-%m-%d %H:%M:%S")
+                            with And("computing the expected result using pytz"):
+                                dt_new = dt + rd.relativedelta(**{py_key: mult*incr*modifier})
+                                tzone = pytz.timezone(tz)
+                                dt_norm = tzone.normalize(tzone.localize(dt_new))
+                                expected = f"{dt_norm.strftime('%Y-%m-%d %H:%M:%S')}"
+                            with And("making a query string for ClickHouse"):
+                                query = f"SELECT {clh_func}(toDateTime64('{dt_str}', 0, '{tz}'), {incr})"
+                            with Then("I execute query"):
+                                exec_query(request=query, expected=f"{expected}")
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_addYears("1.0")
+)
+def add_years(self):
+    """Check the addYears function with DateTime64 extended range."""
+    add_subtract_functions(clh_func="addYears", py_key="years", test_range=(0, 1), years_padding=(0, 1))
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_subtractYears("1.0")
+)
+def subtract_years(self):
+    """Check the subtractYears function with DateTime64 extended range."""
+    add_subtract_functions(clh_func="subtractYears", py_key="years", test_range=(0, 1), years_padding=(1, 0), mult=-1)
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_addQuarters("1.0")
+)
+def add_quarters(self):
+    """Check the addQuarters function with DateTime64 extended range."""
+    add_subtract_functions(clh_func="addQuarters", py_key="months", test_range=range(1, 5), years_padding=(0, 1), modifier=3)
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_subtractQuarters("1.0")
+)
+def subtract_quarters(self):
+    """Check the subtractQuarters function with DateTime64 extended range."""
+    add_subtract_functions(clh_func="subtractQuarters", py_key="months", test_range=range(1, 5), years_padding=(1, 0), modifier=3, mult=-1)
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_addMonths("1.0")
+)
+def add_months(self):
+    """Check the addMonths function with DateTime64 extended range."""
+    add_subtract_functions(clh_func="addMonths", py_key="months", test_range=range(1, 13), years_padding=(0, 1))
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_subtractMonths("1.0")
+)
+def subtract_months(self):
+    """Check the subtractMonths function with DateTime64 extended range."""
+    add_subtract_functions(clh_func="subtractMonths", py_key="months", test_range=range(1, 13), years_padding=(1, 0), mult=-1)
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_addWeeks("1.0")
+)
+def add_weeks(self):
+    """Check the addWeeks function with DateTime64 extended range."""
+    add_subtract_functions(clh_func="addWeeks", py_key="days", test_range=range(6), years_padding=(0, 1), modifier=7)
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_subtractWeeks("1.0")
+)
+def subtract_weeks(self):
+    """Check the subtractWeeks function with DateTime64 extended range."""
+    add_subtract_functions(clh_func="subtractWeeks", py_key="days", test_range=range(6), years_padding=(1, 0), modifier=7, mult=-1)
+
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_addDays("1.0")
+)
+def add_days(self):
+    """Check the addDays function work with DateTime64 extended range"""
+    add_subtract_functions(clh_func="addDays", py_key="days", test_range=range(50))
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_subtractDays("1.0")
+)
+def subtract_days(self):
+    """Check the subtractDays function work with DateTime64 extended range"""
+    add_subtract_functions(clh_func="subtractDays", py_key="days", test_range=range(50), mult=-1)
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_addHours("1.0")
+)
+def add_hours(self):
+    """Check the addHours function work with DateTime64 extended range"""
+    add_subtract_functions(clh_func="addHours", py_key="hours", test_range=range(25))
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_subtractHours("1.0")
+)
+def subtract_hours(self):
+    """Check the subtractHours function work with DateTime64 extended range"""
+    add_subtract_functions(clh_func="subtractHours", py_key="hours", test_range=range(25), mult=-1)
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_addMinutes("1.0")
+)
+def add_minutes(self):
+    """Check the addMinutes function work with DateTime64 extended range"""
+    add_subtract_functions(clh_func="addMinutes", py_key="minutes", test_range=range(60))
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_subtractMinutes("1.0")
+)
+def subtract_minutes(self):
+    """Check the subtractMinutes function work with DateTime64 extended range"""
+    add_subtract_functions(clh_func="subtractMinutes", py_key="minutes", test_range=range(60), mult=-1)
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_addSeconds("1.0")
+)
+def add_seconds(self):
+    """Check the addSeconds function work with DateTime64 extended range"""
+    add_subtract_functions(clh_func="addSeconds", py_key="seconds", test_range=range(60))
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_subtractSeconds("1.0")
+)
+def subtract_seconds(self):
+    """Check the subtractSeconds function work with DateTime64 extended range"""
+    add_subtract_functions(clh_func="subtractSeconds", py_key="seconds", test_range=range(60), mult=-1)
+
+
+def date_diff_helper(dt1, dt2: datetime.datetime, unit: str):
+    """Helper for computing dateDiff expected result using Python.
+    """
+    delta = dt2 - dt1
+    if unit == "second":
+        return delta.total_seconds()
+    elif unit == "minute":
+        return delta.total_seconds() // 60
+    elif unit == "hour":
+        return delta.total_seconds() // 3600
+    elif unit == "day":
+        return delta.total_seconds() // 86400
+    elif unit == "week":
+        return delta.total_seconds() // 604800
+    elif unit == "month":
+        return (dt2.year - dt1.year) * 12 + (dt2.month - dt1.month)
+    elif unit == "quarter":
+        return ((dt2.year - dt1.year) * 12 + (dt2.month - dt1.month)) // 3
+    elif unit == "year":
+        return dt2.year - dt1.year
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_dateDiff("1.0")
+)
+def date_diff(self):
+    """Check how dateDiff works with DateTime64 extended range.
+    """
+    stress = self.context.stress
+    compare_units = ("second", "minute", "hour", "day", "week", "month", "quarter", "year")
+    timezones = timezones_range(stress=stress)
+
+    with Background("I select a set of datetimes to be compared"):
+        datetimes = []
+        for year in years_range(stress=stress):
+            datetimes += list(select_dates_in_year(year=year, stress=stress))
+
+    for dt_1, dt_2 in itertools.product(datetimes, datetimes):
+        for tz in timezones:
+            dt1_str = dt_1.strftime("%Y-%m-%d %H:%M:%S")
+            dt2_str = dt_2.strftime("%Y-%m-%d %H:%M:%S")
+            dt1 = pytz.timezone(tz).localize(dt_1)
+            dt2 = pytz.timezone(tz).localize(dt_2)
+
+            for unit in compare_units:
+                with Given(f"{unit}: {dt1_str} {dt2_str}, {tz}"):
+                    with When("I compute expected result with Pythons"):
+                        expected = date_diff_helper(dt1=dt1, dt2=dt2, unit=unit)
+                    with Then(f"I check dateDiff {dt1_str} {dt2_str} in {unit}"):
+                        query = f"SELECT dateDiff('{unit}', toDateTime64('{dt1_str}', 0, '{tz}'), toDateTime64('{dt2_str}', 0, '{tz}'))"
+                        exec_query(request=query, expected=expected)
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_formatDateTime("1.0")
+)
+def format_date_time(self):
+    """Test formatDateTime() when DateTime64 is out of normal range.
+     This function formats DateTime according to a given Format string.
+     """
+    stress = self.context.stress
+    timezones = timezones_range(stress)
+
+    modes = ('C', 'd', 'D', 'e', 'F', 'G', 'g', 'H', 'I', 'j', 'm', 'M', 'n',
+             'p', 'R', 'S', 't', 'T', 'u', 'V', 'w', 'y', 'Y', '%')
+
+    for year in years_range(stress=stress):
+        with Given(f"I choose datetimes in {year}"):
+            datetimes = select_dates_in_year(year=year, stress=stress)
+
+        with And("I format the datetimes in every possible way"):
+            for dt in datetimes:
+                for tz in timezones:
+                    for mode in modes:
+                        with When(f"{dt} {tz}, format '%{mode}"):
+                            with By("converting datetime to string"):
+                                dt_str = dt.strftime("%Y-%m-%d %H:%M:%S")
+                            with And("computing the expected result using python"):
+                                expected = f"{dt.strftime(f'%{mode}')}"
+                            with And("making a query string for ClickHouse"):
+                                query = f"SELECT formatDateTime(toDateTime64('{dt_str}', 0, '{tz}'), '%{mode}')"
+                            with Then("I execute formatDateTime() query"):
+                                exec_query(request=query, expected=f"{expected}")
+
+
+def time_slots_get_expected(dt: datetime.datetime, duration, size=1800):
+    """Helper to compute expected array for timeSlots().
+    """
+    zero_time = datetime.datetime(1970, 1, 1, 0, 0, 0)
+
+    result = [(zero_time + datetime.timedelta(seconds=((dt - zero_time).total_seconds() // size * size))).strftime("%Y-%m-%d %H:%M:%S")]
+
+    s = 1
+    while s <= duration:
+        delta = dt - zero_time + datetime.timedelta(seconds=s)
+        seconds_rounded = delta.total_seconds() // size * size
+        r = zero_time + datetime.timedelta(seconds=seconds_rounded)
+        r_str = r.strftime("%Y-%m-%d %H:%M:%S")
+        if r_str not in result:
+            result.append(r_str)
+            s += size
+        else:
+            s += 1
+    return result
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions_timeSlots("1.0")
+)
+def time_slots(self):
+    """Check the timeSlots function with DateTime64 extended range.
+    syntax: timeSlots(StartTime, Duration _seconds_ [, Size _seconds_])
+    """
+    stress = self.context.stress
+
+    for year in years_range(stress=stress):
+        with Given(f"I choose datetimes in {year}"):
+            datetimes = select_dates_in_year(year=year, stress=stress)
+        with When("I check each of the datetimes"):
+            for dt in datetimes:
+                for duration in range(1, 100, 9):
+                    for size in range(1, 50, 3):
+                        with Step(f"{dt}, dur={duration}, size={size}"):
+                            with By("getting an expected array using python"):
+                                expected = time_slots_get_expected(dt=dt, duration=duration, size=size)
+                            with And("forming a ClickHouse query"):
+                                dt_str = dt.strftime("%Y-%m-%d %H:%M:%S")
+                                query = f"SELECT timeSlots(toDateTime64('{dt_str}', 0, 'UTC'), toUInt32({duration}), {size})"
+                            with Then("I execute query"):
+                                try:
+                                    assert eval(self.context.node.query(query).output) == expected, error()
+                                except SyntaxError:
+                                    assert False
+
+
+@TestFeature
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_DatesAndTimesFunctions("1.0")
+)
+def date_time_funcs(self, node="clickhouse1"):
+    """Check the basic operations with DateTime64
+    """
+    self.context.node = self.context.cluster.node(node)
+
+    for scenario in loads(current_module(), Scenario):
+        Scenario(run=scenario, flags=TE)
diff --git a/tests/testflows/datetime64_extended_range/tests/generic.py b/tests/testflows/datetime64_extended_range/tests/generic.py
new file mode 100644
index 00000000000..4404c4a7411
--- /dev/null
+++ b/tests/testflows/datetime64_extended_range/tests/generic.py
@@ -0,0 +1,151 @@
+from testflows.core import *
+
+from datetime64_extended_range.requirements.requirements import *
+from datetime64_extended_range.common import *
+from datetime64_extended_range.tests.common import *
+
+import pytz
+import datetime
+import itertools
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_NormalRange_Start("1.0"),
+)
+def normal_range_start(self):
+    """Check DateTime64 can accept a dates around the start of the normal range that begins at 1970-01-01 00:00:00.000.
+    """
+    with When("I do incrementing time sweep", description="check different time points in the first 24 hours at given date"):
+        walk_datetime_in_incrementing_steps(date="1970-01-01", precision=3, hrs_range=(0, 24))
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_NormalRange_End("1.0")
+)
+def normal_range_end(self):
+    """Check DateTime64 can accept a dates around the end of the normal range that ends at 2105-12-31 23:59:59.99999.
+    """
+    with When("I do decrementing time sweep",
+            description="check different time points in the last 24 hours at given date"):
+        walk_datetime_in_decrementing_steps(date="2105-12-31", precision=3, hrs_range=(23, 0))
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_Start("1.0")
+)
+def extended_range_start(self):
+    """Check DateTime64 supports dates around the beginning of the extended range that begins at 1698-01-01 00:00:00.000000.
+    """
+    with When("I do incrementing time sweep",
+            description="check different time points in the first 24 hours at given date"):
+        walk_datetime_in_incrementing_steps(date="1925-01-01", precision=5, hrs_range=(0, 24))
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_End("1.0")
+)
+def extended_range_end(self, precision=3):
+    """Check DateTime64 supports dates around the beginning of the extended range that ends at 2377-12-31T23:59:59.999999.
+    """
+    with When("I do decrementing time sweep",
+            description="check different time points in the last 24 hours at given date"):
+        walk_datetime_in_decrementing_steps(date="2238-12-31", precision=5, hrs_range=(23, 0))
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_NormalRange_Start_BeforeEpochForTimeZone("1.0")
+)
+def timezone_local_below_normal_range(self):
+    """Check how UTC normal range time value treated
+    when current timezone time value is out of normal range.
+    """
+    with When("I do incrementing time sweep",
+            description="check different time points when UTC datetime fits normal range but below it for local datetime"):
+        walk_datetime_in_incrementing_steps(date="1969-12-31", hrs_range=(17, 24), timezone='America/Phoenix')
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_NormalRange_End_AfterEpochForTimeZone("1.0")
+)
+def timezone_local_above_normal_range(self):
+    """Check how UTC normal range time value treated
+    when current timezone time value is out of normal range.
+    """
+    with When("I do decrementing time sweep",
+              description="check different time points when UTC datetime fits normal range but above it for local datetime"):
+        walk_datetime_in_decrementing_steps(date="2106-01-01", hrs_range=(6, 0), timezone='Asia/Novosibirsk')
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_Comparison("1.0")
+)
+def comparison_check(self):
+    """Check how comparison works with DateTime64 extended range.
+    """
+    stress = self.context.stress
+    comparators = (">", "<", "==", "<=", ">=", "!=")
+    timezones = timezones_range(stress=stress)
+    datetimes = []
+
+    for year in years_range(stress=stress):
+        datetimes += list(select_dates_in_year(year=year, stress=stress))
+
+    for dt_1, dt_2 in itertools.product(datetimes, datetimes):
+        for tz1, tz2 in itertools.product(timezones, timezones):
+            dt1_str = dt_1.strftime("%Y-%m-%d %H:%M:%S")
+            dt2_str = dt_2.strftime("%Y-%m-%d %H:%M:%S")
+            dt1 = pytz.timezone(tz1).localize(dt_1)
+            dt2 = pytz.timezone(tz2).localize(dt_2)
+
+            with When(f"{dt1_str} {tz1}, {dt2_str} {tz2}"):
+                for c in comparators:
+                    expr = f"dt1 {c} dt2"
+                    expected = str(int(eval(expr)))
+                    with Then(f"I check {dt1_str} {c} {dt2_str}"):
+                        query = f"SELECT toDateTime64('{dt1_str}', 0, '{tz1}') {c} toDateTime64('{dt2_str}', 0, '{tz2}')"
+                        exec_query(request=query, expected=expected)
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_TimeZones("1.0")
+)
+def timezones_support(self):
+    """Check how timezones work with DateTime64 extended range.
+    """
+    stress = self.context.stress
+    timezones = timezones_range(stress=stress)
+
+    for year in years_range(stress):
+        with Given("I select datetimes in a year"):
+            datetimes = select_dates_in_year(year=year, stress=stress)
+
+        for dt in datetimes:
+            for tz in timezones:
+                with Step(f"{dt} {tz}"):
+                    with By("computing expected output using python"):
+                        dt_str = dt.strftime("%Y-%m-%d %H:%M:%S")
+                    with And("forming a toTimeZone ClickHouse query"):
+                        query = f"SELECT toDateTime64('{dt_str}', 0, '{tz}')"
+                    with Then(f"I execute query", flags=TE):
+                        exec_query(request=query, expected=f"{dt_str}")
+
+
+
+
+
+
+@TestFeature
+def generic(self, node="clickhouse1"):
+    """Check the basic operations with DateTime64
+    """
+    self.context.node = self.context.cluster.node(node)
+
+    for scenario in loads(current_module(), Scenario, Suite):
+        Scenario(run=scenario, flags=TE)
diff --git a/tests/testflows/datetime64_extended_range/tests/non_existent_time.py b/tests/testflows/datetime64_extended_range/tests/non_existent_time.py
new file mode 100644
index 00000000000..38f23269274
--- /dev/null
+++ b/tests/testflows/datetime64_extended_range/tests/non_existent_time.py
@@ -0,0 +1,164 @@
+from testflows.core import *
+import datetime
+
+from datetime64_extended_range.requirements.requirements import *
+from datetime64_extended_range.tests.common import *
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_NonExistentTime_InvalidDate("1.0")
+)
+def invalid_date(self):
+    """Check how non-existent date is treated.
+    For example, check 31st day in month that only has 30 days.
+    """
+    date_range = [1930, 1980, 2230]
+
+    if self.context.stress:
+        date_range = range(1925, 2238)
+
+    with When("I check 31st day of a 30-day month"):
+        for year in date_range:
+            for month in (4, 6, 9, 11):
+                datetime = f"{year}-{str(month).zfill(2)}-31 12:23:34"
+                expected = f"{year}-{str(month + 1).zfill(2)}-01 12:23:34"
+
+                with Then(f"{datetime}", description=f"expected {expected}", flags=TE):
+                    select_check_datetime(datetime=datetime, expected=expected)
+
+
+@TestOutline(Suite)
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_NonExistentTime_InvalidTime("1.0")
+)
+@Examples(
+    "datetime expected timezone", [
+        ('2002-04-07 02:30:00', '2002-04-07 01:30:00', 'America/New_York'),
+        ('2020-03-29 02:30:00', '2020-03-29 01:30:00', 'Europe/Zurich'),
+        ('2017-03-26 02:30:00', '2017-03-26 01:30:00', 'Europe/Berlin')
+    ])
+def invalid_time(self, datetime, expected, timezone='UTC'):
+    """proper handling of invalid time for a timezone
+    when using DateTime64 extended range data type, for example,
+    2:30am on 7th April 2002 never happened at all in the US/Eastern timezone,
+    """
+    with When(f"I check non-existent datetime {datetime}"):
+        select_check_datetime(datetime=datetime, expected=expected, timezone=timezone)
+
+
+@TestOutline(Scenario)
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_NonExistentTime_DaylightSavingTime("1.0"),
+    RQ_SRS_010_DateTime64_ExtendedRange_NonExistentTime_DaylightSavingTime_Disappeared("1.0")
+)
+@Examples(
+    "tz time_dates", [
+        ('America/Denver', {'02:30:00': ('2018-03-11', '2020-03-08', '1980-04-27', '1942-02-09')}),
+        ('Europe/Zurich', {'02:30:00': ('2016-03-27', '2020-03-29', '1981-03-29'), '01:30:00': ('1942-05-04', )})
+])
+def dst_disappeared(self, tz, time_dates):
+    """Proper handling of switching DST, when an hour is being skipped.
+    Testing in 2 steps: first, try to make a DateTime64 with skipped time value.
+    Second, adding interval so that result is in the skipped time.
+    """
+    for time, dates in time_dates.items():
+        for date in dates:
+            with Given(f"forming a datetime"):
+                dt_str = f"{date} {time}"
+                dt = datetime.datetime.strptime(dt_str, "%Y-%m-%d %H:%M:%S")
+            with Step("Assignment test"):
+                with When("computing expected result"):
+                    dt -= datetime.timedelta(hours=1)
+                    expected = dt.strftime("%Y-%m-%d %H:%M:%S")
+                with Then(f"I check skipped hour"):
+                    select_check_datetime(datetime=dt_str, expected=expected, timezone=tz)
+            with Step("Addition test"):
+                with When("computing expected result"):
+                    dt += datetime.timedelta(hours=2)
+                    expected = dt.strftime("%Y-%m-%d %H:%M:%S")
+                with Then(f"I check skipped hour"):
+                    query = f"SELECT addHours(toDateTime64('{dt_str}', 0, '{tz}'), 1)"
+                    exec_query(request=query, expected=f"{expected}")
+
+
+@TestOutline(Scenario)
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_NonExistentTime_LeapSeconds("1.0")
+)
+@Examples(
+    "datet years", [
+        ("06-30 23:59:55", [1972, 1981, 1982, 1983, 1985, 1992, 1993, 1994, 1997, 2012, 2015]),
+        ("12-31 23:59:55", [1972, 1973, 1974, 1975, 1976, 1977, 1978, 1979, 1987, 1989, 1990, 1995, 1998, 2005, 2008, 2016])
+])
+def leap_seconds(self, datet, years):
+    """Test proper handling of leap seconds. Read more: https://de.wikipedia.org/wiki/Schaltsekunde
+    Being checked by selecting a timestamp prior to leap second and adding seconds so that the result is after it.
+    """
+    for year in years:
+        with When(f"{datet}, {year}"):
+            with By("forming an expected result using python"):
+                dt_str = f"{year}-{datet}"
+                dt = datetime.datetime.strptime(dt_str, '%Y-%m-%d %H:%M:%S')
+                dt += datetime.timedelta(seconds=9)
+                expected = dt.strftime("%Y-%m-%d %H:%M:%S")
+            with And(f"forming a query"):
+                query = f"SELECT addSeconds(toDateTime64('{dt_str}', 0, 'UTC'), 10)"
+            with Then("executing query"):
+                exec_query(request=query, expected=f"{expected}")
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_NonExistentTime_DaylightSavingTime("1.0"),
+    RQ_SRS_010_DateTime64_ExtendedRange_NonExistentTime_TimeZoneSwitch("1.0")
+)
+def dst_time_zone_switch(self):
+    """Check how ClickHouse supports handling of invalid time when using DateTime64 extended range data type
+    when the invalid time is caused when countries switch timezone definitions with no daylight savings time switch.
+    """
+    stress = self.context.stress
+    timezones = timezones_range(stress)
+    utc = pytz.timezone("UTC")
+
+    for timezone in timezones:
+        if timezone == 'UTC':
+            continue
+        with Step(f"{timezone}"):
+            tz = pytz.timezone(timezone)
+            transition_times = tz._utc_transition_times
+            transition_info = tz._transition_info
+
+            for i in range(len(transition_times)-1, 0, -1):
+                if (transition_times[i] > datetime.datetime.now()) or (transition_times[i].year < 1925) or (transition_times[i].year > 2238):
+                    continue
+                with Step(f"{transition_times[i]}"):
+                    with By("localize python datetime"):
+                        dt = transition_times[i]
+                        dt0 = dt - datetime.timedelta(hours=4)
+                        dt0 = utc.localize(dt0).astimezone(tz).replace(tzinfo=None)
+                    with And("compute expected result using Pytz"):
+                        seconds_shift = transition_info[i][0] - transition_info[i-1][0]
+                        dt1 = dt0 + datetime.timedelta(hours=8) + seconds_shift
+                        dt0_str = dt0.strftime("%Y-%m-%d %H:%M:%S")
+                        dt1_str = dt1.strftime("%Y-%m-%d %H:%M:%S")
+                    with And("forming a ClickHouse query"):
+                        query = f"SELECT addHours(toDateTime64('{dt0_str}', 0, '{timezone}'), 8)"
+                    with Then("executing the query"):
+                        exec_query(request=query, expected=f"{dt1_str}")
+
+
+
+
+@TestFeature
+@Name("non existent time")
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_NonExistentTime("1.0")
+)
+def feature(self, node="clickhouse1"):
+    """Check how ClickHouse treats non-existent time in DateTime64 data type.
+    """
+    self.context.node = self.context.cluster.node(node)
+
+    for scenario in loads(current_module(), Scenario, Suite):
+        Scenario(run=scenario, flags=TE)
diff --git a/tests/testflows/datetime64_extended_range/tests/reference_times.py b/tests/testflows/datetime64_extended_range/tests/reference_times.py
new file mode 100644
index 00000000000..4d4762cc756
--- /dev/null
+++ b/tests/testflows/datetime64_extended_range/tests/reference_times.py
@@ -0,0 +1,38 @@
+import pytz
+from datetime import datetime
+
+from testflows.core import *
+from datetime64_extended_range.common import *
+from datetime64_extended_range.tests.common import select_check_datetime
+from datetime64_extended_range.requirements.requirements import *
+from datetime64_extended_range.tests.common import *
+
+
+@TestSuite
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_SpecificTimestamps("1.0")
+)
+def reference_times(self, node="clickhouse1"):
+    """Check how ClickHouse converts a set of particular timestamps
+    to DateTime64 for all timezones and compare the result to pytz.
+    """
+    self.context.node = self.context.cluster.node(node)
+
+    timestamps = [9961200, 73476000, 325666800, 354675600, 370400400, 386125200, 388566010, 401850000, 417574811,
+        496803600, 528253200, 624423614, 636516015, 671011200, 717555600, 752047218, 859683600, 922582800,
+        1018173600, 1035705600, 1143334800, 1162105223, 1174784400, 1194156000, 1206838823, 1224982823,
+        1236495624, 1319936400, 1319936424, 1425798025, 1459040400, 1509872400, 2090451627, 2140668000]
+
+    query = ""
+
+    for tz in pytz.all_timezones:
+        timezone = pytz.timezone(tz)
+        query += f"select '{tz}', arrayJoin(arrayFilter(x -> x.2 <> x.3, arrayMap(x -> tuple(x.1, x.2, toString(toDateTime64(x.1, 0, '{tz}'))), ["
+        need_comma = 0
+        for timestamp in timestamps:
+            for reference_timestamp in [timestamp - 1, timestamp, timestamp + 1]:
+                query += f"{',' if need_comma else ''}tuple({reference_timestamp},'{datetime.datetime.fromtimestamp(reference_timestamp, timezone).strftime('%Y-%m-%d %H:%M:%S')}')"
+                need_comma = 1
+        query += "] ) ) );"
+
+    exec_query(request=query, expected="")
diff --git a/tests/testflows/datetime64_extended_range/tests/type_conversion.py b/tests/testflows/datetime64_extended_range/tests/type_conversion.py
new file mode 100644
index 00000000000..f3d93bfa277
--- /dev/null
+++ b/tests/testflows/datetime64_extended_range/tests/type_conversion.py
@@ -0,0 +1,479 @@
+import time
+import pytz
+import decimal
+import itertools
+import numpy as np
+from dateutil.tz import tzlocal
+from datetime import datetime, timedelta
+import dateutil.relativedelta as rd
+from testflows.core import *
+
+from datetime64_extended_range.requirements.requirements import *
+from datetime64_extended_range.common import *
+from datetime64_extended_range.tests.common import *
+
+
+@TestOutline(Scenario)
+@Examples("cast", [
+    (False, Requirements(RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_toInt_8_16_32_64_128_256_("1.0"))),
+    (True, Requirements(RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_CAST_x_T_("1.0")))
+])
+def to_int_8_16_32_64_128_256(self, cast):
+    """Check the toInt(8|16|32|64|128|256) functions with DateTime64 extended range
+    """
+    stress = self.context.stress
+    timezones = timezones_range(stress)
+
+    for year in years_range(stress):
+        with Given("I select datetimes in a year"):
+            datetimes = select_dates_in_year(year=year, stress=stress)
+
+        for d in datetimes:
+            for tz in timezones:
+                dt = pytz.timezone(tz).localize(d)
+                for int_type in (8, 16, 32, 64, 128, 256):
+                    with When(f"{dt} {tz}, int{int_type}"):
+                        with By("converting datetime to string"):
+                            dt_str = dt.strftime("%Y-%m-%d %H:%M:%S")
+                        with And("computing the expected result using python"):
+                            py_res = int(time.mktime(dt.timetuple()))
+                            expected = f"{py_res}"
+                            if not (int_type == 128 or int_type == 256):
+                                """ALL dates fit into int128 and int256, so no need to check"""
+                                np_res = exec(f"np.int{int_type}({py_res})")
+                            else:
+                                np_res = py_res
+                        if np_res == py_res:
+                            with Given(f"{py_res} fits int{int_type}"):
+                                with When(f"making a query string for ClickHouse if py_res fits int{int_type}"):
+                                    if cast:
+                                        query = f"SELECT cast(toDateTime64('{dt_str}', 0, '{tz}'), 'Int{int_type}')"
+                                    else:
+                                        query = f"SELECT toInt{int_type}(toDateTime64('{dt_str}', 0, '{tz}'))"
+                                with Then(f"I execute toInt{int_type}() query"):
+                                    exec_query(request=query, expected=f"{expected}")
+
+
+@TestOutline(Scenario)
+@Examples("cast", [
+    (False, Requirements(RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_toUInt_8_16_32_64_256_("1.0"))),
+    (True, Requirements(RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_CAST_x_T_("1.0")))
+])
+def to_uint_8_16_32_64_256(self, cast):
+    """Check the toUInt(8|16|32|64|256) functions with DateTime64 extended range
+    """
+    stress = self.context.stress
+    timezones = timezones_range(stress)
+
+    for year in years_range(stress):
+        with Given("I select datetimes in a year"):
+            datetimes = select_dates_in_year(year=year, stress=stress)
+
+        for d in datetimes:
+            for tz in timezones:
+                dt = pytz.timezone(tz).localize(d)
+                for int_type in (8, 16, 32, 64, 256):
+                    with Step(f"{dt} {tz}, int{int_type}"):
+                        with By("converting datetime to string"):
+                            dt_str = dt.strftime("%Y-%m-%d %H:%M:%S")
+                        with And("computing the expected result using python"):
+                            py_res = int(time.mktime(dt.timetuple()))
+                            expected = f"{py_res}"
+                            if int_type != 256:
+                                """ALL dates fit into uint256, so no need to check"""
+                                np_res = exec(f"np.uint{int_type}({py_res})")
+                            else:
+                                np_res = py_res
+                        if np_res == py_res:
+                            with Given(f"{py_res} fits int{int_type}"):
+                                with When(f"making a query string for ClickHouse if py_res fits int{int_type}"):
+                                    if cast:
+                                        query = f"SELECT cast(toDateTime64('{dt_str}', 0, '{tz}'), 'UInt{int_type}')"
+                                    else:
+                                        query = f"SELECT toUInt{int_type}(toDateTime64('{dt_str}', 0, '{tz}'))"
+                                with Then(f"I execute toInt{int_type}() query"):
+                                    exec_query(request=query, expected=f"{expected}")
+
+
+@TestOutline(Scenario)
+@Examples("cast", [
+    (False, Requirements(RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_toFloat_32_64_("1.0"))),
+    (True, Requirements(RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_CAST_x_T_("1.0")))
+])
+def to_float_32_64(self, cast):
+    """Check the toFloat(32|64) functions with DateTime64 extended range
+    """
+    stress = self.context.stress
+    timezones = timezones_range(stress)
+
+    for year in years_range(stress):
+        with Given("I select datetimes in a year"):
+            datetimes = select_dates_in_year(year=year, stress=stress)
+
+        for d in datetimes:
+            for tz in timezones:
+                dt = pytz.timezone(tz).localize(d)
+                for float_type in (32, 64):
+                    with Step(f"{dt} {tz}, int{float_type}"):
+                        with By("converting datetime to string"):
+                            dt_str = dt.strftime("%Y-%m-%d %H:%M:%S")
+                        with And("computing the expected result using python"):
+                            py_res = int(time.mktime(dt.timetuple()))
+                            expected = f"{py_res}"
+                            np_res = exec(f"np.float{float_type}({py_res})")
+                        if np_res == py_res:
+                            with When(f"making a query string for ClickHouse"):
+                                if cast:
+                                    query = f"SELECT cast(toDateTime64('{dt_str}', 0, '{tz}'), 'Float{float_type}')"
+                                else:
+                                    query = f"SELECT toFloat{float_type}(toDateTime64('{dt_str}', 0, '{tz}'))"
+                            with Then(f"I execute toFloat{float_type}() query"):
+                                exec_query(request=query, expected=f"{expected}")
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_toDateTime64_FromString_MissingTime("1.0")
+)
+def to_datetime64_from_string_missing_time(self):
+    """Check the toDateTime64() with DateTime64 extended range conversion when string is missing the time part.
+    """
+    stress = self.context.stress
+    timezones = timezones_range(stress)
+
+    for year in years_range(stress):
+        with Given("I select datetimes in a year"):
+            datetimes = select_dates_in_year(year=year, stress=stress)
+
+        for dt in datetimes:
+            for tz in timezones:
+                with Step(f"{dt} {tz}"):
+                    with By("converting datetime to string"):
+                        dt_str = dt.strftime("%Y-%m-%d")
+                    with And("figure out expected result in python"):
+                        expected = f"{dt.strftime('%Y-%m-%d')} 00:00:00"
+                    with When(f"making a query string for ClickHouse"):
+                        query = f"SELECT toDateTime64('{dt_str}', 0, '{tz}')"
+                    with Then(f"I execute toDateTime64() query"):
+                        exec_query(request=query, expected=f"{expected}")
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_toDateTime64("1.0")
+)
+def to_datetime64(self):
+    """Check the toDateTime64() conversion with DateTime64. This is supposed to work in normal range ONLY.
+    """
+    stress = self.context.stress
+    timezones = timezones_range(stress)
+
+    for year in years_range(stress):
+        with Given("I select datetimes in a year"):
+            datetimes = select_dates_in_year(year=year, stress=stress)
+
+        for dt in datetimes:
+            for tz in timezones:
+                with By("converting datetime to string"):
+                    dt_str = dt.strftime("%Y-%m-%d %H:%M:%S")
+                with And(f"making a query string for ClickHouse"):
+                    query = f"SELECT toDateTime64('{dt_str}', 0, '{tz}')"
+                with When("figure out expected result in python"):
+                    expected = f"{dt.strftime('%Y-%m-%d %H:%M:%S')}"
+                with Then(f"I execute toDateTime64() query"):
+                    exec_query(request=query, expected=f"{expected}")
+
+
+@TestOutline(Scenario)
+@Examples("cast", [
+    (False, Requirements(RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_toDate("1.0"))),
+    (True, Requirements(RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_CAST_x_T_("1.0")))
+])
+def to_date(self, cast):
+    """Check the toDate() conversion with DateTime64. This is supposed to work in normal range ONLY.
+    """
+    stress = self.context.stress
+    timezones = timezones_range(stress)
+
+    for year in years_range(stress):
+        with Given("I select datetimes in a year"):
+            datetimes = select_dates_in_year(year=year, stress=stress)
+
+        for dt in datetimes:
+            for tz in timezones:
+                with Step(f"{dt} {tz}"):
+                    expected = None # by default - not checked, checking the exitcode
+                    with By("converting datetime to string"):
+                        dt_str = dt.strftime("%Y-%m-%d %H:%M:%S")
+
+                    if in_normal_range(dt):
+                        with And("DateTime64 fits normal range, change its value"):
+                            expected = f"{dt.strftime('%Y-%m-%d')}"  # being checked in case DateTime64 fits normal range
+
+                    with Given(f"I make a query string for ClickHouse"):
+                        if cast:
+                            query = f"SELECT CAST(toDateTime64('{dt_str}', 0, '{tz}'), 'Date')"
+                        else:
+                            query = f"SELECT toDate(toDateTime64('{dt_str}', 0, '{tz}'))"
+
+                    with Then(f"I execute toDate() query and check return/exitcode"):
+                        exec_query(request=query, expected=expected, exitcode=0)
+
+
+@TestOutline(Scenario)
+@Examples("cast", [
+    (False, Requirements(RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_toDateTime("1.0"))),
+    (True, Requirements(RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_CAST_x_T_("1.0")))
+])
+def to_datetime(self, cast):
+    """Check the toDateTime() conversion with DateTime64. This is supposed to work in normal range ONLY.
+    """
+    stress = self.context.stress
+    timezones = timezones_range(stress)
+
+    for year in years_range(stress):
+        with Given("I select datetimes in a year"):
+            datetimes = select_dates_in_year(year=year, stress=stress)
+
+        for dt in datetimes:
+            for tz in timezones:
+                with By("converting datetime to string"):
+                    dt_str = dt.strftime("%Y-%m-%d %H:%M:%S")
+                with And(f"making a query string for ClickHouse"):
+                    if cast:
+                        query = f"SELECT CAST(toDateTime64('{dt_str}', 0, '{tz}'), 'DateTime')"
+                        with When("figure out expected result in python"):
+                            dt_local = pytz.timezone(tz).localize(dt)
+                            dt_transformed = dt_local.astimezone(tzlocal())
+                            expected = f"{dt_transformed.strftime('%Y-%m-%d %H:%M:%S')}"
+                    else:
+                        query = f"SELECT toDateTime(toDateTime64('{dt_str}', 0, '{tz}'))"
+                        with When("figure out expected result in python"):
+                            expected = f"{dt.strftime('%Y-%m-%d %H:%M:%S')}"
+
+                if not in_normal_range(dt):
+                    with When(f"I execute toDateTime() query out of normal range"):
+                        exec_query(request=query, exitcode=0)
+                else:
+                    with When(f"I execute toDateTime() query"):
+                        exec_query(request=query, expected=f"{expected}")
+
+
+@TestOutline(Scenario)
+@Examples("cast", [
+    (False, Requirements(RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_toString("1.0"))),
+    (True, Requirements(RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_CAST_x_T_("1.0")))
+])
+def to_string(self, cast):
+    """Check the toString() with DateTime64 extended range.
+    """
+    stress = self.context.stress
+    timezones = timezones_range(stress)
+
+    for year in years_range(stress):
+        with Given("I select datetimes in a year"):
+            datetimes = select_dates_in_year(year=year, stress=stress)
+
+        for dt in datetimes:
+            for tz in timezones:
+                with Step(f"{dt} {tz}"):
+                    with By("converting datetime to string"):
+                        dt_str = dt.strftime("%Y-%m-%d %H:%M:%S")
+                    with When(f"making a query string for ClickHouse"):
+                        if cast:
+                            query = f"SELECT cast(toDateTime64('{dt_str}', 0, '{tz}'), 'String')"
+                        else:
+                            query = f"SELECT toString(toDateTime64('{dt_str}', 0, '{tz}'))"
+                    with Then(f"I execute toDateTime64() query"):
+                        exec_query(request=query, expected=f"{dt_str}")
+
+
+def valid_decimal_range(bit_depth, S):
+    """A helper to find valid range for Decimal(32|64|128|256) with given scale (S)"""
+    return {32: -1 * 10 ** (9 - S), 64: -1 * 10 ** (18 - S), 128: -1 * 10 ** (38 - S), 256: -1 * 10 ** (76 - S)}[
+        bit_depth]
+
+
+@TestOutline(Scenario)
+@Examples("cast", [
+    (False, Requirements(RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_toDecimal_32_64_128_256_("1.0"))),
+    (True, Requirements(RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_CAST_x_T_("1.0")))
+])
+def to_decimal_32_64_128_256(self, cast):
+    """Check the toDecimal(32|64|128|256) functions with DateTime64 extended range.
+    Decimal32(S) - ( -1 * 10^(9 - S), 1 * 10^(9 - S) )
+    Decimal64(S) - ( -1 * 10^(18 - S), 1 * 10^(18 - S) )
+    Decimal128(S) - ( -1 * 10^(38 - S), 1 * 10^(38 - S) )
+    Decimal256(S) - ( -1 * 10^(76 - S), 1 * 10^(76 - S) )
+    """
+    stress = self.context.stress
+    timezones = timezones_range(stress)
+    scales = {32: 9, 64: 18, 128: 38, 256: 76}
+
+    for year in years_range(stress):
+        with Given("I select datetimes in a year"):
+            datetimes = select_dates_in_year(year=year, stress=stress)
+
+        for d in datetimes:
+            for tz in timezones:
+                dt = pytz.timezone(tz).localize(d)
+                for decimal_type in (32, 64, 128, 256):
+                    for scale in range(scales[decimal_type]):
+                        with When(f"{dt} {tz}, Decimal{decimal_type}({scale})"):
+                            valid_range = valid_decimal_range(bit_depth=decimal_type, S=scale)
+                            with By("computing the expected result using python"):
+                                expected = decimal.Decimal(time.mktime(dt.timetuple()))
+                            if -valid_range < expected < valid_range:
+                                with And("converting datetime to string"):
+                                    dt_str = dt.strftime("%Y-%m-%d %H:%M:%S")
+                                with When(f"making a query string for ClickHouse"):
+                                    if cast:
+                                        query = f"SELECT cast(toDateTime64('{dt_str}', 0, '{tz}'), 'Decimal({decimal_type}, {scale})')"
+                                    else:
+                                        query = f"SELECT toDecimal{decimal_type}(toDateTime64('{dt_str}', 0, '{tz}'))"
+                                with Then(f"I execute toDecimal{decimal_type}() query"):
+                                    exec_query(request=query, expected=f"{expected}")
+
+
+@TestOutline
+def to_unix_timestamp64_milli_micro_nano(self, scale):
+    """Check the toUnixTimestamp64[Milli/Micro/Nano] functions with DateTime64 extended range.
+    :param scale: 3 for milli, 6 for micro, 9 for nano; int
+    """
+    stress = self.context.stress
+    timezones = timezones_range(stress)
+    func = {3: 'Milli', 6: 'Micro', 9: 'Nano'}
+
+    for year in years_range(stress):
+        with Given("I select datetimes in a year"):
+            datetimes = select_dates_in_year(year=year, stress=stress, microseconds=True)
+
+        for d in datetimes:
+            for tz in timezones:
+                dt = pytz.timezone(tz).localize(d)
+                with When(f"{dt} {tz}"):
+                    with By("converting datetime to string"):
+                        dt_str = dt.strftime("%Y-%m-%d %H:%M:%S.%f")
+                    with And("converting DateTime to UTC"):
+                        dt = dt.astimezone(pytz.timezone('UTC'))
+                    with And("computing the expected result using python"):
+                        expected = int(dt.timestamp() * (10**scale))
+                        if expected >= 0:
+                            expected += dt.microsecond * 10 ** (scale - 6)
+                        else:
+                            expected -= dt.microsecond * 10 ** (scale - 6)
+                    with When(f"making a query string for ClickHouse"):
+                        query = f"SELECT toUnixTimestamp64{func[scale]}(toDateTime64('{dt_str}', {scale}, '{tz}'))"
+                    with Then(f"I execute toUnixTimestamp64{func[scale]}() query"):
+                        exec_query(request=query, expected=f"{expected}")
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_toUnixTimestamp64Milli("1.0")
+)
+def to_unix_timestamp64_milli(self):
+    """Check the toUnixTimestamp64Milli functions with DateTime64 extended range.
+    """
+    to_unix_timestamp64_milli_micro_nano(scale=3)
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_toUnixTimestamp64Micro("1.0")
+)
+def to_unix_timestamp64_micro(self):
+    """Check the toUnixTimestamp64Micro functions with DateTime64 extended range.
+    """
+    to_unix_timestamp64_milli_micro_nano(scale=6)
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_toUnixTimestamp64Nano("1.0")
+)
+def to_unix_timestamp64_nano(self):
+    """Check the toUnixTimestamp64Nano functions with DateTime64 extended range.
+    """
+    to_unix_timestamp64_milli_micro_nano(scale=9)
+
+
+@TestOutline
+def from_unix_timestamp64_milli_micro_nano(self, scale):
+    """Check the fromUnixTimestamp64[Milli/Micro/Nano] functions with DateTime64 extended range.
+    :param scale: 3 for milli, 6 for micro, 9 for nano; int
+    """
+    stress = self.context.stress
+    timezones = timezones_range(stress)
+    func = {3: 'Milli', 6: 'Micro', 9: 'Nano'}
+
+    for year in years_range(stress):
+        with Given("I select datetimes in a year"):
+            datetimes = select_dates_in_year(year=year, stress=stress, microseconds=True)
+
+        for d in datetimes:
+            for tz in timezones:
+                dt = pytz.timezone(tz).localize(d)
+                with When(f"{dt} {tz}"):
+                    with By("converting datetime to string"):
+                        d_str = d.strftime("%Y-%m-%d %H:%M:%S.%f")
+                        d_str += "0" * (scale-3)
+                    with And("converting DateTime64 to UTC"):
+                        dt = dt.astimezone(pytz.timezone('UTC'))
+                    with And("computing the expected result using python"):
+                        ts = int(dt.timestamp() * (10**scale))
+                        if ts >= 0:
+                            ts += dt.microsecond * 10 ** (scale - 6)
+                        else:
+                            ts -= dt.microsecond * 10 ** (scale - 6)
+                    with And(f"making a query string for ClickHouse"):
+                        query = f"SELECT fromUnixTimestamp64{func[scale]}(CAST({ts}, 'Int64'), '{tz}')"
+                    with Then(f"I execute fromUnixTimestamp64{func[scale]}() query"):
+                        exec_query(request=query, expected=f"{d_str}")
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_fromUnixTimestamp64Milli("1.0")
+)
+def from_unix_timestamp64_milli(self):
+    """Check the fromUnixTimestamp64Milli functions with DateTime64 extended range.
+    """
+    from_unix_timestamp64_milli_micro_nano(scale=3)
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_fromUnixTimestamp64Micro("1.0")
+)
+def from_unix_timestamp64_micro(self):
+    """Check the fromUnixTimestamp64Micro functions with DateTime64 extended range.
+    """
+    from_unix_timestamp64_milli_micro_nano(scale=6)
+
+
+@TestScenario
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions_fromUnixTimestamp64Nano("1.0")
+)
+def from_unix_timestamp64_nano(self):
+    """Check the fromUnixTimestamp64Nano functions with DateTime64 extended range.
+    """
+    from_unix_timestamp64_milli_micro_nano(scale=9)
+
+
+
+
+
+@TestFeature
+@Requirements(
+    RQ_SRS_010_DateTime64_ExtendedRange_TypeConversionFunctions("1.0")
+)
+def type_conversion(self, node="clickhouse1"):
+    """Check the type conversion operations with DateTime64. Cast can be set as Requirement thereby as the module
+    tests exactly what CAST does.
+    """
+    self.context.node = self.context.cluster.node(node)
+
+    for scenario in loads(current_module(), Scenario):
+        Scenario(run=scenario, flags=TE)
diff --git a/tests/testflows/helpers/cluster.py b/tests/testflows/helpers/cluster.py
index cc676134024..be23559d9de 100755
--- a/tests/testflows/helpers/cluster.py
+++ b/tests/testflows/helpers/cluster.py
@@ -278,7 +278,7 @@ class Cluster(object):
         if not os.path.exists(docker_compose_file_path):
             raise TypeError("docker compose file '{docker_compose_file_path}' does not exist")
 
-        self.docker_compose += f" --no-ansi --project-directory \"{docker_compose_project_dir}\" --file \"{docker_compose_file_path}\""
+        self.docker_compose += f" --project-directory \"{docker_compose_project_dir}\" --file \"{docker_compose_file_path}\""
         self.lock = threading.Lock()
 
     def shell(self, node, timeout=300):
diff --git a/tests/testflows/regression.py b/tests/testflows/regression.py
index 9a919a91183..912ee3d58e5 100755
--- a/tests/testflows/regression.py
+++ b/tests/testflows/regression.py
@@ -19,7 +19,8 @@ def regression(self, local, clickhouse_binary_path, stress=None, parallel=None):
     # Feature(test=load("rbac.regression", "regression"))(**args)
     # Feature(test=load("aes_encryption.regression", "regression"))(**args)
     Feature(test=load("map_type.regression", "regression"))(**args)
-    # Feature(test=load("window_functions.regression", "regression"))(**args)
+    Feature(test=load("window_functions.regression", "regression"))(**args)
+    # Feature(test=load("datetime64_extended_range.regression", "regression"))(**args)
     # Feature(test=load("kerberos.regression", "regression"))(**args)
 
 if main():
diff --git a/tests/testflows/window_functions/requirements/requirements.md b/tests/testflows/window_functions/requirements/requirements.md
index 6136c1b3d92..1d6dbc28923 100644
--- a/tests/testflows/window_functions/requirements/requirements.md
+++ b/tests/testflows/window_functions/requirements/requirements.md
@@ -202,7 +202,13 @@ All the updates are tracked using the [Revision History].
 
 ## Introduction
 
-This software requirements specification covers requirements for `Map(key, value)` data type in [ClickHouse].
+This software requirements specification covers requirements for supporting window functions in [ClickHouse].
+Similar functionality exists in [MySQL] and [PostreSQL]. [PostreSQL] defines a window function as follows:
+
+> A window function performs a calculation across a set of table rows that are somehow related to the current row.
+> This is comparable to the type of calculation that can be done with an aggregate function.
+> But unlike regular aggregate functions, use of a window function does not cause rows to
+> become grouped into a single output row — the rows retain their separate identities.
 
 ## Requirements
 
@@ -2290,3 +2296,5 @@ version: 1.0
 [Revision History]: https://github.com/ClickHouse/ClickHouse/commits/master/tests/testflows/window_functions/requirements/requirements.md
 [Git]: https://git-scm.com/
 [GitHub]: https://github.com
+[PostreSQL]: https://www.postgresql.org/docs/9.2/tutorial-window.html
+[MySQL]: https://dev.mysql.com/doc/refman/8.0/en/window-functions.html
diff --git a/tests/testflows/window_functions/requirements/requirements.py b/tests/testflows/window_functions/requirements/requirements.py
index bfc3656ba6d..42389fd5452 100644
--- a/tests/testflows/window_functions/requirements/requirements.py
+++ b/tests/testflows/window_functions/requirements/requirements.py
@@ -1,6 +1,6 @@
 # These requirements were auto generated
 # from software requirements specification (SRS)
-# document by TestFlows v1.6.210312.1172513.
+# document by TestFlows v1.6.210505.1133630.
 # Do not edit by hand but re-generate instead
 # using 'tfs requirements generate' command.
 from testflows.core import Specification
@@ -3796,7 +3796,13 @@ All the updates are tracked using the [Revision History].
 
 ## Introduction
 
-This software requirements specification covers requirements for `Map(key, value)` data type in [ClickHouse].
+This software requirements specification covers requirements for supporting window functions in [ClickHouse].
+Similar functionality exists in [MySQL] and [PostreSQL]. [PostreSQL] defines a window function as follows:
+
+> A window function performs a calculation across a set of table rows that are somehow related to the current row.
+> This is comparable to the type of calculation that can be done with an aggregate function.
+> But unlike regular aggregate functions, use of a window function does not cause rows to
+> become grouped into a single output row — the rows retain their separate identities.
 
 ## Requirements
 
@@ -5884,4 +5890,6 @@ version: 1.0
 [Revision History]: https://github.com/ClickHouse/ClickHouse/commits/master/tests/testflows/window_functions/requirements/requirements.md
 [Git]: https://git-scm.com/
 [GitHub]: https://github.com
+[PostreSQL]: https://www.postgresql.org/docs/9.2/tutorial-window.html
+[MySQL]: https://dev.mysql.com/doc/refman/8.0/en/window-functions.html
 ''')
diff --git a/tests/testflows/window_functions/tests/common.py b/tests/testflows/window_functions/tests/common.py
index 075f76cf68b..ef694b19a0e 100644
--- a/tests/testflows/window_functions/tests/common.py
+++ b/tests/testflows/window_functions/tests/common.py
@@ -100,7 +100,7 @@ def t1_table(self, name="t1", distributed=False):
             create_table(name=name + "_source", statement=sql, on_cluster="sharded_cluster")
 
         with And("a distributed table"):
-            sql = "CREATE TABLE {name} AS " + name + '_source' + " ENGINE = Distributed(sharded_cluster, default, " + f"{name + '_source'}, rand())"
+            sql = "CREATE TABLE {name} AS " + name + '_source' + " ENGINE = Distributed(sharded_cluster, default, " + f"{name + '_source'}, f1 % toUInt8(getMacro('shard')))"
             table = create_table(name=name, statement=sql)
 
         with And("populating table with data"):
@@ -155,7 +155,7 @@ def datetimes_table(self, name="datetimes", distributed=False):
             create_table(name=name + "_source", statement=sql, on_cluster="sharded_cluster")
 
         with And("a distributed table"):
-            sql = "CREATE TABLE {name} AS " + name + '_source' + " ENGINE = Distributed(sharded_cluster, default, " + f"{name + '_source'}, rand())"
+            sql = "CREATE TABLE {name} AS " + name + '_source' + " ENGINE = Distributed(sharded_cluster, default, " + f"{name + '_source'}, id % toUInt8(getMacro('shard')))"
             table = create_table(name=name, statement=sql)
 
         with And("populating table with data"):
@@ -213,7 +213,7 @@ def numerics_table(self, name="numerics", distributed=False):
             create_table(name=name + "_source", statement=sql, on_cluster="sharded_cluster")
 
         with And("a distributed table"):
-            sql = "CREATE TABLE {name} AS " + name + '_source' + " ENGINE = Distributed(sharded_cluster, default, " + f"{name + '_source'}, rand())"
+            sql = "CREATE TABLE {name} AS " + name + '_source' + " ENGINE = Distributed(sharded_cluster, default, " + f"{name + '_source'}, id % toUInt8(getMacro('shard')))"
             table = create_table(name=name, statement=sql)
 
         with And("populating table with data"):
@@ -282,7 +282,7 @@ def tenk1_table(self, name="tenk1", distributed=False):
             create_table(name=name + '_source', statement=sql, on_cluster="sharded_cluster")
 
         with And("a distributed table"):
-            sql = "CREATE TABLE {name} AS " + name + '_source' + " ENGINE = Distributed(sharded_cluster, default, " + f"{name + '_source'}, rand())"
+            sql = "CREATE TABLE {name} AS " + name + '_source' + " ENGINE = Distributed(sharded_cluster, default, " + f"{name + '_source'}, unique1 % toUInt8(getMacro('shard')))"
             table = create_table(name=name, statement=sql)
 
         with And("populating table with data"):
@@ -353,7 +353,7 @@ def empsalary_table(self, name="empsalary", distributed=False):
                 create_table(name=name + "_source", statement=sql, on_cluster="sharded_cluster")
 
         with And("a distributed table"):
-            sql = "CREATE TABLE {name} AS " + name + '_source' + " ENGINE = Distributed(sharded_cluster, default, " + f"{name + '_source'}, rand())"
+            sql = "CREATE TABLE {name} AS " + name + '_source' + " ENGINE = Distributed(sharded_cluster, default, " + f"{name + '_source'}, empno % toUInt8(getMacro('shard')))"
             table = create_table(name=name, statement=sql)
 
         with And("populating distributed table with data"):
diff --git a/utils/list-versions/version_date.tsv b/utils/list-versions/version_date.tsv
index 0bd63c9bc46..dd6488cea9f 100644
--- a/utils/list-versions/version_date.tsv
+++ b/utils/list-versions/version_date.tsv
@@ -2,6 +2,7 @@ v21.4.6.55-stable	2021-04-30
 v21.4.5.46-stable	2021-04-24
 v21.4.4.30-stable	2021-04-16
 v21.4.3.21-stable	2021-04-12
+v21.3.10.1-lts	2021-05-09
 v21.3.9.83-lts	2021-04-28
 v21.3.8.76-lts	2021-04-24
 v21.3.7.62-stable	2021-04-16